Android集成GLM-4.7完整教程：30分钟实现AI对话功能

Android集成GLM-4.7完整教程：30分钟实现AI对话功能

╔═══════════════════════════════════════════════════════════════════════╗
║ ║
║ ╔══════════╗ ║
║ ║ 📱 ║ Android集成GLM-4.7完整教程 ║
║ ║ ║ ║
║ ║ ┌─────────┐ ║ 30分钟实现AI对话功能 ║
║ ║ │ 🤖 AI │ ║ ║
║ ║ └─────────┘ ║ ║
║ ║ ║ [Android] [GLM-4.7] [Kotlin] [Retrofit] ║
║ ╚══════════╝ ║
║ ║
╚═════════════════════════════════════════════════════════════════════════╝

你遇到过这个问题吗？

想在Android应用里加入AI对话功能，但被GLM-4.7 API集成搞得焦头烂额？

你遇到的问题可能是:

• 不知道怎么正确调用GLM-4.7 API
• Android网络请求总是超时或失败
• 异步处理搞得界面卡顿
• API响应格式解析出错
• 错误处理写得一塌糊涂

别担心,这篇文章手把手教你从零开始,在30分钟内完成Android应用中GLM-4.7的集成。

Android集成GLM-4.7的核心问题分析

为什么在Android中调用GLM-4.7 API这么麻烦？

核心痛点有三个:

好消息是,掌握了正确的方法,这些都能轻松解决。

解决方案：Android集成GLM-4.7完整实现

步骤1:准备工作

1.1 项目依赖配置

在app模块的build.gradle中添加必要依赖:

dependencies {
// 网络请求库 – Retrofit用于Android GLM-4.7 API调用
implementation 'com.squareup.retrofit2:retrofit:2.11.0'
implementation 'com.squareup.retrofit2:converter-gson:2.11.0'
implementation 'com.squareup.okhttp3:okhttp:4.12.0'
implementation 'com.squareup.okhttp3:logging-interceptor:4.12.0'

// Kotlin协程支持 – 处理Android异步网络请求
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0'

// JSON解析库
implementation 'com.google.code.gson:gson:2.11.0'
}

// 版本兼容性说明：
// – Retrofit 2.11.0 官方推荐搭配 OkHttp 4.12.0
// – 如果使用旧版 Retrofit (2.9.x)，需搭配 OkHttp 4.10.x
// – 版本不匹配可能导致：适配器加载失败、HTTP/2不支持等问题
// – 协程 1.8.0 需要 Kotlin 1.9.0+，建议同步升级 Kotlin 插件版本

1.2 Android网络权限配置

在AndroidManifest.xml中添加网络权限:

<!– Android网络权限配置 – GLM-4.7 API调用必需 –>
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

注意: 如果使用HTTPS,无需额外配置;如果使用HTTP,需要在res/xml/network_security_config.xml中配置:

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
<!– Android网络安全配置 – 允许HTTP明文传输 –>
<domain-config cleartextTrafficPermitted="true">
<domain includeSubdomains="true">your-api-domain.com</domain>
</domain-config>
</network-security-config>

然后在Manifest中引用:

<application
android:networkSecurityConfig="@xml/network_security_config"
…>

1.3 创建GLM-4.7数据模型

GLM-4.7 数据模型

┌─────────────────────────────────────────────────────────────────────────────┐
│ 请求模型 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ data class GLMRequest( │
│ val model: String = "glm-4.7", // 模型版本 │
│ val messages: List<Message>, // 消息列表 │
│ val temperature: Float = 0.7f, // 0-2（官方范围），控制生成随机性 │
│ val max_tokens: Int = 1024 // 默认值降低，避免触发限流 │
│ ) │
│ │
│ data class Message( │
│ val role: String, // "user" | "assistant" | "system" │
│ val content: String // 消息内容 │
│ ) │
│ │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│ 响应模型 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ data class GLMResponse( │
│ val id: String, // 请求ID │
│ val choices: List<Choice>, // AI回复选项 │
│ val usage: Usage? // Token使用统计 │
│ ) │
│ │
│ data class Choice( │
│ val index: Int, // 选项索引 │
│ val message: Message, // AI消息 │
│ val finish_reason: String? // 结束原因 │
│ ) │
│ │
│ data class Usage( │
│ val prompt_tokens: Int, // 输入token数 │
│ val completion_tokens: Int, // 输出token数 │
│ val total_tokens: Int // 总token数 │
│ ) │
│ │
└─────────────────────────────────────────────────────────────────────────────┘

定义GLM-4.7 API请求和响应的数据类:

