ChatGPT官方原版APK接入指南：从零开始构建AI对话应用

1次阅读

没有评论

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

ChatGPT 官方 API 为开发者提供了强大的自然语言处理能力，典型应用场景包括：

智能客服系统
内容创作辅助工具
教育类应用的智能问答功能
语音助手的后台处理引擎

接入价值主要体现在三个方面：

大幅降低开发 AI 对话功能的门槛
获得 OpenAI 持续优化的模型能力
可快速集成到现有应用中

Android Studio 2021.2.1 或更高版本
Gradle 7.0 或更高版本
Android SDK API Level 23+

在 app 模块的 build.gradle 中添加以下依赖：

dependencies {
    // 网络请求库
    implementation 'com.squareup.okhttp3:okhttp:4.9.3'

    // JSON 处理
    implementation 'com.google.code.gson:gson:2.8.9'

    // 协程支持
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.1'
}

class ChatGptApiClient(private val apiKey: String) {private val client = OkHttpClient()
    private val gson = Gson()

    /**
     * 发送对话请求
     * @param messages 对话消息列表
     * @param model 使用的模型 ID，默认 "gpt-3.5-turbo"
     * @param temperature 生成文本的随机性，0-2
     */
    suspend fun sendMessage(
        messages: List<Message>,
        model: String = "gpt-3.5-turbo",
        temperature: Float = 0.7f
    ): Response {
        val requestBody = gson.toJson(ChatRequest(model, messages, temperature)
        ).toRequestBody("application/json".toMediaType())

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

        return withContext(Dispatchers.IO) {client.newCall(request).execute()}
    }
}

data class ChatRequest(
    val model: String,
    val messages: List<Message>,
    val temperature: Float
)

data class Message(
    val role: String, // "system", "user", or "assistant"
    val content: String
)

class AuthManager(context: Context) {private val sharedPrefs = context.getSharedPreferences("auth_prefs", Context.MODE_PRIVATE)
    private val maxRetries = 3
    private val retryDelay = 1000L // 1 秒

    /**
     * 获取访问令牌（带重试机制）*/
    suspend fun getAccessToken(): String? {
        var currentRetry = 0
        var lastError: Exception? = null

        while (currentRetry < maxRetries) {
            try {return fetchTokenFromServer()
            } catch (e: Exception) {
                lastError = e
                delay(retryDelay * (currentRetry + 1))
                currentRetry++
            }
        }

        throw lastError ?: IllegalStateException("Unknown authentication error")
    }

    private suspend fun fetchTokenFromServer(): String {
        // 实际实现中这里应该调用 OAuth2.0 认证接口
        return "your_access_token"
    }
}

推荐使用生产者 - 消费者模式管理对话消息：

class MessageQueue {private val queue = Channel<Message>(capacity = Channel.UNLIMITED)
    private val scope = CoroutineScope(Dispatchers.Default)

    fun sendMessage(message: Message) {
        scope.launch {queue.send(message)
        }
    }

    suspend fun receiveMessages(): ReceiveChannel<Message> {return queue}
}

// 在 OkHttpClient 配置中添加缓存
val cacheSize = 10 * 1024 * 1024 // 10MB
val cache = Cache(context.cacheDir, cacheSize.toLong())

val client = OkHttpClient.Builder()
    .cache(cache)
    .addInterceptor { chain ->
        val request = chain.request()
        // 强制从网络获取
        val networkRequest = request.newBuilder()
            .header("Cache-Control", "no-cache")
            .build()

        // 先尝试从缓存读取
        val cacheResponse = chain.proceed(networkRequest).cacheResponse
        cacheResponse?.let {return@addInterceptor it}

        // 没有缓存则走网络
        chain.proceed(networkRequest)
    }
    .build()

suspend fun processStreamingResponse(response: Response) {response.body?.source()?.let { source ->
        val buffer = source.buffer()
        while (!buffer.exhausted()) {val line = buffer.readUtf8Line() ?: break
            if (line.startsWith("data:")) {val json = line.substring(5).trim()
                if (json == "[DONE]") break

                val event = gson.fromJson(json, ChatEvent::class.java)
                // 处理每个事件
                onEventReceived(event)
            }
        }
    }
}

使用 Android Keystore 存储密钥：

@RequiresApi(Build.VERSION_CODES.M)
class SecureStorage(context: Context) {private val keyStore = KeyStore.getInstance("AndroidKeyStore")
    private val alias = "chatgpt_api_key"

    init {keyStore.load(null)

        if (!keyStore.containsAlias(alias)) {createKey()
        }
    }

    private fun createKey() {
        val keyGenerator = KeyGenerator.getInstance(
            KeyProperties.KEY_ALGORITHM_AES,
            "AndroidKeyStore"
        )

        keyGenerator.init(
            KeyGenParameterSpec.Builder(
                alias,
                KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
            )
                .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                .setRandomizedEncryptionRequired(false)
                .build())

        keyGenerator.generateKey()}

    fun encrypt(data: String): ByteArray {// 实现加密逻辑}

    fun decrypt(encryptedData: ByteArray): String {// 实现解密逻辑}
}

fun signRequest(request: Request, secret: String): Request {val timestamp = System.currentTimeMillis()
    val nonce = UUID.randomUUID().toString()

    // 构建签名内容
    val content = StringBuilder()
        .append(request.method)
        .append(request.url)
        .append(timestamp)
        .append(nonce)
        .toString()

    // 计算 HMAC-SHA256 签名
    val hmac = Mac.getInstance("HmacSHA256")
    hmac.init(SecretKeySpec(secret.toByteArray(), "HmacSHA256"))
    val signature = hmac.doFinal(content.toByteArray())
        .let {Base64.encodeToString(it, Base64.NO_WRAP) }

    // 添加签名头
    return request.newBuilder()
        .addHeader("X-Timestamp", timestamp.toString())
        .addHeader("X-Nonce", nonce)
        .addHeader("X-Signature", signature)
        .build()}