博易阁

ESP32定时控制GPIO2灯

Tue, 21 Apr 2026 15:47:07 +0800

直接在 Thonny 里运行、ESP32 可用、每天 7:30 自动点亮 GPIO2 灯 1 分钟后关闭的完整 MicroPython 代码。

功能说明

每天 7:30 自动打开 GPIO2（开发板板载 LED）
保持 1 分钟后自动关闭
自带网络同步时间（不用手动设时间）
掉电/重启后依然能自动运行

完整可直接复制代码（MicroPython）

import machine
import network
import ntptime
import time

# ===================== 配置区 =====================
WIFI_SSID = "你的WiFi名称"       # 改成你的WiFi
WIFI_PASSWORD = "你的WiFi密码"   # 改成你的WiFi密码
TARGET_HOUR = 7                 # 几点
TARGET_MINUTE = 30              # 几分
DURATION_SECONDS = 60           # 持续时间（秒）
LED_PIN = 2                     # 板载LED引脚（大部分ESP32是2）
# ==================================================

# 初始化LED
led = machine.Pin(LED_PIN, machine.Pin.OUT)
led.value(0)  # 初始关闭

# 连接WiFi
def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print("正在连接WiFi...")
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        while not wlan.isconnected():
            time.sleep(0.5)
    print("WiFi连接成功！IP:", wlan.ifconfig()[0])

# 同步网络时间（NTP）
def sync_time():
    try:
        ntptime.settime()
        print("时间同步成功！")
        # 东八区偏移 +8小时
        tm = time.localtime(time.time() + 8 * 3600)
        print("当前时间：%04d-%02d-%02d %02d:%02d:%02d" % tm[0:6])
    except:
        print("时间同步失败，稍后重试")

# 主循环：每天定时开关灯
def main_loop():
    while True:
        # 获取东八区时间
        now = time.time() + 8 * 3600
        tm = time.localtime(now)
        current_hour = tm[3]
        current_minute = tm[4]
        current_second = tm[5]

        # 打印时间（每秒一次）
        print("当前时间：%02d:%02d:%02d" % (current_hour, current_minute, current_second))

        # 判断是否到 7:30:00
        if current_hour == TARGET_HOUR and current_minute == TARGET_MINUTE and current_second == 0:
            print("=== 到达设定时间，开灯！===")
            led.value(1)  # 开灯
            time.sleep(DURATION_SECONDS)  # 保持设定时长
            led.value(0)  # 关灯
            print("=== 时间到，关灯！===")
            time.sleep(50)  # 防止重复触发

        time.sleep(1)

# 启动
print("===== ESP32 定时开灯程序 =====")
connect_wifi()
sync_time()
main_loop()

使用方法

打开 Thonny
把 ESP32 连接电脑
复制上面代码
修改 WiFi 名称和密码
点击运行

效果

每天 7:30:00 GPIO2 输出高电平 → 灯亮
持续 60 秒
自动关闭
每天重复执行

常见问题

灯不亮？

部分 ESP32 板载 LED 是低电平点亮
把代码里的 led.value(1) 和 led.value(0) 互换即可

时间不准？

代码已经用了 NTP 网络对时
确保 WiFi 能上网

总结

代码实现每天 7:30 自动开灯 1 分钟
自带 WiFi 对时，无需手动设置时间
直接在 Thonny 运行，无需额外库
稳定、掉电重启后自动继续运行

Kotlin中Response与CALL的区别

Sun, 15 Mar 2026 12:02:41 +0800

在 Kotlin 结合 Retrofit 访问 API 时，Response 和 Call 是两种核心的返回类型，尤其在 lifecycleScope 中使用协程时差异显著。我会从用法、特性、适配性三个维度帮你讲清楚它们的区别。

一、核心概念与本质区别

1. Call（传统回调式）

Call 是 Retrofit 早期的核心类型，本质是一个可执行的请求对象，本身不支持协程，需要通过回调（enqueue）或阻塞调用（execute）来执行请求：

它是一个「请求载体」，创建后不会自动执行，必须手动调用 enqueue()（异步）或 execute()（同步）
不支持挂起函数（suspend），如果强行在 suspend fun 中返回 Call，协程的挂起特性会失效
典型用法（非协程）：

// API 定义
@POST("Sendcode")
fun Sendcode(@Query("email") email: String): Call<CodesendRs>

// 调用（传统回调）
lifecycleScope.launch {
    val call = apiService.Sendcode("test@example.com")
    // 异步执行（回调方式）
    call.enqueue(object : Callback<CodesendRs> {
        override fun onResponse(call: Call<CodesendRs>, response: Response<CodesendRs>) {
            if (response.isSuccessful) {
                val data = response.body() // 成功数据
            } else {
                // 处理错误（4xx/5xx）
            }
        }

        override fun onFailure(call: Call<CodesendRs>, t: Throwable) {
            // 处理网络错误
        }
    })
}

2. Response（协程挂起式）

Response 是 Retrofit 对协程支持的核心返回类型，必须配合 suspend 函数使用：

suspend 函数执行时会自动挂起协程，直到请求完成（无需手动调用 enqueue/execute）
Response 封装了完整的响应信息（状态码、响应体、头信息等），是请求执行后的「结果载体」
典型用法（协程推荐）：

// API 定义（推荐）
@POST("Sendcode")
suspend fun Sendcode(@Query("email") email: String): Response<CodesendRs>

// 调用（lifecycleScope 协程）
lifecycleScope.launch {
    try {
        val response = apiService.Sendcode("test@example.com")
        if (response.isSuccessful) {
            // 成功：获取响应体
            val data = response.body()
            val code = response.code() // 状态码（200/201 等）
        } else {
            // 失败：处理 4xx/5xx 错误
            val errorBody = response.errorBody()?.string()
        }
    } catch (e: Exception) {
        // 处理网络异常（如无网络、超时）
    }
}

二、关键差异对比

特性	Call	Response （suspend）
协程适配性	不原生支持，需手动封装	原生支持，挂起函数自动挂起协程
执行方式	需手动调用 enqueue()/execute()	调用函数自动执行，协程挂起等待
错误处理	回调分 onResponse/onFailure	统一通过 try-catch 处理
代码风格	回调嵌套（回调地狱风险）	线性代码（协程同步写法）
生命周期感知	需手动取消 call.cancel()	依托 lifecycleScope自动取消
响应信息获取	需通过 Response中间对象	直接返回 Response，信息完整

