2026-01-04发表8 分钟读完 (大约1155个字)

一、请求构建流程代码示例

1. GET 请求构建

// 创建OkHttpClient实例
val client = OkHttpClient()

// 构建GET请求
val request = Request.Builder()
    .url("https://api.example.com/users")
    .header("Authorization", "Bearer token123")
    .addHeader("Accept", "application/json")
    .get()  // GET请求，可省略，因为默认就是GET
    .tag(String::class.java, "用户列表请求")
    .build()

// 执行请求
val response = client.newCall(request).execute()

2. POST 请求构建 (JSON 数据)

// 创建JSON请求体
val json = """
    {
        "username": "test_user",
        "password": "test_password"
    }
""".trimIndent()

val mediaType = "application/json; charset=utf-8".toMediaType()
val requestBody = json.toRequestBody(mediaType)

// 构建POST请求
val request = Request.Builder()
    .url("https://api.example.com/login")
    .header("Content-Type", "application/json")
    .post(requestBody)  // 设置POST方法和请求体
    .build()

// 执行请求
val response = client.newCall(request).execute()

3. POST 表单提交

// 创建表单请求体
val formBody = FormBody.Builder()
    .add("username", "test_user")
    .add("password", "test_password")
    .build()

// 构建POST请求
val request = Request.Builder()
    .url("https://api.example.com/login")
    .post(formBody)  // 设置POST方法和表单请求体
    .build()

4. 文件上传

// 创建MultipartBody
val file = File("/path/to/file.jpg")
val mediaType = "image/jpeg".toMediaType()
val requestFile = file.asRequestBody(mediaType)

val multipartBody = MultipartBody.Builder()
    .setType(MultipartBody.FORM)
    .addFormDataPart("title", "Profile Picture")
    .addFormDataPart("image", "file.jpg", requestFile)
    .build()

// 构建POST请求
val request = Request.Builder()
    .url("https://api.example.com/upload")
    .post(multipartBody)
    .build()

二、响应处理流程代码示例

1. 基本响应处理

// 执行请求获取响应
val response = client.newCall(request).execute()

try {
    // 检查响应是否成功
    if (response.isSuccessful) {
        // 状态码在200-299之间
        val statusCode = response.code
        val headers = response.headers

        // 获取响应体并转换为字符串
        val responseBody = response.body
        val responseString = responseBody?.string()

        println("响应成功: $statusCode")
        println("响应内容: $responseString")
    } else {
        // 处理错误响应
        println("请求失败: ${response.code}")
        println("错误信息: ${response.message}")
    }
} finally {
    // 关闭响应，释放资源
    response.close()
}

2. JSON 响应处理

// 假设使用Gson进行JSON解析
val gson = Gson()

try {
    if (response.isSuccessful) {
        val responseBody = response.body

        // 将响应体转换为字符串
        val jsonString = responseBody?.string()

        // 解析JSON到数据类
        data class User(val id: Int, val name: String, val email: String)
        val user = gson.fromJson(jsonString, User::class.java)

        println("用户ID: ${user.id}")
        println("用户名: ${user.name}")
        println("邮箱: ${user.email}")
    }
} finally {
    response.close()
}

3. 流式处理大文件下载

// 下载文件示例
val request = Request.Builder()
    .url("https://example.com/large-file.zip")
    .build()

val response = client.newCall(request).execute()

try {
    if (!response.isSuccessful) {
        throw IOException("下载失败: ${response.code}")
    }

    // 获取响应体
    val responseBody = response.body ?: throw IOException("响应体为空")

    // 创建输出文件
    val downloadFile = File("/path/to/save/file.zip")
    val outputStream = FileOutputStream(downloadFile)

    // 使用BufferedSink进行高效写入
    val sink = outputStream.sink().buffer()

    // 从响应体获取源
    val source = responseBody.source()

    // 读取数据并写入文件
    val bufferSize = 8 * 1024  // 8KB缓冲区
    val buffer = Buffer()
    var bytesRead: Long

    // 显示下载进度
    val contentLength = responseBody.contentLength()
    var totalBytesRead = 0L

    while (source.read(buffer, bufferSize.toLong()).also { bytesRead = it } != -1L) {
        sink.write(buffer, bytesRead)
        totalBytesRead += bytesRead

        // 计算下载进度
        if (contentLength > 0) {
            val progress = (totalBytesRead * 100 / contentLength).toInt()
            println("下载进度: $progress%")
        }
    }

    // 确保所有数据都写入
    sink.flush()
    sink.close()

    println("文件下载完成: ${downloadFile.absolutePath}")
} finally {
    response.close()
}