// GLM-4.7 API请求模型
data class GLMRequest(
val model: String = "glm-4.7",
val messages: List<Message>,
val temperature: Float = 0.7f, // 0-2（官方范围），控制生成随机性
val max_tokens: Int = 1024 // 降低默认值，避免触发限流
)

// GLM-4.7消息模型
data class Message(
val role: String, // "user", "assistant", "system"
val content: String
)

// GLM-4.7 API响应模型
data class GLMResponse(
val id: String,
val choices: List<Choice>,
val usage: Usage?
)

// GLM-4.7选择模型
data class Choice(
val index: Int,
val message: Message,
val finish_reason: String?
)

// GLM-4.7 Token使用统计
data class Usage(
val prompt_tokens: Int,
val completion_tokens: Int,
val total_tokens: Int
)

// 参数详细说明：
// temperature: 0-2（官方范围）
// – 0-0.3：确定性输出，适合代码生成、逻辑推理
// – 0.3-0.7：平衡输出，适合对话、问答
// – 0.7-1.3：创造性输出，适合写作、头脑风暴
// – 1.3-2.0：高度随机，仅适用于特殊场景
// max_tokens: 512-4096
// – 512-1024：简单问答、短对话（推荐默认值）
// – 1024-2048：中等长度对话
// – 2048-4096：长对话、复杂任务
// – ⚠️ 设置过高可能导致 API 限流（429 Too Many Requests）

步骤2:核心实现 – Retrofit异步网络请求

Android GLM-4.7 集成架构

┌─────────────────────────────────────────────────────────────────────────────┐
│ Android应用架构 │
└─────────────────────────────────────────────────────────────────────────────┘

[用户界面] [ViewModel层] [数据层] [API层]
│ │ │ │
│ sendMessage() │ │ │
├────────────────────>│ │ │
│ │ chat() │ │
│ ├──────────────────>│ │
│ │ │ chatCompletion() │
│ │ ├──────────────────>│
│ │ │ ┌────────────┐ │
│ │ │ │ GLM-4.7 │ │
│ │ │ │ API │ │
│ │ │ └────────────┘ │
│ │ │ │ │
│ │ │ │ GLMResponse
│ │ │ │ │
│ │ │<────────┘ │
│ │ Result<String> │ │
│ │<─────────────────┘ │
│ UI State更新 │ │
│<───────────────────┘ │
▼ │
[显示响应] │
│
技术栈：Kotlin Coroutines + Retrofit + OkHttp + GLM-4.7 API │

2.1 创建GLM-4.7 Retrofit API接口

import retrofit2.Response
import retrofit2.http.Body
import retrofit2.http.Header
import retrofit2.http.POST