三、补充说明（容易混淆的点）

为什么 suspend fun 不能返回 Call？

Retrofit 规定：如果函数标记为 suspend，返回类型只能是「响应体」（如 CodesendRs）或 Response，返回 Call 会编译报错。

如果你想简化代码，也可以直接返回实体类（无需 Response）：

// 简化版：直接返回响应体（失败时抛出异常） @POST("Sendcode") suspend fun Sendcode(@Query("email") email: String): CodesendRs

这种写法的缺点是：无法获取状态码、响应头，所有错误（包括 4xx/5xx）都会抛出异常。

Call 的取消 vs 协程的取消

使用 Call 时：需要在 lifecycleScope 销毁时手动调用 call.cancel()，否则请求可能泄露；
使用 suspend + Response 时：lifecycleScope 销毁会自动取消协程，Retrofit 会中断请求，无需手动处理。

总结

Call 是 Retrofit 传统回调模式的产物，不适合在 lifecycleScope 协程中使用，代码冗余且需要手动管理生命周期；
Response（配合 suspend）是协程时代的推荐写法，适配 lifecycleScope 生命周期感知，代码线性易读，错误处理统一；
实际开发中，优先使用 suspend fun + Response<实体类>，既保留完整的响应信息，又能享受协程的简洁性。

kotlin获取设备的公网IP

Tue, 24 Feb 2026 22:11:44 +0800

Android 里没有直接“读系统公网IP”的 API，只能通过请求外网接口拿到当前出口公网 IP。

下面 Kotlin 可用的最简方案。

一、最稳方案：请求公开 IP 接口

权限（AndroidManifest.xml）

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

Kotlin 代码（协程版）

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.net.URL

/** 获取公网IP */
suspend fun getPublicIp(): String = withContext(Dispatchers.IO) {
    try {
        // 常用接口，任选一个
        val ip = URL("https://api.ipify.org").readText()
        // val ip = URL("https://icanhazip.com").readText()
        ip
    } catch (e: Exception) {
        e.toString()
    }
}

调用示例：

lifecycleScope.launch {
    val ip = getPublicIp()
    Log.d("PublicIP", ip)
}

遇到的 java.net.ConnectException 是典型的网络连接失败问题，api.ipify.org 虽然稳定，但会受网络环境（如代理、防火墙、DNS解析、HTTPS证书）影响导致连接失败。下面完整的解决方案，包含「备用接口 + 超时重试 + 异常处理」，彻底解决这个问题。

上面使用时返回java.net.ConnectException: Failed to connect to api.ipify.org/172.67.74.152:443错误，更改方案如下

第一步：先理解错误原因

Failed to connect to api.ipify.org/172.67.74.152:443 表示：

DNS解析到了 172.67.74.152，但无法建立TCP连接（443端口是HTTPS）；
常见原因：网络禁用HTTPS、代理配置错误、接口被墙、设备网络权限未生效。

第二步：修复后的完整代码（Android + Kotlin）

这个版本包含多接口重试 + 超时控制 + 详细异常提示，稳定性大幅提升：

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import java.net.HttpURLConnection
import java.net.URL
import java.util.concurrent.TimeUnit

object IpUtils {
    // 备用公网IP接口列表（优先选国内可访问的）
    private val IP_API_LIST = listOf(
        "https://api.ipify.org",          // 基础版
        "https://icanhazip.com",          // 备用1
        "https://ifconfig.me/ip",         // 备用2
        "http://icanhazip.com",           // 降级为HTTP（避免HTTPS证书问题）
        "http://ifconfig.me/ip"           // 降级为HTTP（最后兜底）
    )

    /**
     * 获取公网IP（带重试+超时）
     * @return 公网IP字符串，失败返回具体原因
     */
    suspend fun getPublicIpWithRetry(): String = withContext(Dispatchers.IO) {
        var lastException: Exception? = null

        // 遍历接口列表，逐个尝试
        for (apiUrl in IP_API_LIST) {
            try {
                val url = URL(apiUrl)
                // 手动创建连接，添加超时控制（关键）
                val connection = url.openConnection() as HttpURLConnection
                connection.apply {
                    connectTimeout = 5000  // 连接超时5秒
                    readTimeout = 5000     // 读取超时5秒
                    requestMethod = "GET"
                    instanceFollowRedirects = true  // 允许重定向
                }

                // 检查响应码
                if (connection.responseCode == 200) {
                    val ip = connection.inputStream.bufferedReader().readText().trim()
                    connection.disconnect()
                    // 过滤空值/无效IP
                    if (ip.isNotBlank() && ip.contains(".")) {
                        return@withContext ip
                    }
                }
            } catch (e: Exception) {
                lastException = e
                // 打印当前接口失败原因，继续试下一个
                println("接口 $apiUrl 失败: ${e.message}")
                continue
            }
        }

        // 所有接口都失败，返回最后一次异常信息
        return@withContext "获取失败: ${lastException?.message ?: "未知错误"}"
    }
}

第三步：调用方式

// 在Activity/Fragment中调用

lifecycleScope.launch {
    val ip = IpUtils.getPublicIpWithRetry()
    // 更新UI（已回到主线程）
    tvIp.text = "公网IP：$ip"
}

第四步：额外排查步骤（如果仍失败）

如果修复后还是连接失败，按以下顺序排查：

检查网络权限：确认 AndroidManifest.xml 中
已添加，且没有
缺失（可选）；
关闭代理/VPN：如果设备开启了代理、VPN，先关闭再测试（很多时候是代理导致HTTPS连接失败）；
测试HTTP接口：代码中已加入HTTP接口兜底，优先尝试 http://icanhazip.com（避免HTTPS证书问题）；
检查网络环境：切换Wi-Fi/手机流量测试（部分局域网会屏蔽外网接口）；
手动验证接口：在浏览器/Postman中访问 https://api.ipify.org，确认能返回IP（如果浏览器也打不开，说明该接口在当前网络不可用）。

总结

核心问题：api.ipify.org 连接失败是网络环境导致，而非代码问题；
解决方案：通过「多接口重试 + 超时控制 + HTTP降级」提升稳定性；
排查重点：优先检查网络权限、代理/防火墙、接口可访问性。