4. 异步请求与响应处理

// 异步执行请求
client.newCall(request).enqueue(object : Callback {
    override fun onFailure(call: Call, e: IOException) {
        // 请求失败处理
        println("请求失败: ${e.message}")
    }

    override fun onResponse(call: Call, response: Response) {
        // 使用try-finally确保响应关闭
        try {
            if (response.isSuccessful) {
                val responseData = response.body?.string()
                println("异步请求成功: $responseData")

                // 注意：这里是在OkHttp的工作线程中
                // 如果需要更新UI，需要切换到主线程
            } else {
                println("请求返回错误: ${response.code}")
            }
        } finally {
            response.close()
        }
    }
})

三、请求和响应的完整生命周期

// 1. 创建OkHttpClient
val client = OkHttpClient.Builder()
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .build()

// 2. 构建请求
val request = Request.Builder()
    .url("https://api.example.com/data")
    .header("User-Agent", "OkHttp Example")
    .build()

// 3. 创建Call对象
val call = client.newCall(request)

// 4. 执行请求
val response = call.execute()

// 5. 处理响应
try {
    // 5.1 检查响应状态
    val statusCode = response.code

    // 5.2 获取响应头
    val contentType = response.header("Content-Type")

    // 5.3 处理响应体
    if (response.isSuccessful) {
        val responseBody = response.body

        // 根据Content-Type处理不同类型的响应
        when {
            contentType?.contains("application/json") == true -> {
                // 处理JSON响应
                val jsonString = responseBody?.string()
                println("JSON响应: $jsonString")
            }
            contentType?.contains("text/") == true -> {
                // 处理文本响应
                val textResponse = responseBody?.string()
                println("文本响应: $textResponse")
            }
            else -> {
                // 处理二进制响应
                val bytes = responseBody?.bytes()
                println("二进制响应长度: ${bytes?.size} 字节")
            }
        }
    } else {
        // 处理错误响应
        println("错误: ${response.code} ${response.message}")
    }
} catch (e: Exception) {
    println("处理响应时发生异常: ${e.message}")
} finally {
    // 6. 关闭响应
    response.close()
}

以上代码示例展示了 OkHttp 请求构建和响应处理的完整流程，包括：

不同类型的请求构建（GET、POST、文件上传等）
各种响应处理方式（字符串、JSON、文件下载等）
同步和异步请求的处理差异
完整的请求-响应生命周期管理

这些示例可以作为实际开发中的参考模板。

2026-01-03发表9 分钟读完 (大约1303个字)

OkHttp 请求构建和响应处理流程源码分析

我需要分析 OkHttp 中请求构建和响应处理的源码流程。让我整理一下需要涵盖的内容：

一、请求构建流程

Request 构建代码

1
2
3

val request = Request.Builder()
    .url("https://api.example.com")
    .build()

请求构建流程
- Request.Builder 的使用
- 各种组件的构建（URL、Headers、RequestBody 等）
- 请求构建的设计模式分析
Request 构建