// Android GLM-4.7 API接口定义
interface GLMApiService {
@POST("v4/chat/completions") // 根据官方文档确认路径
suspend fun chatCompletion(
@Header("Authorization") authorization: String,
@Header("Content-Type") contentType: String = "application/json",
@Body request: GLMRequest
): Response<GLMResponse>

companion object {
// GLM-4.7 API创建方法 – 配置OkHttp和Retrofit

// ⚠️ API 路径说明：
// 智谱AI官方推荐 Base URL: https://open.bigmodel.cn/api/
// 如果使用旧版 API 路径，可能是: https://open.bigmodel.cn/api/paas/v4/
// 建议使用官方最新文档确认: https://open.bigmodel.cn/dev/api

// 当前配置（推荐）：
fun create(baseUrl: String = "https://open.bigmodel.cn/api/"): GLMApiService {
val loggingInterceptor = HttpLoggingInterceptor().apply {
level = HttpLoggingInterceptor.Level.BODY
}

// OkHttp配置 – 处理Android网络请求超时和重试
val okHttpClient = OkHttpClient.Builder()
.addInterceptor(loggingInterceptor)
.connectTimeout(30, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.writeTimeout(30, TimeUnit.SECONDS)
.retryOnConnectionFailure(true) // 启用连接失败重试
.build()

// Retrofit配置 – 用于Android GLM-4.7 API调用
return Retrofit.Builder()
.baseUrl(baseUrl)
.client(okHttpClient)
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(GLMApiService::class.java)
}
}
}

// 错误处理说明：
// 如果遇到 404 错误，检查：
// 1. Base URL 是否正确
// 2. API 路径是否包含 /paas/ 前缀（旧版）
// 3. @POST 注解路径是否为 "v4/chat/completions"

2.2 创建GLM-4.7 API客户端类

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

// Android GLM-4.7客户端 – 使用Kotlin协程处理异步网络请求
class GLMClient(private val apiKey: String) {

private val apiService = GLMApiService.create()
private val authorization = "Bearer $apiKey"

// GLM-4.7聊天方法 – Android异步网络请求实现
suspend fun chat(
userMessage: String,
systemPrompt: String = "你是一个有用的AI助手。",
conversationHistory: List<Message> = emptyList()
): Result<String> = withContext(Dispatchers.IO) {
try {
// 构建GLM-4.7消息列表
val messages = mutableListOf<Message>()

// 添加系统提示
if (systemPrompt.isNotEmpty()) {
messages.add(Message(role = "system", content = systemPrompt))
}

// 添加历史对话 – GLM-4.7多轮对话上下文支持
messages.addAll(conversationHistory)

// 添加用户消息
messages.add(Message(role = "user", content = userMessage))

// 发起GLM-4.7 API请求
val request = GLMRequest(
model = "glm-4.7",
messages = messages,
temperature = 0.7f,
max_tokens = 1024 // 降低默认值，避免触发限流
)

val response = apiService.chatCompletion(authorization, "application/json", request)

if (response.isSuccessful && response.body() != null) {
val assistantMessage = response.body()!!.choices.firstOrNull()?.message?.content
if (assistantMessage != null) {
Result.success(assistantMessage)
} else {
Result.failure(Exception("GLM-4.7响应中未找到有效消息"))
}
} else {
val errorMsg = response.errorBody()?.string() ?: "未知错误"
Result.failure(Exception("GLM-4.7 API请求失败: $errorMsg"))
}
} catch (e: Exception) {
Result.failure(e)
}
}

// GLM-4.7流式响应 – 高级功能
suspend fun streamChat(
userMessage: String,
onTokenReceived: (String) -> Unit,
onComplete: (String) -> Unit,
onError: (Exception) -> Unit
) {
// 注意: GLM-4.7流式响应实现更复杂
// 实际项目建议使用WebSocket或SSE库
}
}

2.3 在ViewModel中使用Kotlin协程

Android GLM-4.7 集成数据流程

┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 用户 │ │ ViewModel │ │ GLMClient │ │ GLM-4.7 │
│ 输入 │ │ │ │ │ │ API │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘
│ │ │ │
│ "你好" │ │ │
├────────────────────>│ │ │
│ │ │ │
│ │ │ │
│ │ chat("你好") │ │
│ ├────────────────────>│ │
│ │ │ 构建消息列表 │
│ │ │ │
│ │ │ HTTP Request │
│ │ ├────────────────────>│
│ │ │ │
│ │ │ │ 处理
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │<────────────────────┤
│ │ │ HTTP Response │
│ │ │ │
│ │ │ │
│ │ Result.success() │ │
│ │<────────────────────┤ │
│ │ │ │
│ 更新UI │ │ │
│<────────────────────┤ │ │
│ │ │ │
▼ ▼ ▼ ▼
显示AI响应 State更新 请求完成 响应返回

┌────────────────────────────────────────────────────────────────────────────┐
│ 关键特性： │
│ • Kotlin Coroutines处理异步请求 │
│ • Retrofit封装HTTP调用 │
│ • OkHttp配置超时和重试 │
│ • Result类型处理成功/失败 │
└────────────────────────────────────────────────────────────────────────────┘

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch

// Android聊天UI状态
data class ChatUiState(
val isLoading: Boolean = false,
val response: String = "",
val error: String? = null,
val conversation: List<Pair<String, String>> = emptyList()
)

// GLM-4.7聊天ViewModel – 使用Kotlin协程处理异步请求
class ChatViewModel(private val glmClient: GLMClient) : ViewModel() {

private val _uiState = MutableStateFlow(ChatUiState())
val uiState: StateFlow<ChatUiState> = _uiState.asStateFlow()

// 发送消息 – Android异步网络请求
fun sendMessage(message: String) {
if (message.isBlank()) return

viewModelScope.launch {
_uiState.value = _uiState.value.copy(
isLoading = true,
error = null
)

glmClient.chat(message).fold(
onSuccess = { response ->
val newConversation = _uiState.value.conversation + (message to response)
_uiState.value = _uiState.value.copy(
isLoading = false,
response = response,
conversation = newConversation
)
},
onFailure = { error ->
_uiState.value = _uiState.value.copy(
isLoading = false,
error = error.message ?: "未知错误"
)
}
)
}
}
}

2.4 创建Android UI界面

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:padding="16dp">

<!– Android对话历史显示 –>
<androidx.recyclerview.widget.RecyclerView
android:id="@+id/chatRecyclerView"
android:layout_width="match_parent"
android:layout_height="0dp"
android:layout_weight="1" />

<!– GLM-4.7响应显示 –>
<TextView
android:id="@+id/responseTextView"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="8dp"
android:layout_marginBottom="8dp"
android:padding="12dp"
android:background="@drawable/response_background"
android:text="等待输入…"
android:textSize="14sp" />

<!– 加载状态 –>
<ProgressBar
android:id="@+id/loadingProgressBar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
android:visibility="gone" />

<!– Android输入框 –>
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:layout_marginTop="8dp">

<EditText
android:id="@+id/messageEditText"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:layout_weight="1"
android:hint="输入消息…"
android:maxLines="4" />

<Button
android:id="@+id/sendButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="发送" />
</LinearLayout>

</LinearLayout>

2.5 Android Activity实现

import android.os.Bundle
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

// Android聊天Activity – GLM-4.7集成完整实现
class ChatActivity : AppCompatActivity() {

private lateinit var binding: ActivityChatBinding
private val viewModel: ChatViewModel by viewModels {
val apiKey = "your-api-key-here" // 从安全存储中获取
ChatViewModelFactory(GLMClient(apiKey))
}

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityChatBinding.inflate(layoutInflater)
setContentView(binding.root)

setupObservers()
setupListeners()
}

private fun setupObservers() {
lifecycleScope.launch {
viewModel.uiState.collect { state ->
// 更新加载状态
binding.loadingProgressBar.visibility =
if (state.isLoading) View.VISIBLE else View.GONE

// 更新GLM-4.7响应文本
binding.responseTextView.text =
if (state.response.isEmpty()) "等待输入…" else state.response

// 显示错误
if (state.error != null) {
Toast.makeText(
this@ChatActivity,
"错误: ${state.error}",
Toast.LENGTH_SHORT
).show()
}

// 更新Android对话历史(需要实现RecyclerView适配器)
// binding.chatRecyclerView.adapter?.submitList(state.conversation)
}
}
}

private fun setupListeners() {
binding.sendButton.setOnClickListener {
val message = binding.messageEditText.text.toString().trim()
if (message.isNotEmpty()) {
viewModel.sendMessage(message)
binding.messageEditText.text?.clear()
}
}
}
}