kotlin 图标长按弹出快捷菜单及跳转

Mon, 26 Jan 2026 19:10:45 +0800

安卓实现长按App图标弹出快捷菜单并跳转指定页面，核心用App Shortcuts（应用快捷方式），分静态快捷方式（清单配置，无需代码）和动态快捷方式（代码动态添加），以下是可直接使用的完整实现方案：

一、静态快捷方式（推荐，简单高效，适用于固定跳转）

通过AndroidManifest.xml配置，应用安装后即可生效，支持API 25+。

步骤1：配置清单文件（AndroidManifest.xml）

在启动页标签内添加，关联快捷方式资源文件：

<!-- 启动页Activity（通常是MainActivity） -->
<activity
    android:name=".ui.MainActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>

    <!-- 关联App Shortcuts资源 -->
    <meta-data
        android:name="android.app.shortcuts"
        android:resource="@xml/shortcuts" />
</activity>

步骤2：创建快捷方式资源文件

在res/xml/目录下新建shortcuts.xml（无xml目录则手动创建），配置跳转的页面和菜单信息：

<?xml version="1.0" encoding="utf-8"?>
<shortcuts xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- 快捷方式1：跳转“我的行程”页面 -->
    <shortcut
        android:enabled="true"
        android:icon="@mipmap/ic_shortcut_travel" <!-- 菜单图标（建议24x24dp） -->
        android:shortcutId="travel" <!-- 唯一ID，不可重复 -->
        android:shortcutLongLabel="@string/shortcut_long_travel" <!-- 长按显示的长名称 -->
        android:shortcutShortLabel="@string/shortcut_short_travel"> <!-- 短名称（优先显示） -->
        <!-- 跳转的意图：指定目标Activity -->
        <intent
            android:action="android.intent.action.VIEW"
            android:targetClass="com.xzb.bolvtravel2.ui.travel.TravelActivity" <!-- 目标页面全类名 -->
            android:targetPackage="com.xzb.bolvtravel2" /> <!-- App包名 -->
        <!-- 若需多个intent，可添加，按顺序执行 -->
        <categories android:name="android.shortcut.conversation" />
    </shortcut>

    <!-- 快捷方式2：跳转“个人中心”页面（可添加多个） -->
    <shortcut
        android:enabled="true"
        android:icon="@mipmap/ic_shortcut_mine"
        android:shortcutId="mine"
        android:shortcutLongLabel="@string/shortcut_long_mine"
        android:shortcutShortLabel="@string/shortcut_short_mine">
        <intent
            android:action="android.intent.action.VIEW"
            android:targetClass="com.xzb.bolvtravel2.ui.mine.MineActivity"
            android:targetPackage="com.xzb.bolvtravel2" />
        <categories android:name="android.shortcut.conversation" />
    </shortcut>
</shortcuts>

步骤3：配置字符串和图标（res/values/strings.xml）

<!-- 快捷方式文字 -->
<string name="shortcut_short_travel">我的行程</string>
<string name="shortcut_long_travel">查看我的出行行程</string>
<string name="shortcut_short_mine">个人中心</string>
<string name="shortcut_long_mine">进入我的个人中心</string>

图标要求：使用mipmap目录的矢量图/位图，建议24x24dp，避免过大导致变形。

二、动态快捷方式（适用于动态更新的菜单，如“最近订单”）

通过ShortcutManager代码实现，可在应用运行时添加/删除/更新快捷方式，支持API 25+，核心代码在Application或启动页MainActivity中。

核心代码（Kotlin版，适配你的开发语言）

import android.content.Context
import android.content.Intent
import android.os.Build
import android.content.pm.ShortcutInfo
import android.content.pm.ShortcutManager
import android.graphics.drawable.Icon
import androidx.annotation.RequiresApi
import com.xzb.bolvtravel2.ui.order.OrderActivity // 目标页面

class MyApp : android.app.Application() {
    override fun onCreate() {
        super.onCreate()
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
            initDynamicShortcuts() // 初始化动态快捷方式
        }
    }

    @RequiresApi(Build.VERSION_CODES.N_MR1)
    private fun initDynamicShortcuts() {
        val shortcutManager = getSystemService(Context.SHORTCUT_SERVICE) as ShortcutManager
        // 检查是否支持快捷方式
        if (!shortcutManager.isRequestPinShortcutSupported) return

        // 构建跳转意图
        val orderIntent = Intent(this, OrderActivity::class.java).apply {
            action = Intent.ACTION_VIEW
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
        }

        // 构建动态快捷方式
        val dynamicShortcut = ShortcutInfo.Builder(this, "dynamic_order")
            .setShortLabel("最近订单") // 短名称
            .setLongLabel("查看我的最近出行订单") // 长名称
            .setIcon(Icon.createWithResource(this, R.mipmap.ic_shortcut_order)) // 图标
            .setIntent(orderIntent) // 跳转意图
            .build()

        // 添加到快捷方式列表（最多5个，静态+动态总数不超过5）
        shortcutManager.dynamicShortcuts = listOf(dynamicShortcut)
    }
}

注意：需在AndroidManifest.xml中注册MyApp：

<application
    android:name=".MyApp"
    ...>
    ...
</application>

三、关键注意事项（必看，避免踩坑）

数量限制：静态+动态快捷方式总数不超过5个，多余的不会显示。
页面权限：目标Activity需在AndroidManifest.xml中注册，无需添加，若设置exported，建议为true（API 30+要求）。
API兼容：App Shortcuts最低支持API 25（Android 7.1），低于此版本无效果，无需做兼容（系统会自动忽略）。
图标和文字：短名称建议不超过10个字，长名称不超过25个字，图标使用纯色简约样式，适配不同桌面主题。
跳转逻辑：若目标页面需要传参，可在Intent中通过putExtra传递，和普通页面跳转一致。

四、效果测试

编译运行App，在手机桌面找到App图标；
长按图标，即可弹出配置的快捷菜单；
点击菜单选项，直接跳转到指定的Activity页面。

五、进阶：固定快捷方式到桌面（可选）

可通过代码让用户将快捷方式直接固定到桌面（需用户授权），核心代码：