// 典型的构建器模式实现
class Request private constructor(
    @get:JvmName("url") val url: HttpUrl,
    @get:JvmName("method") val method: String,
    @get:JvmName("headers") val headers: Headers,
    @get:JvmName("body") val body: RequestBody?,
    val tags: Map<Class<*>, Any>
) {
    // 构建器类
    class Builder {
        private var url: HttpUrl? = null
        private var method = "GET"
        private var headers = Headers.Builder()
        private var body: RequestBody? = null
        private var tags = mutableMapOf<Class<*>, Any>()

        // 设置URL (支持多种形式)
        fun url(url: String): Builder = url(url.toHttpUrl())
        fun url(url: HttpUrl): Builder {
            this.url = url
            return this
        }

        // 设置请求方法
        fun method(method: String, body: RequestBody?): Builder {
            // 检查方法名和body的合法性
            if (method.isEmpty()) throw IllegalArgumentException("method.isEmpty()")
            if (method !in METHODS_ALLOWING_BODY && body != null) {
                throw IllegalArgumentException("method $method must not have a request body")
            }
            if (method in METHODS_REQUIRING_BODY && body == null) {
                throw IllegalArgumentException("method $method must have a request body")
            }

            this.method = method
            this.body = body
            return this
        }

        // 便捷方法: GET请求
        fun get(): Builder = method("GET", null)

        // 便捷方法: POST请求
        fun post(body: RequestBody): Builder = method("POST", body)

        // 添加Header
        fun addHeader(name: String, value: String): Builder {
            headers.add(name, value)
            return this
        }

        // 设置完整Headers
        fun headers(headers: Headers): Builder {
            this.headers = headers.newBuilder()
            return this
        }

        // 构建最终Request对象
        fun build(): Request {
            // 检查URL是否已设置
            val url = checkNotNull(this.url) { "url == null" }
            return Request(
                url = url,
                method = method,
                headers = headers.build(),
                body = body,
                tags = tags.toMap()
            )
        }
    }
}

RequestBody 实现

// 抽象类定义
abstract class RequestBody {
    // 返回内容类型
    abstract fun contentType(): MediaType?

    // 返回内容长度
    open fun contentLength(): Long = -1L

    // 写入内容到缓冲区
    abstract fun writeTo(sink: BufferedSink)

    // 创建请求体的工厂方法
    companion object {
        // 从字符串创建
        @JvmStatic
        fun create(
            contentType: MediaType?,
            content: String
        ): RequestBody = create(contentType, content.toByteArray())

        // 从字节数组创建
        @JvmStatic
        fun create(
            contentType: MediaType?,
            content: ByteArray
        ): RequestBody = create(contentType, content, 0, content.size)

        // 从文件创建
        @JvmStatic
        fun create(file: File, contentType: MediaType?): RequestBody {
            return object : RequestBody() {
                override fun contentType() = contentType

                override fun contentLength(): Long = file.length()

                override fun writeTo(sink: BufferedSink) {
                    file.source().use { source ->
                        sink.writeAll(source)
                    }
                }
            }
        }
    }
}

二、响应处理流程

响应处理流程
- Response 的结构
- ResponseBody 的处理
- 响应解析和转换机制
Response 结构

class Response private constructor(
    @get:JvmName("request") val request: Request,
    @get:JvmName("protocol") val protocol: Protocol,
    @get:JvmName("message") val message: String,
    @get:JvmName("code") val code: Int,
    @get:JvmName("headers") val headers: Headers,
    @get:JvmName("body") val body: ResponseBody?,
    @get:JvmName("networkResponse") val networkResponse: Response?,
    @get:JvmName("cacheResponse") val cacheResponse: Response?,
    @get:JvmName("priorResponse") val priorResponse: Response?,
    internal val sentRequestAtMillis: Long,
    internal val receivedResponseAtMillis: Long,
    @get:JvmName("exchange") internal val exchange: Exchange?,
) {
    // 检查响应是否成功
    val isSuccessful: Boolean
        get() = code in 200..299

    // 构建器类
    class Builder {
        // 省略实现细节...
    }

    // 关闭响应体
    fun close() {
        body?.close()
    }
}

ResponseBody 处理

abstract class ResponseBody : Closeable {
    // 返回内容类型
    abstract fun contentType(): MediaType?

    // 返回内容长度
    abstract fun contentLength(): Long

    // 获取字节流
    abstract fun source(): BufferedSource

    // 获取字节数组
    fun bytes(): ByteArray {
        val contentLength = contentLength()
        if (contentLength > Int.MAX_VALUE) {
            throw IOException("Cannot buffer entire body for content length: $contentLength")
        }

        val bytes = source().use { it.readByteArray() }
        if (contentLength != -1L && contentLength != bytes.size.toLong()) {
            throw IOException("Content-Length and stream length disagree")
        }
        return bytes
    }