// Android ViewModelFactory
class ChatViewModelFactory(private val glmClient: GLMClient) :
ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
if (modelClass.isAssignableFrom(ChatViewModel::class.java)) {
@Suppress("UNCHECKED_CAST")
return ChatViewModel(glmClient) as T
}
throw IllegalArgumentException("Unknown ViewModel class")
}
}

步骤3:测试验证

3.1 Android单元测试

import kotlinx.coroutines.test.runTest
import org.junit.Assert.*
import org.junit.Before
import org.junit.Test

// GLM-4.7 Android单元测试
class GLMClientTest {

private lateinit var glmClient: GLMClient

@Before
fun setup() {
// 使用测试API密钥
glmClient = GLMClient("test-api-key")
}

@Test
fun `test chat with valid message returns success`() = runTest {
val result = glmClient.chat("你好")

assertTrue(result.isSuccess)
assertFalse(result.getOrNull().isNullOrEmpty())
}

@Test
fun `test chat with empty message handles gracefully`() = runTest {
val result = glmClient.chat("")

assertTrue(result.isSuccess)
}
}

3.2 Android集成测试步骤

Android集成GLM-4.7踩坑记录

Android集成GLM-4.7常见坑

┌─────────────────────────────────────────────────────────────────────────────┐
│ 坑1: NetworkSecurityException │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 现象: Trust anchor for certification path not found │
│ 原因: Android 9.0+默认不允许HTTP明文流量 │
│ 解决: 配置network_security_config.xml │
│ │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│ 坑2: NetworkOnMainThreadException │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 现象: android.os.NetworkOnMainThreadException │
│ 原因: 主线程直接发起网络请求 │
│ 解决: 使用Kotlin协程(viewModelScope.launch) │
│ │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│ 坑3: API密钥硬编码 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 现象: API密钥直接写在代码中 │
│ 原因: 开发时为了方便 │
│ 解决: 使用local.properties或Android Keystore加密存储 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│ 坑4: JSON解析失败 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 现象: JsonSyntaxException: Expected BEGIN_ARRAY but was BEGIN_OBJECT │
│ 原因: API响应格式与数据模型不匹配 │
│ 解决: 使用@SerializedName处理字段名不一致 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│ 坑5: 超时问题 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ 现象: API请求经常超时 │
│ 原因: 超时时间设置太短或服务器响应慢 │
│ 解决: 增加OkHttp超时时间(60s) + 启用重试 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘

坑1: NetworkSecurityException错误

现象:

java.security.cert.CertPathValidatorException: Trust anchor for certification path not found.