@RequiresApi(Build.VERSION_CODES.O)
fun pinShortcut(context: Context) {
    val shortcutManager = context.getSystemService(ShortcutManager::class.java)
    val intent = Intent(context, TravelActivity::class.java).setAction(Intent.ACTION_VIEW)
    val shortcutInfo = ShortcutInfo.Builder(context, "pin_travel")
        .setShortLabel("我的行程")
        .setIcon(Icon.createWithResource(context, R.mipmap.ic_shortcut_travel))
        .setIntent(intent)
        .build()
    // 发起固定请求，用户确认后会显示在桌面
    shortcutManager.requestPinShortcut(shortcutInfo, null)
}

一为静态，二为动态，按需添加

kotlin 我应用使用的权限申请介绍

Fri, 23 Jan 2026 22:56:58 +0800

明明在应用清单（Manifest）里只声明了网络、存储、相机等少数权限，还主动移除了位置权限，但上架检测却测出了更多权限请求（比如之前提到的后台位置、悬浮窗、修改系统设置等），想知道这种权限不匹配的根本原因。

核心原因分析

这种 “声明的权限” 和 “检测出的权限” 不一致的情况，在安卓开发中非常常见，核心原因是权限会通过非主工程的渠道被引入，而非你手动声明的部分，具体分以下几类：

1. 第三方 SDK / 依赖库自动引入权限（最常见）

你用到的 “激光推送” SDK（以及可能的其他依赖，比如图片选择、相机封装库等），其自身的 AndroidManifest.xml 中可能声明了额外权限，安卓构建时会自动合并所有依赖的 Manifest，最终打包的 APK 中会包含这些 “隐式引入” 的权限。

举例：

激光推送 SDK 可能为了实现后台推送、唤醒设备，额外声明了 ACCESS_BACKGROUND_LOCATION（后台位置）、SYSTEM_ALERT_WINDOW（悬浮窗）等；
某些相机 / 相册库可能为了兼容旧版本，声明了 READ_PHONE_STATE（读取通话状态）等无关权限。

验证方式：
打开安卓工程的 build/outputs/logs/manifest-merger-xxx-report.txt（构建日志），搜索 “permission”，能清晰看到每个权限的来源（主工程 / 某个依赖库）。

2. `tools:node="remove"` 生效失败

你用了 tools:node="remove" 移除位置权限，但如果缺少必要的命名空间声明，这个属性会失效，导致移除操作没生效：

错误场景：Manifest 根节点未添加 xmlns:tools="http://schemas.android.com/tools"，此时 tools:node="remove" 是无效的，位置权限仍会被保留 / 合并。
正确写法示例：

<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"  <!-- 必须加这个命名空间 -->
    package="你的包名">    <!-- 此时remove才会生效 -->
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" tools:node="remove"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" tools:node="remove"/></manifest>

3. 上架检测不仅检测 “Manifest 声明的权限”，还检测 “运行时申请的权限”

部分应用商店的检测工具会扫描 APK 的代码（反编译），如果代码中存在 Context.checkSelfPermission()、Activity.requestPermissions() 等动态申请权限的逻辑，即使 Manifest 没声明，也会被标记为 “请求了该权限”。

举例：如果激光推送 SDK 的代码里包含申请 ACCESS_BACKGROUND_LOCATION 的逻辑，即使你没声明，检测工具也会判定应用 “请求了该权限”。

4. 权限的 “隐式关联”（少数情况）

安卓中某些 uses-feature 或系统 API 调用，会被检测工具判定为 “需要对应权限”：

比如声明 android.hardware.camera（即使 required=false），部分检测工具会关联到 “相机权限” 之外的辅助权限；
调用 Settings.System.putInt() 等修改系统设置的 API，即使没声明 WRITE_SETTINGS，也会被标记为 “请求修改系统设置权限”。

解决方案（按优先级）

1. 排查并移除依赖库引入的多余权限

在 Manifest 中对所有非必要的、由依赖引入的权限，统一用 tools:node="remove" 移除（确保命名空间正确）：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="你的包名">

    <!-- 你原有声明的权限 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-feature android:name="android.hardware.camera" android:required="false" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

    <!-- 主动移除所有非必要的、由依赖引入的权限 -->
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" tools:node="remove"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" tools:node="remove"/>
    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" tools:node="remove"/>
    <uses-permission android:name="android.permission.READ_PHONE_STATE" tools:node="remove"/>
    <uses-permission android:name="android.permission.READ_PHONE_NUMBERS" tools:node="remove"/>
    <uses-permission android:name="android.permission.WRITE_SETTINGS" tools:node="remove"/>
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" tools:node="remove"/>
    <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" tools:node="remove"/></manifest>

2. 检查第三方 SDK 的配置，关闭不必要的功能

联系激光推送 SDK 的开发者，或查看其文档，关闭 SDK 中不需要的功能（比如后台位置、悬浮窗推送等），从源头减少权限引入。

3. 验证最终打包的 Manifest

构建 APK 后，用 Android Studio 的 “Build> Analyze APK” 功能打开 APK，查看 AndroidManifest.xml，确认所有多余权限已被移除。

4. 针对 “运行时申请权限” 的检测结果

如果检测报告是因为代码中存在动态申请权限的逻辑，需：

移除代码中无关的权限申请逻辑；
若 SDK 内置了该逻辑且无法移除，需在应用商店的上架说明中解释 “该权限为 SDK 内置，但应用未实际使用，已通过 Manifest 移除”。

总结

权限不匹配的核心原因是第三方 SDK / 依赖库隐式引入权限，其次是 tools:node="remove" 命名空间缺失导致移除失效。
解决关键是：补全 tools 命名空间，主动移除所有非必要权限，验证最终 APK 的 Manifest。
若检测结果包含 “运行时申请权限”，需要么移除对应代码，要么在审核时说明权限未实际使用。

Kotlin中收起输入法

Fri, 16 Jan 2026 11:35:46 +0800

背景：我在开发时出现已点击按钮，由于前面焦点了输入框，导致输入法没收回，影响使用体验

想要在Kotlin开发的Android应用中，实现点击输入框外的区域或按钮时，自动收起弹出的软键盘，同时保持输入框本身不消失。

解决方案

我会提供两种最常用且实用的方法，你可以根据场景选择：

方法1：通用工具类（推荐）