    // 获取字符串
    fun string(): String {
        val source = source()
        try {
            return source.readString(source.readByteArray().size.toLong(), Charsets.UTF_8)
        } finally {
            source.close()
        }
    }
}

响应处理流程

// 使用Response的典型流程
val response = client.newCall(request).execute()

try {
    // 1. 检查响应状态
    if (response.isSuccessful) {
        // 2. 获取响应体
        val responseBody = response.body

        // 3. 根据Content-Type处理数据
        val contentType = responseBody?.contentType()

        // 4. 读取响应数据
        val responseString = responseBody?.string()
        // 或者
        val responseBytes = responseBody?.bytes()
        // 或者
        val responseStream = responseBody?.source()
    } else {
        // 处理错误响应
        println("请求失败: ${response.code}")
    }
} finally {
    // 5. 关闭响应
    response.close()
}

响应流程详解

响应创建：
- 通过拦截器链处理网络请求
- CallServerInterceptor生成原始 Response
- 各拦截器可能修改 Response（如缓存拦截器）
响应体流式处理：
- ResponseBody 采用流式 API
- 数据按需加载，避免一次性加载大文件
- 支持多种数据转换形式（string(), bytes(), source()）
响应关闭机制：
- 必须手动关闭响应以释放连接
- 适用 try-finally 模式确保资源释放
- 未关闭的响应可能导致连接池耗尽

设计亮点分析

构建器模式的精巧应用
- Request.Builder 和 Response.Builder 使构建过程简洁直观
- 链式调用提高代码可读性
- 参数验证在构建时进行，避免运行时错误
请求体的抽象设计
- RequestBody 抽象类允许多种请求数据形式
- 工厂方法简化常见请求体创建
- 流式API高效处理大文件上传
响应处理的流式设计
- 延迟加载机制减少内存占用
- BufferedSource 接口提供灵活的数据读取方式
- 显式关闭机制确保资源正确释放
类型安全与灵活性平衡
- MediaType 类型处理确保内容类型正确
- Headers 类封装HTTP头部复杂处理逻辑
- 支持同步/异步两种处理模式

核心流程图

请求构建流程：
Request.Builder
    → 设置URL(url())
    → 设置方法(get/post/method())
    → 设置头部(headers/addHeader())
    → 设置请求体(body)
    → build() → Request对象

响应处理流程：
Response对象
    → 检查状态码(isSuccessful)
    → 获取ResponseBody
    → 读取数据(string/bytes/source)
    → 处理业务逻辑
    → 关闭响应(close)

2026-01-02发表5 分钟读完 (大约700个字)

OkHttp 源码分析路线图

1. 基础组件模块

OkHttpClient（核心配置类）
  ├── 连接池管理
  ├── 线程池管理
  └── 各种配置参数

2. 请求响应模块

Request/Response（请求响应模型）
  ├── RequestBody
  ├── ResponseBody
  ├── Headers
  └── HttpUrl

3. 核心流程模块

1
2
3

Call（请求执行流程）
  ├── RealCall（同步请求）
  └── AsyncCall（异步请求）

让我们按照以下顺序深入分析：

一、基础组件层

OkHttpClient 分析

构建器模式的使用
默认配置项的设定
连接池的管理机制

连接池管理

class ConnectionPool(
    maxIdleConnections: Int = 5,
    keepAliveDuration: Long = 5,
    timeUnit: TimeUnit = TimeUnit.MINUTES
) {
    // 连接复用机制
    // 空闲连接清理
}

二、请求响应层

请求构建流程

1
2
3

val request = Request.Builder()
    .url("https://api.example.com")
    .build()

响应处理机制

响应体的流式处理
数据转换机制

三、核心执行层

同步请求流程

// RealCall 执行流程
class RealCall implements Call {
    override fun execute(): Response {
        // 同步请求实现
    }
}

异步请求流程

// AsyncCall 实现原理
class AsyncCall extends NamedRunnable {
    // 异步请求实现
}

四、重点关注的核心机制

连接复用机制

连接池的实现
连接的生命周期管理
Keep-Alive 策略

缓存机制

缓存策略的实现
缓存验证机制
缓存替换策略

