安卓手机使用ChatGPT全指南：从安装到API调用的实战解析

11次阅读

共计 3996 个字符，预计需要花费 10 分钟才能阅读完成。

在移动端使用 ChatGPT 主要存在三种方式：官方 App、网页端和 API 集成。每种方式各有优劣：

官方 App：体验最流畅，但功能受限于官方提供的界面，无法深度定制。
网页端 ：无需安装，但受限于移动浏览器性能，交互体验可能不如原生 App。
API 集成 ：灵活性最高，可以深度定制功能，但开发复杂度较高，需要考虑网络请求、鉴权等问题。

如果用户已经安装了 ChatGPT 官方 App，可以通过 Intent 直接跳转：

创建 Intent 并设置包名

val intent = packageManager.getLaunchIntentForPackage("com.openai.chatgpt")
if (intent != null) {startActivity(intent)
} else {
    // 处理未安装情况
    fallbackToWebView()}

处理未安装情况的回退逻辑

private fun fallbackToWebView() {val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://chat.openai.com"))
    startActivity(intent)
}

在 WebView 中加载 ChatGPT 网页版时，需要优化 User-Agent 以确保最佳体验：

配置 WebView 设置

val webView = WebView(context)
val settings = webView.settings
settings.userAgentString = "Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.120 Mobile Safari/537.36"
settings.javaScriptEnabled = true

处理页面加载

webView.webViewClient = object : WebViewClient() {override fun shouldOverrideUrlLoading(view: WebView?, request: WebResourceRequest?): Boolean {return false}
}
webView.loadUrl("https://chat.openai.com")

对于需要深度集成的场景，可以直接调用 ChatGPT API：

添加 OkHttp 依赖

implementation "com.squareup.okhttp3:okhttp:4.10.0"

创建 OkHttpClient 并配置超时

val client = OkHttpClient.Builder()
    .connectTimeout(30, TimeUnit.SECONDS)
    .readTimeout(60, TimeUnit.SECONDS)
    .writeTimeout(30, TimeUnit.SECONDS)
    .build()

流式请求实现（Kotlin 协程版本）

suspend fun streamChatCompletion(request: ChatCompletionRequest): Flow<String> = flow {val json = Gson().toJson(request)
    val body = json.toRequestBody("application/json".toMediaType())
    val request = Request.Builder()
        .url("https://api.openai.com/v1/chat/completions")
        .post(body)
        .build()

    client.newCall(request).enqueue(object : Callback {override fun onFailure(call: Call, e: IOException) {// 错误处理}

        override fun onResponse(call: Call, response: Response) {response.body?.source()?.use { source ->
                while (!source.exhausted()) {val line = source.readUtf8Line()
                    line?.let {emit(it) }
                }
            }
        }
    })
}

RxJava 版本实现

Observable<String> streamChatCompletion(ChatCompletionRequest request) {
    return Observable.create(emitter -> {String json = new Gson().toJson(request);
        RequestBody body = RequestBody.create(json, MediaType.parse("application/json"));
        Request apiRequest = new Request.Builder()
            .url("https://api.openai.com/v1/chat/completions")
            .post(body)
            .build();

        client.newCall(apiRequest).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {emitter.onError(e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {try (BufferedSource source = response.body().source()) {while (!source.exhausted()) {String line = source.readUtf8Line();
                        if (line != null) {emitter.onNext(line);
                        }
                    }
                    emitter.onComplete();}
            }
        });
    });
}

永远不要将 API 密钥硬编码在客户端代码中
考虑使用后端服务作为代理，客户端只获取临时 token
使用 Android 的 Keystore 系统安全存储敏感信息

实现指数退避重试策略

private suspend fun <T> retryWithBackoff(
    times: Int = 3,
    initialDelay: Long = 1000,
    maxDelay: Long = 10000,
    factor: Double = 2.0,
    block: suspend () -> T): T {
    var currentDelay = initialDelay
    repeat(times - 1) { attempt ->
        try {return block()
        } catch (e: Exception) {// 可以根据异常类型决定是否重试}
        delay(currentDelay)
        currentDelay = (currentDelay * factor).toLong().coerceAtMost(maxDelay)
    }
    return block() // 最后一次尝试}

网络状态监听

val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
connectivityManager.registerNetworkCallback(NetworkRequest.Builder().build(),
    object : ConnectivityManager.NetworkCallback() {override fun onAvailable(network: Network) {// 网络恢复}

        override fun onLost(network: Network) {// 网络丢失}
    }
)

使用 RecyclerView 实现流式显示

val adapter = object : ListAdapter<String, MyViewHolder>(DiffCallback()) {override fun onBindViewHolder(holder: MyViewHolder, position: Int) {holder.bind(getItem(position))
    }
}

// 在接收流式数据时
launch {streamChatCompletion(request).collect { chunk ->
        withContext(Dispatchers.Main) {adapter.submitList(adapter.currentList + chunk)
            recyclerView.smoothScrollToPosition(adapter.itemCount - 1)
        }
    }
}