创建一个工具类，封装收起软键盘的逻辑，可在任意地方调用（比如按钮点击、点击空白区域时）。

import android.content.Context
import android.view.View
import android.view.inputmethod.InputMethodManager
import android.widget.EditText

/**
 * 软键盘工具类
 */
object KeyboardUtils {

    /**
     * 隐藏软键盘
     * @param view 任意View（通常传EditText或当前Activity的根布局）
     */
    fun hideSoftKeyboard(view: View) {
        val imm = view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(view.windowToken, 0)
    }

    /**
     * 为布局设置点击空白区域隐藏软键盘
     * @param rootView 根布局（比如Activity的contentView）
     * @param editText 需要监听的输入框
     */
    fun setupTouchOutsideToHideKeyboard(rootView: View, editText: EditText) {
        rootView.setOnTouchListener { v, event ->
            // 判断点击的不是输入框时，隐藏软键盘
            if (v != editText) {
                hideSoftKeyboard(editText)
            }
            false
        }
    }
}

方法2：在Activity/Fragment中使用

场景1：点击按钮时收起键盘

// 在Activity的onCreate中
val editText = findViewById<EditText>(R.id.et_input)
val button = findViewById<Button>(R.id.btn_confirm)

// 按钮点击事件
button.setOnClickListener {
    // 收起软键盘
    KeyboardUtils.hideSoftKeyboard(editText)
    // 执行你的按钮逻辑
    // ...
}

场景2：点击空白区域收起键盘

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    val editText = findViewById<EditText>(R.id.et_input)
    val rootView = findViewById<View>(android.R.id.content) // 获取Activity根布局

    // 设置点击空白区域收起键盘
    KeyboardUtils.setupTouchOutsideToHideKeyboard(rootView, editText)
}

场景3：更优雅的空白区域监听（处理子View）

如果布局中有多个可点击View，上面的方法可能失效，可使用以下方式：

override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
    if (ev.action == MotionEvent.ACTION_DOWN) {
        val v = currentFocus
        if (v is EditText) {
            val outRect = Rect()
            v.getGlobalVisibleRect(outRect)
            if (!outRect.contains(ev.rawX.toInt(), ev.rawY.toInt())) {
                // 点击输入框外部，收起键盘
                KeyboardUtils.hideSoftKeyboard(v)
                // 可选：清除输入框焦点
                v.clearFocus()
            }
        }
    }
    return super.dispatchTouchEvent(ev)
}

关键说明

前置条件：确保你的Activity/Fragment中能正确获取到EditText实例
核心API：InputMethodManager.hideSoftInputFromWindow() 是Android系统提供的隐藏软键盘的核心方法
焦点处理：如果需要同时清除输入框的焦点，可调用 editText.clearFocus()

总结

通用方案：使用封装的KeyboardUtils工具类，可在任意位置调用hideSoftKeyboard()收起键盘
空白区域监听：重写dispatchTouchEvent是最稳定的监听空白区域点击的方式
按钮点击：直接在按钮的点击事件中调用工具类方法即可快速收起键盘

这种实现方式符合Android开发最佳实践，兼容性好，适用于绝大多数场景（包括Activity、Fragment、Dialog等）。

我的APP最终选择方法3，将代码放到需要代码页就可直接使用

kotlin字符串截取

Wed, 14 Jan 2026 23:13:45 +0800

Kotlin提供了多种灵活的字符串截取方式，既兼容Java风格的substring方法，也有更符合Kotlin简洁风格的便捷方法。下面按使用场景分类讲解：

一、基础截取：substring 方法

这是最通用的截取方式，Kotlin的substring兼容Java的用法，且索引从0开始。

1. 从指定索引截取到末尾

语法：str.substring(startIndex: Int)

fun main() {
    val str = "Hello Kotlin"
    // 从索引6开始截取（包含6），直到末尾
    val result = str.substring(6)
    println(result) // 输出：Kotlin
}

2. 截取指定索引范围（左闭右开）

语法：str.substring(startIndex: Int, endIndex: Int)

startIndex：起始索引（包含）
endIndex：结束索引（不包含）

fun main() {
    val str = "Hello Kotlin"
    // 截取索引0到5的字符（包含0，不包含5）
    val result = str.substring(0, 5)
    println(result) // 输出：Hello
}

注意：如果索引超出字符串长度，会抛出StringIndexOutOfBoundsException，建议使用前判断索引合法性：

fun safeSubstring(str: String, start: Int, end: Int): String {
    val safeStart = maxOf(0, start)
    val safeEnd = minOf(str.length, end)
    return if (safeStart < safeEnd) str.substring(safeStart, safeEnd) else ""
}

二、便捷截取：take/drop 系列（推荐）

Kotlin提供了更简洁、更安全的截取方法，无需担心索引越界：

方法	功能描述	示例（str = "Hello Kotlin"）
take(n: Int)	截取前n个字符	str.take(5) → "Hello"
takeLast(n: Int)	截取最后n个字符	str.takeLast(6) → "Kotlin"
drop(n: Int)	丢弃前n个字符，返回剩余部分	str.drop(6) → "Kotlin"
dropLast(n: Int)	丢弃最后n个字符，返回剩余部分	str.dropLast(6) → "Hello "

示例代码：

fun main() {
    val str = "Hello Kotlin"
    
    val takeResult = str.take(5) // 前5个字符
    val takeLastResult = str.takeLast(6) // 最后6个字符
    val dropResult = str.drop(6) // 丢弃前6个
    val dropLastResult = str.dropLast(6) // 丢弃最后6个
    
    println(takeResult) // Hello
    println(takeLastResult) // Kotlin
    println(dropResult) // Kotlin
    println(dropLastResult) // Hello 
}

三、按分隔符截取：substringBefore/After 系列

适合按特定字符/字符串分割截取，比如处理路径、URL、拼接字符串等场景：

方法	功能描述	示例（str = "user:123456:admin"）
substringBefore(delimiter)	截取第一个分隔符之前的部分	str.substringBefore(":") → "user"
substringAfter(delimiter)	截取第一个分隔符之后的部分	str.substringAfter(":") → "123456:admin"
substringBeforeLast(delimiter)	截取最后一个分隔符之前的部分	str.substringBeforeLast(":") → "user:123456"
substringAfterLast(delimiter)	截取最后一个分隔符之后的部分	str.substringAfterLast(":") → "admin"