DNS 解析

DNS 缓存机制
自定义 DNS 实现

失败重试机制

重试策略
重定向处理

HTTP/2 支持

多路复用实现
流量控制

分析建议

循序渐进

先了解整体架构
再深入具体模块
最后研究细节实现

重点关注

类的职责划分
接口设计原则
性能优化手段

实践验证

编写测试用例
修改源码观察效果
对比不同版本变化

源码阅读技巧

从使用示例开始
跟踪调用链路
关注设计模式应用

建议的学习顺序

第一阶段：基础认知

OkHttpClient 的配置项
Request/Response 的基本结构
同步/异步调用方式

第二阶段：核心流程

拦截器链的完整执行过程
网络请求的处理流程
连接池的管理机制

第三阶段：深入细节

HTTP/2 的实现原理
缓存机制的具体实现
安全机制（证书、HTTPS 等）

第四阶段：性能优化

连接复用策略
内存管理优化
并发控制机制

通过这样系统的分析，您可以：

深入理解 OkHttp 的设计思想
掌握网络库的核心实现
学习优秀的代码设计方法

需要深入了解哪个具体模块，我可以为您详细展开分析。

2026-01-01发表4 分钟读完 (大约610个字)

OkHttp 拦截器的核心源码分析

1. 拦截器接口定义

interface Interceptor {
    @Throws(IOException::class)
    fun intercept(chain: Chain): Response

    interface Chain {
        fun request(): Request
        fun proceed(request: Request): Response
        // ... 其他方法
    }
}

2. RealInterceptorChain 的核心实现

class RealInterceptorChain(
    private val interceptors: List<Interceptor>,
    private val index: Int,
    private val request: Request,
    // ... 其他参数
) : Interceptor.Chain {

    override fun proceed(request: Request): Response {
        // 检查是否到达链条末端
        if (index >= interceptors.size) throw AssertionError()

        // 创建下一个拦截器链
        val next = RealInterceptorChain(
            interceptors = interceptors,
            index = index + 1,
            request = request,
            // ... 其他参数
        )

        // 获取当前拦截器并执行
        val interceptor = interceptors[index]
        val response = interceptor.intercept(next)

        return response
    }
}

3. OkHttpClient 中的拦截器管理

class OkHttpClient internal constructor(builder: Builder) {
    // 应用拦截器列表
    internal val interceptors: List<Interceptor> = builder.interceptors

    // 网络拦截器列表
    internal val networkInterceptors: List<Interceptor> = builder.networkInterceptors

    class Builder {
        internal val interceptors: MutableList<Interceptor> = mutableListOf()
        internal val networkInterceptors: MutableList<Interceptor> = mutableListOf()
    }
}

4. 核心执行流程：

class RealCall(
    private val client: OkHttpClient,
    // ... 其他参数
) {
    override fun execute(): Response {
        // 构建完整的拦截器链
        val interceptors = mutableListOf<Interceptor>()

        // 1. 添加用户自定义的应用拦截器
        interceptors.addAll(client.interceptors)

        // 2. 添加OkHttp内置的核心拦截器
        interceptors.add(RetryAndFollowUpInterceptor(client))
        interceptors.add(BridgeInterceptor(client.cookieJar))
        interceptors.add(CacheInterceptor(client.cache))
        interceptors.add(ConnectInterceptor(client))

        // 3. 添加用户自定义的网络拦截器
        interceptors.addAll(client.networkInterceptors)

        // 4. 添加服务器通信拦截器
        interceptors.add(CallServerInterceptor())

        // 创建拦截器链并执行
        val chain = RealInterceptorChain(
            interceptors = interceptors,
            index = 0,
            request = originalRequest,
            // ... 其他参数
        )

        return chain.proceed(originalRequest)
    }
}

5. 内置核心拦截器的职责：

RetryAndFollowUpInterceptor: 处理重试和重定向
BridgeInterceptor: 处理请求头和响应头的转换
CacheInterceptor: 处理请求缓存
ConnectInterceptor: 建立连接
CallServerInterceptor: 与服务器进行实际通信

6. 责任链模式的关键点：