原因: Android 9.0+默认不允许HTTP明文流量,而你的GLM-4.7 API使用的是HTTP而不是HTTPS。

解决方案:

坑2: NetworkOnMainThreadException

现象:

android.os.NetworkOnMainThreadException

原因: 在Android主线程直接发起了GLM-4.7 API网络请求,Android不允许这样做。

解决方案: 使用Kotlin协程或RxJava处理Android异步网络请求:

// ❌ 错误做法 – Android主线程网络请求
val response = apiService.chatCompletion(...)

// ✅ 正确做法 – 使用Kotlin协程处理异步
viewModelScope.launch {
val response = apiService.chatCompletion(...) // 在IO线程
}

坑3: API密钥硬编码问题

现象: GLM-4.7 API密钥直接写在代码中,容易被泄露。

原因: 开发时为了方便直接将密钥写在代码中。

解决方案:

坑4: JSON解析失败

现象:

com.google.gson.JsonSyntaxException: Expected BEGIN_ARRAY but was BEGIN_OBJECT

原因: GLM-4.7 API响应格式与定义的数据模型不匹配。

解决方案:

坑5: Android网络请求超时问题

现象: GLM-4.7 API请求经常超时,用户体验差。

原因: Android网络请求设置超时时间太短或服务器响应慢。

解决方案:

val okHttpClient = OkHttpClient.Builder()
.connectTimeout(60, TimeUnit.SECONDS) // 增加连接超时
.readTimeout(60, TimeUnit.SECONDS) // 增加读取超时
.writeTimeout(60, TimeUnit.SECONDS) // 增加写入超时
.retryOnConnectionFailure(true) // 启用重试
.build()

Android集成GLM-4.7常见问题FAQ

Q1: 如何获取GLM-4.7的API密钥？

A: 访问智谱AI开放平台(https://open.bigmodel.cn/),注册账号后创建应用即可获取API密钥。新用户通常有免费额度。

Q2: Android支持GLM-4.7流式响应吗？

A: 支持,但需要额外处理。GLM-4.7支持SSE(Server-Sent Events)流式输出。你需要使用OkHttp的SSE库或WebSocket来接收流式数据。

Q3: Android如何处理GLM-4.7多轮对话上下文？

A: 将历史对话消息列表传递给GLM-4.7 API:

val messages = mutableListOf<Message>()
messages.add(Message(role = "user", content = "你好"))
messages.add(Message(role = "assistant", content = "你好!"))
messages.add(Message(role = "user", content = "刚才说的是什么?"))

glmClient.chat("", conversationHistory = messages)

Q4: GLM-4.7 token消耗如何计算？

A: GLM-4.7的token消耗包括输入token和输出token。可以通过响应中的usage字段查看:

val usage = response.usage
Log.d("Token", "Prompt: ${usage?.prompt_tokens}, " +
"Completion: ${usage?.completion_tokens}, " +
"Total: ${usage?.total_tokens}")

Q5: 如何优化GLM-4.7 API调用成本？

A:

• 合理设置max_tokens参数,避免浪费
• 使用缓存机制,避免重复请求相同内容
• 对简单问题使用较小的模型
• 实现本地缓存常用问答

Q6: GLM-4.7支持图片输入吗？

A: GLM-4.7目前主要支持文本,但GLM-4V等视觉模型支持图片输入。需要使用不同的API端点。

Q7: API调用返回404错误怎么办？

A: 检查以下几点：

Q8: 为什么默认max_tokens改为1024而不是2000？

A: 原因如下：

Q9: temperature参数范围为什么是0-2？

A: GLM-4.7官方文档规定的温度范围是0-2：

• 0-0.3：确定性输出，适合代码生成、逻辑推理
• 0.3-0.7：平衡输出，适合对话、问答（推荐默认0.7）
• 0.7-1.3：创造性输出，适合写作、头脑风暴
• 1.3-2.0：高度随机，仅适用于特殊场景

其他模型（如GPT-4）可能使用0-1的范围，但GLM-4.7使用0-2。

延伸阅读

• Retrofit官方文档 – Android网络请求
• Kotlin协程指南 – Android异步处理
• GLM-4.7 API文档
• Android网络最佳实践

相关阅读

• Android协程完整指南
• Retrofit网络请求实战
• GLM-4.7 API高级用法

总结

通过这篇文章,你已经学会了:

完整代码已经为你准备好了,可以直接复制到项目中使用。记得将API密钥换成你自己的。

如果遇到其他问题,欢迎在评论区讨论交流!

更多Android AI集成技巧: 加入知识星球,获取完整项目源码和更多GLM-4.7实战案例