示例代码：

fun main() {
    val str = "user:123456:admin"
    
    val beforeFirst = str.substringBefore(":") // 第一个:之前
    val afterLast = str.substringAfterLast(":") // 最后一个:之后
    
    println(beforeFirst) // user
    println(afterLast) // admin
}

总结

基础截取：substring 适合精确控制索引范围，但需手动处理索引越界问题；
便捷截取：take/drop 系列更简洁安全，优先推荐日常使用；
分隔符截取：substringBefore/After 系列专为按分隔符截取设计，场景适配性更强。

所有截取方法返回的都是新字符串（Kotlin字符串不可变），原字符串不会被修改。

kotlin下拉刷新在fragment中使用

Sun, 04 Jan 2026 11:12:37 +0800

在 Kotlin 的 Fragment 中实现下拉刷新功能，Android 官方推荐使用 SwipeRefreshLayout 组件来完成，它能完美适配 Fragment 场景，下面我将详细讲解完整的实现步骤和代码示例。

一、核心组件说明

实现下拉刷新的核心组件是 androidx.swiperefreshlayout.widget.SwipeRefreshLayout（属于 AndroidX 库，需确保项目已引入 AndroidX 依赖），它通过包裹可滚动视图（如 RecyclerView、ScrollView）来提供下拉刷新能力，且对 Fragment 的生命周期兼容性极佳。

二、步骤 1：编写 Fragment 布局文件

布局中需以 SwipeRefreshLayout 作为根布局（或外层布局），它只能包含一个直接子视图（通常是 RecyclerView，用于展示刷新的数据列表），示例布局如下（fragment_refresh.xml）：

<?xml version="1.0" encoding="utf-8"?>
<!-- 下拉刷新核心布局：SwipeRefreshLayout -->
<androidx.swiperefreshlayout.widget.SwipeRefreshLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/swipe_refresh_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <!-- 可滚动子视图：RecyclerView（唯一直接子视图） -->
    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recycler_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:padding="8dp"/>

</androidx.swiperefreshlayout.widget.SwipeRefreshLayout>

三、步骤 2：Fragment 代码实现（Kotlin）

使用 ViewBinding 简化视图操作，核心步骤包括：初始化控件、设置刷新监听、异步处理刷新逻辑、停止刷新动画，完整代码如下：

1. 基础配置（启用 ViewBinding，可选但推荐）

若未启用 ViewBinding，需在模块 build.gradle（Module 级别）中添加配置：

android {
    // 其他配置...
    buildFeatures {
        viewBinding true // 启用ViewBinding
    }
}

2. Fragment 完整代码

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import com.xxx.databinding.FragmentRefreshBinding // 替换为你的包名

// 下拉刷新Fragment
class RefreshFragment : Fragment() {
    // ViewBinding实例
    private var _binding: FragmentRefreshBinding? = null
    private val binding get() = _binding!!

    // RecyclerView适配器（简单字符串适配器，可自定义）
    private lateinit var mAdapter: SimpleStringAdapter
    // 模拟数据列表
    private val dataList = mutableListOf<String>()

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        // 初始化ViewBinding
        _binding = FragmentRefreshBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // 1. 初始化RecyclerView
        initRecyclerView()
        // 2. 初始化下拉刷新控件
        initSwipeRefreshLayout()
        // 3. 初始化模拟数据
        initData()
    }

    /**
     * 初始化RecyclerView
     */
    private fun initRecyclerView() {
        // 初始化适配器
        mAdapter = SimpleStringAdapter(dataList)
        // 设置布局管理器
        binding.recyclerView.layoutManager = LinearLayoutManager(requireContext())
        // 设置适配器
        binding.recyclerView.adapter = mAdapter
    }

    /**
     * 初始化下拉刷新控件
     */
    private fun initSwipeRefreshLayout() {
        // 可选：设置刷新圈颜色（支持多个颜色，循环显示）
        binding.swipeRefreshLayout.setColorSchemeResources(
            android.R.color.holo_blue_light,
            android.R.color.holo_red_light,
            android.R.color.holo_green_light
        )
        // 可选：设置刷新圈大小（DEFAULT / LARGE）
        binding.swipeRefreshLayout.setSize(SwipeRefreshLayout.LARGE)

        // 3. 设置下拉刷新监听（核心）
        binding.swipeRefreshLayout.setOnRefreshListener {
            // 触发下拉刷新时，执行刷新逻辑
            performRefresh()
        }
    }

    /**
     * 执行刷新逻辑（核心：异步处理，避免阻塞主线程）
     */
    private fun performRefresh() {
        // 使用协程异步处理（Kotlin推荐，也可使用Thread+Handler）
        CoroutineScope(Dispatchers.IO).launch {
            // 模拟耗时操作：如网络请求、数据库查询（延迟2秒模拟耗时）
            delay(2000)
            // 刷新数据（模拟新增数据）
            val newData = "新增数据${System.currentTimeMillis() / 1000}"
            dataList.add(0, newData) // 插入到列表头部

            // 切换到主线程更新UI（RecyclerView适配器刷新）
            withContext(Dispatchers.Main) {
                mAdapter.notifyItemInserted(0) // 局部刷新
                binding.recyclerView.scrollToPosition(0) // 滚动到顶部

                // 4. 停止刷新动画（必须调用，否则刷新圈会一直转动）
                binding.swipeRefreshLayout.isRefreshing = false
            }
        }
    }

    /**
     * 初始化模拟数据
     */
    private fun initData() {
        for (i in 1..20) {
            dataList.add("原始数据$i")
        }
        mAdapter.notifyDataSetChanged()
    }

    /**
     * 销毁视图时，释放ViewBinding，避免内存泄漏
     */
    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }

    /**
     * 简单的RecyclerView字符串适配器（自定义适配器可替换）
     */
    inner class SimpleStringAdapter(private val data: List<String>) :
        androidx.recyclerview.widget.RecyclerView.Adapter<SimpleStringAdapter.ViewHolder>() {

        inner class ViewHolder(itemView: View) :
            androidx.recyclerview.widget.RecyclerView.ViewHolder(itemView) {
            val tvContent: android.widget.TextView = itemView as android.widget.TextView
        }

        override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
            // 创建TextView作为列表项
            val textView = android.widget.TextView(requireContext())
            textView.layoutParams = androidx.recyclerview.widget.RecyclerView.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.WRAP_CONTENT
            )
            textView.textSize = 16f
            textView.setPadding(0, 16, 0, 16)
            return ViewHolder(textView)
        }

        override fun onBindViewHolder(holder: ViewHolder, position: Int) {
            holder.tvContent.text = data[position]
        }

        override fun getItemCount(): Int = data.size
    }
}