class CustomInterceptor : Interceptor {
    override fun intercept(chain: Chain): Response {
        // 1. 获取原始请求
        val originalRequest = chain.request()

        // 2. 处理请求（可选）
        val modifiedRequest = originalRequest.newBuilder()
            .addHeader("Custom-Header", "Value")
            .build()

        // 3. 转发给下一个拦截器
        val response = chain.proceed(modifiedRequest)

        // 4. 处理响应（可选）
        return response.newBuilder()
            .addHeader("Response-Header", "Value")
            .build()
    }
}

这种设计的优点：

高度解耦，每个拦截器只负责自己的任务
灵活可扩展，可以随时添加或移除拦截器
双向处理能力，可以同时处理请求和响应
链式调用清晰，调试方便

注意事项：

拦截器的添加顺序会影响最终的执行顺序
必须调用 chain.proceed() 来继续链条，除非你想中断请求
注意处理异常，确保资源正确释放
避免在拦截器中执行耗时操作，可能会影响整体性能

2025-12-31发表8 分钟读完 (大约1254个字)

在 Windows 上调试 Android TV 并模拟方向键和返回键的操作

在 Windows 上调试 Android TV 并模拟方向键和返回键的操作，可以通过以下工具和方法实现。这些工具支持通过 ADB（Android Debug Bridge）发送按键事件，从而模拟遥控器操作。

1. 使用 ADB 命令行

ADB 是调试 Android 设备的核心工具，您可以直接通过命令行发送按键事件来模拟方向键和返回键。

步骤：

安装 ADB 工具：
- 下载并安装 Platform Tools（包含 ADB 工具）。
- 解压后将 adb.exe 所在目录添加到系统的环境变量中，方便全局调用。
连接 Android TV：
- 确保 Android TV 和电脑处于同一局域网。
- 在 Android TV 上启用开发者选项，并开启“USB 调试”或“网络调试”。
- 使用以下命令连接设备：
  1
  adb connect <TV_IP>:5555
  示例：
  1
  adb connect 192.168.1.100:5555
发送按键事件：
使用以下命令模拟方向键和返回键：
- 返回键（KEYCODE_BACK）：
  1
  adb shell input keyevent 4
- 方向键上（KEYCODE_DPAD_UP）：
  1
  adb shell input keyevent 19
- 方向键下（KEYCODE_DPAD_DOWN）：
  1
  adb shell input keyevent 20
- 方向键左（KEYCODE_DPAD_LEFT）：
  1
  adb shell input keyevent 21
- 方向键右（KEYCODE_DPAD_RIGHT）：
  1
  adb shell input keyevent 22
- 确定键（KEYCODE_ENTER）：
  1
  adb shell input keyevent 23

优点：

免费且无需额外工具。
支持高度定制化。

缺点：

需要手动输入命令，效率较低。

2. 使用 Scrcpy

Scrcpy 是一款开源的 Android 屏幕投射和控制工具，支持通过鼠标或键盘模拟 Android TV 的操作。

步骤：

下载 Scrcpy：
- 前往 Scrcpy GitHub 页面下载最新版本。
- 解压后运行 scrcpy.exe。
连接 Android TV：
- 同样需要启用开发者选项和网络调试。
- 使用以下命令启动 Scrcpy：
  1
  scrcpy --tcpip=<TV_IP>:5555
模拟按键：
- 在 Scrcpy 窗口中，使用键盘的方向键即可模拟 Android TV 的方向键操作。
- 按下键盘上的 Esc 键可模拟返回键。

优点：

提供屏幕投射功能，便于观察操作效果。
支持鼠标点击和键盘按键模拟。

缺点：

需要一定的学习成本。
不适合批量自动化操作。

3. 使用 ADB Remote ATV（Windows 版）

ADB Remote ATV 是一款专为 Android TV 设计的虚拟遥控器工具，支持通过 ADB 模拟方向键、返回键等操作。

步骤：

下载工具：
- 前往 GitHub 项目页面或 Gitee 项目页面下载最新版本。
配置 ADB 连接：
- 打开工具并输入 Android TV 的 IP 地址。
- 点击“连接”按钮。
模拟按键：
- 界面上提供了虚拟的方向键、返回键和其他按键，点击即可发送对应的 ADB 命令。

