ChatGPT安卓应用开发实战：从零构建到性能优化

1次阅读

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

构建 ChatGPT 安卓应用的第一步是理解 API 的集成原理和认证机制。OpenAI 提供了 RESTful API，通过 HTTP 请求与 ChatGPT 模型进行交互。API 的核心认证机制基于 Bearer Token，开发者需要在请求头中携带有效的 API 密钥。

获取 API 密钥：首先需要在 OpenAI 官网注册账号并获取 API 密钥。这个密钥是访问 API 的唯一凭证，需要妥善保管。
API 请求格式：ChatGPT API 的请求体通常包含model（指定使用的模型，如gpt-3.5-turbo）、messages（对话历史）和temperature（控制回复的随机性）等参数。
认证实现：在 Kotlin 中，可以使用 OkHttp 或 Retrofit 来发送 HTTP 请求。以下是使用 OkHttp 的示例代码：

val client = OkHttpClient()
val mediaType = "application/json".toMediaType()
val requestBody = """{"model":"gpt-3.5-turbo","messages": [{"role":"user","content":"Hello!"}]
}
""".trimIndent().toRequestBody(mediaType)

val request = Request.Builder()
  .url("https://api.openai.com/v1/chat/completions")
  .post(requestBody)
  .addHeader("Authorization", "Bearer YOUR_API_KEY")
  .build()

client.newCall(request).enqueue(object : Callback {override fun onFailure(call: Call, e: IOException) {e.printStackTrace()
  }

  override fun onResponse(call: Call, response: Response) {val responseBody = response.body?.string()
    println(responseBody)
  }
})

网络请求是 ChatGPT 应用的核心功能之一，优化网络层可以显著提升用户体验。以下是几种常见的优化策略：

重试机制 ：网络请求可能会因为各种原因失败，实现自动重试机制可以提高请求的成功率。可以使用 OkHttp 的RetryInterceptor 来实现：

class RetryInterceptor(private val maxRetries: Int) : Interceptor {override fun intercept(chain: Interceptor.Chain): Response {var request = chain.request()
    var response: Response? = null
    var retryCount = 0
    var lastException: IOException? = null

    while (retryCount < maxRetries) {
      try {response = chain.proceed(request)
        if (response.isSuccessful) {return response}
      } catch (e: IOException) {lastException = e}
      retryCount++
      Thread.sleep(1000 * retryCount)
    }

    throw lastException ?: IOException("Max retries reached")
  }
}

缓存策略 ：对于频繁请求的相同内容，可以使用缓存来减少网络请求。OkHttp 支持通过Cache 类实现磁盘缓存：

val cacheSize = 10 * 1024 * 1024 // 10MB
val cache = Cache(File(context.cacheDir, "http_cache"), cacheSize.toLong())

val client = OkHttpClient.Builder()
  .cache(cache)
  .build()

为了提供流畅的用户体验，UI 设计需要响应迅速且易于交互。以下是使用 Jetpack Compose 实现响应式 UI 的示例：

消息列表 ：使用LazyColumn 展示对话历史，每条消息根据角色（用户或 AI）显示在不同的位置：

@Composable
fun MessageList(messages: List<Message>) {
  LazyColumn {items(messages) { message ->
      MessageItem(message)
    }
  }
}

@Composable
fun MessageItem(message: Message) {
  Box(
    modifier = Modifier
      .fillMaxWidth()
      .padding(8.dp),
    contentAlignment = if (message.role == "user") Alignment.CenterEnd else Alignment.CenterStart
  ) {
    Card(backgroundColor = if (message.role == "user") Color.Blue else Color.Gray,
      contentColor = Color.White
    ) {
      Text(
        text = message.content,
        modifier = Modifier.padding(16.dp)
      )
    }
  }
}

输入框和发送按钮 ：使用TextField 和Button组合实现用户输入功能：

@Composable
fun InputBar(onSend: (String) -> Unit) {var text by remember { mutableStateOf("") }

  Row(modifier = Modifier.fillMaxWidth()) {
    TextField(
      value = text,
      onValueChange = {text = it},
      modifier = Modifier.weight(1f)
    )
    Button(onClick = {onSend(text)
      text = ""
    }) {Text("Send")
    }
  }
}

以下是整合了 API 调用和 UI 的完整 Kotlin 代码示例：

class MainActivity : ComponentActivity() {private val viewModel: ChatViewModel by viewModels()

  override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)
    setContent {ChatApp(viewModel)
    }
  }
}

@Composable
fun ChatApp(viewModel: ChatViewModel) {val messages by viewModel.messages.collectAsState()

  Column(modifier = Modifier.fillMaxSize()) {MessageList(messages)
    InputBar { text ->
      viewModel.sendMessage(text)
    }
  }
}

class ChatViewModel : ViewModel() {private val _messages = mutableStateListOf<Message>()
  val messages: List<Message> get() = _messages

  private val client = OkHttpClient.Builder()
    .addInterceptor(RetryInterceptor(3))
    .cache(Cache(File(context.cacheDir, "http_cache"), 10 * 1024 * 1024))
    .build()

  fun sendMessage(text: String) {_messages.add(Message("user", text))

    viewModelScope.launch {
      try {val response = sendApiRequest(text)
        _messages.add(Message("assistant", response))
      } catch (e: Exception) {_messages.add(Message("system", "Error: ${e.message}"))
      }
    }
  }

  private suspend fun sendApiRequest(text: String): String {return withContext(Dispatchers.IO) {val mediaType = "application/json".toMediaType()
      val requestBody = """{"model":"gpt-3.5-turbo","messages": [{"role":"user","content":"$text"}]
        }
      """.trimIndent().toRequestBody(mediaType)

      val request = Request.Builder()
        .url("https://api.openai.com/v1/chat/completions")
        .post(requestBody)
        .addHeader("Authorization", "Bearer YOUR_API_KEY")
        .build()

      val response = client.newCall(request).execute()
      val responseBody = response.body?.string() ?: throw IOException("Empty response")
      val json = JSONObject(responseBody)
      json.getJSONArray("choices").getJSONObject(0).getJSONObject("message").getString("content")
    }
  }
}

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

性能测试：使用 Android Profiler 监控应用的 CPU、内存和网络使用情况。重点关注 API 响应时间和 UI 渲染性能。
优化建议：
使用 Dispatchers.IO 处理网络请求，避免阻塞主线程。
对 API 响应进行压缩，减少数据传输量。
实现分页加载，避免一次性加载大量消息。
使用 remember 缓存计算结果，避免不必要的重绘。

Token 管理：API 密钥需要安全存储，建议使用 Android 的EncryptedSharedPreferences：

val masterKey = MasterKey.Builder(applicationContext)
  .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
  .build()

val sharedPreferences = EncryptedSharedPreferences.create(
  applicationContext,
  "api_keys",
  masterKey,
  EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
  EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)

sharedPreferences.edit().putString("openai_key", "YOUR_API_KEY").apply()