四、关键注意事项

SwipeRefreshLayout 的子视图限制：它只能有一个直接子视图（如 RecyclerView、ScrollView），若需多个视图，需先使用 LinearLayout/RelativeLayout 等包裹后再作为其子视图。
必须停止刷新动画：刷新逻辑完成后，务必调用 swipeRefreshLayout.isRefreshing = false，否则刷新圈会持续转动，影响用户体验。
刷新逻辑异步化：耗时操作（网络请求、数据库查询等）必须放在子线程 / 协程中执行，避免阻塞主线程导致 ANR，上述示例使用 Kotlin 协程（Dispatchers.IO）实现异步，更简洁高效。
ViewBinding 内存泄漏防护：在 onDestroyView 中将 _binding 置为 null，避免 Fragment 视图销毁后仍持有引用导致内存泄漏。
样式自定义：可通过 setColorSchemeResources（设置刷新圈颜色）、setSize（设置刷新圈大小）、setProgressBackgroundColorSchemeResource（设置刷新圈背景色）自定义下拉刷新样式。

五、运行效果

Fragment 加载后，显示原始数据列表；
下拉列表时，会触发刷新圈动画；
等待 2 秒（模拟耗时操作）后，列表头部插入新数据并自动滚动到顶部；
刷新圈自动停止动画，完成下拉刷新流程。

Kotlin 本地化存储 3 种常用方案

Mon, 29 Dec 2025 09:29:41 +0800

适配 Android 开发场景，提供可直接复用的 Kotlin 实现，兼顾简洁性和实用性，优先覆盖高频使用场景。

一、轻量键值对存储（SharedPreferences）

最常用的本地存储方案，适合存少量简单数据（如用户配置、登录状态），Kotlin 可通过扩展函数简化调用，无需重复写模板代码。

1. 核心工具类（可直接复用）

import android.content.Contextimport android.content.SharedPreferences/**
 * SharedPreferences 本地化存储工具类
 */object SpUtil {
    // 存储文件名
    private const val SP_NAME = "AppLocalStorage"
    private lateinit var sp: SharedPreferences    // 初始化（建议在Application中调用）
    fun init(context: Context) {
        sp = context.getSharedPreferences(SP_NAME, Context.MODE_PRIVATE)
    }

    // 存值 通用方法
    fun put(key: String, value: Any) {
        val editor = sp.edit()
        when (value) {
            is String -> editor.putString(key, value)
            is Int -> editor.putInt(key, value)
            is Boolean -> editor.putBoolean(key, value)
            is Float -> editor.putFloat(key, value)
            is Long -> editor.putLong(key, value)
            else -> throw IllegalArgumentException("不支持该数据类型存储")
        }
        editor.apply() // 异步提交（推荐），同步用 commit()
    }

    // 取值 带默认值，避免空指针
    fun getString(key: String, defValue: String = "") = sp.getString(key, defValue) ?: defValue    fun getInt(key: String, defValue: Int = 0) = sp.getInt(key, defValue)
    fun getBoolean(key: String, defValue: Boolean = false) = sp.getBoolean(key, defValue)
    fun getFloat(key: String, defValue: Float = 0f) = sp.getFloat(key, defValue)
    fun getLong(key: String, defValue: Long = 0L) = sp.getLong(key, defValue)

    // 删除单个key
    fun remove(key: String) = sp.edit().remove(key).apply()
    // 清空所有数据
    fun clear() = sp.edit().clear().apply()}

2. 使用步骤

在 Application 中初始化（全局只执行一次）

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        SpUtil.init(this)
    }}

项目中直接调用（简洁无冗余）

// 存值SpUtil.put("user_name", "张三")SpUtil.put("is_login", true)SpUtil.put("user_age", 28)// 取值val userName = SpUtil.getString("user_name")val isLogin = SpUtil.getBoolean("is_login")val userAge = SpUtil.getInt("user_age")

二、本地文件存储（File）

适合存大量文本数据（如日志文件、JSON 字符串、大段文本），Kotlin 提供了简洁的文件读写扩展函数，无需手动处理流关闭。

1. 文本文件读写（核心代码）

import android.content.Contextimport java.io.File/**
 * 本地文件存储工具类
 */object FileUtil {
    // 存储路径：应用私有目录（无需权限），外部存储需申请读写权限
    private fun getFile(context: Context, fileName: String): File {
        return File(context.filesDir, fileName)
    }

    // 写入文本
    fun writeText(context: Context, fileName: String, content: String) {
        getFile(context, fileName).writeText(content, Charsets.UTF_8)
    }

    // 读取文本
    fun readText(context: Context, fileName: String): String {
        val file = getFile(context, fileName)
        return if (file.exists()) file.readText(Charsets.UTF_8) else ""
    }

    // 追加文本（如日志追加）
    fun appendText(context: Context, fileName: String, content: String) {
        getFile(context, fileName).appendText(content + "\n", Charsets.UTF_8)
    }}

2. 使用示例

// 写入文本FileUtil.writeText(this, "user_info.txt", "{\"name\":\"张三\",\"age\":28}")// 读取文本val userInfo = FileUtil.readText(this, "user_info.txt")// 追加日志FileUtil.appendText(this, "app_log.txt", "2025-12-29 10:00: 应用启动成功")

三、数据库存储（Room）

适合存结构化、大量数据（如本地列表数据、用户明细），Google 官方推荐，基于 SQLite 封装，Kotlin 支持协程、LiveData，无需手动写 SQL 原生语句。

1. 第一步：添加依赖（build.gradle (Module)）

dependencies {
    // Room 核心库
    implementation "androidx.room:room-runtime:2.5.0"
    // Kotlin 注解处理器
    kapt "androidx.room:room-compiler:2.5.0"
    // 协程支持（可选，推荐）
    implementation "androidx.room:room-ktx:2.5.0"}