优点：

图形化界面，操作简单直观。
支持多种按键模拟。

缺点：

功能相对基础，不适合复杂场景。

4. 使用 AutoHotkey（AHK）脚本

如果您希望在 Windows 上创建一个自定义的快捷键映射工具，可以使用 AutoHotkey 编写脚本。

步骤：

安装 AutoHotkey：
- 前往 AutoHotkey 官网下载并安装。

编写脚本：
创建一个新的 .ahk 文件，内容如下：

; 模拟方向键
Up::Run, adb shell input keyevent 19
Down::Run, adb shell input keyevent 20
Left::Run, adb shell input keyevent 21
Right::Run, adb shell input keyevent 22

; 模拟返回键
Esc::Run, adb shell input keyevent 4

; 模拟确定键
Enter::Run, adb shell input keyevent 23

运行脚本：
- 双击 .ahk 文件运行脚本。
- 按下键盘上的方向键或 Esc 键即可发送对应的 ADB 命令。

优点：

高度灵活，可根据需求自定义快捷键。
支持一键触发复杂操作。

缺点：

需要一定的脚本编写能力。

5. 使用 Total Control

Total Control 是一款商业化的 Android 控制工具，支持通过 PC 模拟 Android TV 的各种操作。

特点：

支持多设备管理。
提供虚拟遥控器功能，可模拟方向键和返回键。
支持自动化测试和脚本录制。

下载地址：

官网：https://www.sigma-rt.com/

优点：

功能强大，适合专业开发和测试。
提供图形化界面。

缺点：

商业软件，可能需要付费。

总结

根据您的需求，推荐以下选择：

简单易用：使用 ADB Remote ATV 或 Scrcpy。
灵活性高：使用 ADB 命令行 或 AutoHotkey 脚本。
专业工具：选择 Total Control。

如果只是偶尔调试，建议从 ADB 命令行或 Scrcpy 开始；如果需要长期使用，可以考虑更专业的工具。

2025-12-30发表4 分钟读完 (大约576个字)

各手机品牌后台联网及耗电策略设置引导文档@2025

📱 各手机品牌后台联网与耗电策略设置引导

为确保 App 能在后台下载，避免被系统过度节电限制，请根据您手机的品牌，按以下步骤手动设置。

🔹 小米（MIUI 系统）

设置路径：
长按 App 桌面图标 → 应用信息 → 电量消耗 → 省电策略 → 不限制

说明：
将“省电策略”设置为“不限制”，可避免系统在后台自动关闭 APP 网络或进程。

🔹 华为（HarmonyOS / EMUI 系统）

设置路径：

打开设置 → 电池 → 性能模式
打开设置 → 电池 → 更多电池设置 → 休眠时始终保持网络连接
打开设置 → 应用和服务 → 应用管理 → App → 耗电详情 → 启动管理 → 允许后台活动

若“允许后台活动”选项无法开启，请先关闭“自动管理”开关。

说明：
开启性能模式并保持休眠时网络连接，可确保应用后台数据传输稳定。

🔹 OPPO & 一加（ColorOS 系统）

设置路径：
长按 App 桌面图标 → 应用详情 → 耗电管理 → 完全允许后台行为

说明：
“完全允许后台行为”可确保 APP 在锁屏或后台状态下依然能正常联网。

🔹 VIVO（OriginOS / FuntouchOS 系统）

设置路径：
设置 → 电池 → 后台耗电管理 → App → 允许后台高耗电

说明：
开启“允许后台高耗电”，防止系统限制 APP 的网络请求或后台播放。

🔹 iQOO（OriginOS / FuntouchOS 系统）

设置路径：
长按 App 桌面图标 → 应用信息 → 电量 → 后台耗电管理 → 允许后台高耗电

说明：
允许后台高耗电可避免系统在后台自动冻结应用，确保后台下载视频稳定。

✅ 温馨提示：

以上设置仅影响 App 的后台运行权限，不会对其他应用造成影响。
若您的系统版本或界面略有差异，请根据相近选项进行操作。

OkHttp 请求构建和响应处理的完整流程