ChatGPT安卓App开发实战：从零搭建到性能优化全指南

1次阅读

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

开发 ChatGPT 类安卓应用时，开发者常面临以下核心挑战：

网络延迟敏感 ：大语言模型的 API 响应时间直接影响对话流畅度，尤其在移动网络不稳定的场景下
流式响应处理 ：传统请求 - 响应模式无法满足实时对话体验，需要处理分块传输的流数据
UI 线程阻塞风险 ：大文本的解析和渲染可能导致 ANR(Application Not Responding)
API 调用成本 ：OpenAI 按 token 计费，不当的请求设计会导致额外开销

方案	延迟	吞吐量	适用场景	实现复杂度
Retrofit+OkHttp	中	高	常规请求	低
WebSocket	低	中	实时双向通信	中
gRPC	最低	最高	高性能微服务	高

结论：对于 ChatGPT 类应用，推荐组合方案：
– 使用 Retrofit 处理常规 API 请求（认证 / 配置）
– 采用 WebSocket 实现消息实时推送

获取 API 密钥（需在 OpenAI 平台创建）

在 AndroidManifest.xml 添加网络权限：

<uses-permission android:name="android.permission.INTERNET" />

配置 Retrofit 实例时添加认证头：

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.openai.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .client(OkHttpClient.Builder()
        .addInterceptor { chain ->
            val request = chain.request().newBuilder()
                .addHeader("Authorization", "Bearer YOUR_API_KEY")
                .build()
            chain.proceed(request)
        }
        .build())
    .build()

定义数据模型和接口：

// 请求体
data class ChatRequest(
    val model: String = "gpt-3.5-turbo",
    val messages: List<Message>,
    val stream: Boolean = true
)

data class Message(val role: String, val content: String)

// 响应体（流式）data class ChatChunk(
    val id: String,
    val choices: List<Choice>
)

data class Choice(val delta: Delta)
data class Delta(val content: String?)

// Retrofit 接口
interface OpenAIApi {@POST("/v1/chat/completions")
    @Streaming
    suspend fun chatCompletion(@Body request: ChatRequest): Response<ResponseBody>
}

// ViewModel 中处理流式响应
class ChatViewModel : ViewModel() {private val _messages = MutableStateFlow<List<Message>>(emptyList())
    val messages: StateFlow<List<Message>> = _messages

    fun sendMessage(prompt: String) = viewModelScope.launch {
        // 添加用户消息
        _messages.update {it + Message("user", prompt) }

        val api = retrofit.create(OpenAIApi::class.java)
        val request = ChatRequest(
            messages = _messages.value,
            stream = true
        )

        try {val response = api.chatCompletion(request)
            if (response.isSuccessful) {response.body()?.charStream()?.bufferedReader()?.use { reader ->
                    val buffer = StringBuilder()
                    var assistantMessage = Message("assistant", "")

                    reader.lineSequence().forEach { line ->
                        if (line.startsWith("data:")) {val json = line.removePrefix("data:").trim()
                            if (json != "[DONE]") {val chunk = Gson().fromJson(json, ChatChunk::class.java)
                                chunk.choices.firstOrNull()?.delta?.content?.let { content ->
                                    buffer.append(content)
                                    assistantMessage = assistantMessage.copy(content = buffer.toString()
                                    )
                                    // 更新最新消息
                                    _messages.update {it.dropLast(1) + assistantMessage 
                                    }
                                }
                            }
                        }
                    }
                }
            }
        } catch (e: Exception) {// 错误处理}
    }
}

使用 OkHttp 的 CacheControl：

val client = OkHttpClient.Builder()
    .cache(Cache(directory = File(context.cacheDir, "http_cache"),
        maxSize = 10L * 1024 * 1024 // 10MB
    ))
    .addInterceptor { chain ->
        val request = chain.request().newBuilder()
            .cacheControl(if (isNetworkAvailable()) {CacheControl.FORCE_NETWORK} else {CacheControl.FORCE_CACHE}
            )
            .build()
        chain.proceed(request)
    }
    .build()

在 RecyclerView.Adapter 中使用 DiffUtil 高效更新
按句子或段落分割长响应（使用正则匹配标点符号）

使用协程的 IO 调度器处理网络请求

主线程只做最终 UI 更新：

viewModelScope.launch(Dispatchers.IO) {
    // 网络请求
    val response = api.chatCompletion(request)

    // 切换到 Main 线程更新 UI
    withContext(Dispatchers.Main) {_messages.value = updatedMessages}
}

实现请求队列和速率限制器：

class RateLimiter(private val maxRequests: Int, private val timeWindow: Long) {private val timestamps = LinkedList<Long>()

    suspend fun acquire() {while (true) {synchronized(this) {val now = System.currentTimeMillis()
                timestamps.removeIf {it < now - timeWindow}

                if (timestamps.size < maxRequests) {timestamps.add(now)
                    return
                }
            }
            delay(100) // 等待 100ms 重试
        }
    }
}

使用 Moderation API 前置检查：

suspend fun checkContentSafety(text: String): Boolean {val response = openAIApi.moderate(ModerationRequest(text))
    return response.results?.none {it.flagged} ?: true
}

实现自动重试机制：

private suspend fun <T> withRetry(
    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) {if (attempt == times - 1) throw e
            delay(currentDelay)
            currentDelay = (currentDelay * factor).toLong().coerceAtMost(maxDelay)
        }
    }
    return block()}