2. 第二步：3 个核心组件实现（实体 + Dao + 数据库）

（1）实体类（对应数据库表）

import androidx.room.Entityimport androidx.room.PrimaryKey// 出差记录实体（对应表名：business_trip）@Entity(tableName = "business_trip")data class BusinessTripEntity(
    @PrimaryKey(autoGenerate = true) val id: Int = 0, // 自增主键
    val tripNo: String, // 出差单号
    val tripPerson: String, // 出差人
    val startDate: String, // 出差开始时间
    val endDate: String, // 出差结束时间
    val destination: String // 出差目的地)

（2） Dao 接口（数据操作接口，无需实现）

import androidx.room.Daoimport androidx.room.Deleteimport androidx.room.Insertimport androidx.room.Queryimport kotlinx.coroutines.flow.Flow@Daointerface BusinessTripDao {
    // 插入数据（可批量）
    @Insert
    suspend fun insertTrip(vararg trip: BusinessTripEntity)

    // 删除数据
    @Delete
    suspend fun deleteTrip(trip: BusinessTripEntity)

    // 查询所有出差记录（返回Flow，数据变化自动回调）
    @Query("SELECT * FROM business_trip")
    fun getAllTrips(): Flow<List<BusinessTripEntity>>

    // 按出差人查询
    @Query("SELECT * FROM business_trip WHERE tripPerson = :person")
    suspend fun getTripByPerson(person: String): List<BusinessTripEntity>}

（3）数据库单例类（全局唯一）

import androidx.room.Databaseimport androidx.room.Roomimport androidx.room.RoomDatabaseimport android.content.Context// 数据库版本号，升级时需修改@Database(entities = [BusinessTripEntity::class], version = 1, exportSchema = false)abstract class AppDatabase : RoomDatabase() {
    // 暴露Dao接口
    abstract fun businessTripDao(): BusinessTripDao    // 单例模式
    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null

        fun getInstance(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_local_db" // 数据库文件名
                ).build()
                INSTANCE = instance
                instance            }
        }
    }}

3. 使用示例（协程中调用，避免主线程阻塞）

import kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.GlobalScopeimport kotlinx.coroutines.launchimport kotlinx.coroutines.flow.collect// 1. 插入出差记录GlobalScope.launch(Dispatchers.IO) {
    val trip = BusinessTripEntity(
        tripNo = "TRIP20251229001",
        tripPerson = "张三",
        startDate = "2025-12-29",
        endDate = "2025-01-05",
        destination = "上海"
    )
    AppDatabase.getInstance(this@MainActivity).businessTripDao().insertTrip(trip)}// 2. 查询所有记录并监听变化GlobalScope.launch(Dispatchers.Main) {
    AppDatabase.getInstance(this@MainActivity).businessTripDao().getAllTrips()
        .collect { tripList ->
            // 数据变化时回调，直接更新UI
            Log.d("Room数据", "出差记录：$tripList")
        }}

四、三种方案选型建议

存简单键值对（配置、状态）→ 用 SharedPreferences（最轻量、开发最快）
存大段文本 / 文件（日志、JSON）→ 用 File 存储（灵活，适合非结构化数据）
存结构化大量数据（列表、明细）→ 用 Room（安全、支持协程，适配复杂业务）

kotlin 获取当前年

Thu, 18 Dec 2025 08:42:44 +0800

在 Kotlin 中获取当前年份有多种方式，以下是最常用的几种实现方案，适配不同场景（如 Java 8+ 新时间 API、传统 Calendar 类）：

方案 1：推荐（Java 8+ 新时间 API，线程安全）

使用 java.time 包下的 Year、LocalDate 等类，是 Kotlin 中获取年份的首选方式（Android API 26+ 原生支持，低版本可通过 desugar 或 ThreeTenABP 兼容）。

import java.time.LocalDate
import java.time.Year
import java.time.ZoneId

fun getCurrentYear(): Int {
    // 方式 1：直接获取当前年份（系统默认时区）
    val year1 = Year.now().value

    // 方式 2：通过 LocalDate 获取（更灵活，可扩展获取月/日）
    val year2 = LocalDate.now().year

    // 方式 3：指定时区（如 UTC、东八区）
    val year3 = LocalDate.now(ZoneId.of("Asia/Shanghai")).year

    return year1 // 返回任意一种即可
}

// 调用示例
fun main() {
    val currentYear = getCurrentYear()
    println("当前年份：$currentYear") // 输出示例：2025
}

方案 2：兼容低版本（传统 Calendar 类）

如果需要兼容 Android 低版本（API < 26）或旧版 Java 环境，可使用 java.util.Calendar：

import java.util.Calendar

fun getCurrentYearCompat(): Int {
    val calendar = Calendar.getInstance()
    return calendar.get(Calendar.YEAR) // 获取当前年份
}

// 调用示例
fun main() {
    val year = getCurrentYearCompat()
    println("当前年份（兼容版）：$year")
}

方案 3：简化写法（一行代码）

如果只需快速获取，可直接简写：

// Java 8+ 简写
val currentYear = LocalDate.now().year

// 兼容版简写
val currentYearCompat = Calendar.getInstance().get(Calendar.YEAR)

关键说明：

时区问题：now() 无参时使用系统默认时区，如需统一时区（如 UTC），建议显式指定 ZoneId（如 ZoneId.of("UTC")）。
Android 兼容：

API 26+：直接使用 java.time 包。
API < 26：添加 ThreeTenABP 依赖（com.jakewharton.threetenabp:threetenabp:1.4.4），然后使用 org.threeten.bp 包下的对应类（如 org.threeten.bp.LocalDate）。

线程安全：java.time 类是不可变且线程安全的，而 Calendar 是线程不安全的，多线程场景优先选前者。

完整示例（Android 兼容版）

// 如需兼容 Android API < 26，先添加 ThreeTenABP 依赖，然后：
import org.threeten.bp.LocalDate
import org.threeten.bp.ZoneId

fun getCurrentYearAndroid(): Int {
    return LocalDate.now(ZoneId.systemDefault()).year
}

以上方案可根据你的运行环境（Java 版本 / Android API 级别）选择，优先使用 java.time 系列 API，代码更简洁、安全。

博易阁