add api

BuildInfo数据库字段对应关系.md

@@ -0,0 +1,307 @@
+# BuildInfo 与数据库字段对应关系
+
+## 数据库表 `phone.build` 字段映射
+
+### ✅ 已完全实现的字段
+
+| 数据库字段 | BuildInfo 属性 | Android API | 说明 |
+|-----------|---------------|-------------|------|
+| brand | `brand` | `Build.BRAND` | 品牌 |
+| model | `model` | `Build.MODEL` | 机型 |
+| product | `product` | `Build.PRODUCT` | 产品名称 (如 x1seea) |
+| sdkInt | `versionSdkInt` | `Build.VERSION.SDK_INT` | SDK 版本 |
+| androidVersion | `versionRelease` | `Build.VERSION.RELEASE` | Android 版本 |
+| buildId | `id` | `Build.ID` | 构建 ID (如 AP3A.240905.015.A2) |
+| bootloader | `bootloaderVersion` | `Build.BOOTLOADER` | Bootloader 版本 |
+| display | `display` | `Build.DISPLAY` | 显示 ID |
+| buildUser | `user` | `Build.USER` | 构建用户 |
+| incremental | `incremental` | `Build.VERSION.INCREMENTAL` | 增量版本 |
+| buildHost | `host` | `Build.HOST` | 构建主机 |
+| buildFingerprint | `fingerprint` | `Build.FINGERPRINT` | 构建指纹 |
+| kernelVersion | `kernelVersion` | `System.getProperty("os.version")` | 内核版本 |
+| securityPatch | `securityPatch` | `Build.VERSION.SECURITY_PATCH` | 安全补丁日期 |
+| releaseDate | `buildDate` | `Build.TIME` | 构建时间 |
+
+### ✅ 新增的字段（三星设备特定）
+
+| 数据库字段 | BuildInfo 属性 | 系统属性 | 说明 |
+|-----------|---------------|---------|------|
+| rilProductCode | `rilProductCode` | `ro.ril.product_code` | RIL 产品代码 |
+| rilOfficialCscver | `rilOfficialCscver` | `ro.ril.official_cscver` | RIL 官方 CSC 版本 |
+| cscSalesCode | `cscSalesCode` | `ro.csc.sales_code` | CSC 销售代码 |
+| countryISO | `countryISO` | `ro.product.locale.region` | 国家/地区 ISO 代码 |
+
+### 📝 需要在应用层处理的字段
+
+| 数据库字段 | 说明 | 建议获取方式 |
+|-----------|------|-------------|
+| buildIdGD | 人工生成的构建 ID | 应用层生成 |
+| incrementalGD | 人工生成的增量版本 | 应用层生成 |
+| isManual | 是否人工录入 | 应用层标记 |
+| sourceId | 数据源 ID | 应用层管理 |
+| sourceTable | 数据源表 | 应用层管理 |
+| updatedOn | 更新时间 | 数据库自动生成 |
+| dataStatus | 数据状态 (1为准确可用) | 应用层管理 |
+
+---
+
+## 数据库表 `phone.hardware_new` 字段映射
+
+### ✅ 已完全实现的字段
+
+| 数据库字段 | BuildInfo/其他模块 属性 | Android API | 说明 |
+|-----------|----------------------|-------------|------|
+| brand | `brand` | `Build.BRAND` | 品牌 |
+| model | `model` | `Build.MODEL` | 设备型号 |
+| device | `device` | `Build.DEVICE` | 设备代号 |
+| board | `board` | `Build.BOARD` | 主板名称 |
+| manufacturer | `manufacturer` | `Build.MANUFACTURER` | 制造商 |
+| hardware | `hardware` | `Build.HARDWARE` | 硬件标识 |
+| formFactor | `formFactor` | 复合判断 | 设备类型 (Phone/Tablet) |
+| linuxArchitecture | `kernelArchitecture` | `System.getProperty("os.arch")` | Linux 架构 |
+
+### ⚠️ 部分实现或需要其他模块的字段
+
+| 数据库字段 | 对应模块 | 说明 |
+|-----------|---------|------|
+| marketingName | ❌ 未实现 | 需要从设备数据库或 API 获取 |
+| shortName | ❌ 未实现 | 需要从 marketingName 处理生成 |
+| systemonChip | ⚠️ CpuInfo | 需要从 CPU 信息推导 SoC 名称 |
+| screenSize | ⚠️ DisplayInfo | 屏幕尺寸（英寸） |
+| screenSizecm | ⚠️ DisplayInfo | 屏幕尺寸（平方厘米） |
+| maxWidthPixels | ⚠️ DisplayInfo | 最大宽度像素 |
+| maxHeightPixels | ⚠️ DisplayInfo | 最大高度像素 |
+| dpi | ⚠️ DisplayInfo | 物理 DPI |
+| maxRefreshRate | ⚠️ DisplayInfo | 最大刷新率 |
+| ramType | ⚠️ MemInfo | RAM 类型 (LPDDR5 等) |
+| totalMemoryGB | ⚠️ DeviceInfo/MemInfo | 总内存 |
+| totalStorageGB | ⚠️ StorageInfo | 总存储空间 |
+| supportEsim | ⚠️ NetworkInfo | 是否支持 eSIM |
+| simSlotCount | ⚠️ NetworkInfo | SIM 卡槽数量 |
+| batteryDesignCapacity | ⚠️ BatteryInfo | 电池设计容量 |
+| batteryWirelessSupported | ⚠️ BatteryInfo | 是否支持无线充电 |
+| cellularGen | ⚠️ NetworkInfo | 最大网络类型 (3G/4G/5G) |
+| maxWifiVersion | ⚠️ NetworkInfo | 最大 Wi-Fi 版本 |
+| bluetoothVersion | ⚠️ BluetoothInfo | 蓝牙版本 |
+| hasNFC | ⚠️ 未实现 | 是否支持 NFC |
+
+### 📝 需要外部数据或人工处理的字段
+
+| 数据库字段 | 说明 | 建议获取方式 |
+|-----------|------|-------------|
+| boardGD | 人工生成的主板名称 | 应用层生成 |
+| hardwareGD | 人工生成的硬件标识 | 应用层生成 |
+| isFold | 是否折叠机 | 需要外部数据库或规则判断 |
+| releasedDate | 产品发布时间 | 需要外部数据库 |
+| weight | 设备重量 | 需要外部数据库 |
+| releasedAndroidVersion | 发布时 Android 版本 | 需要外部数据库 |
+| supportAndroidMaxVersion | 最大支持 Android 版本 | 需要外部数据库 |
+| price | 价格（美元） | 需要外部数据库 |
+| sourceId | 数据源 ID | 应用层管理 |
+| updatedOn | 更新时间 | 数据库自动生成 |
+
+---
+
+## 📋 BuildInfo.kt 已实现的完整字段列表
+
+### 基本构建信息
+- ✅ `fingerprint` - 构建指纹
+- ✅ `brand` - 品牌
+- ✅ `model` - 机型
+- ✅ `product` - 产品名称
+- ✅ `device` - 设备代号
+- ✅ `board` - 主板名称
+- ✅ `manufacturer` - 制造商
+- ✅ `hardware` - 硬件标识
+- ✅ `tags` - 构建标签
+- ✅ `type` - 构建类型
+- ✅ `buildDate` - 构建日期
+- ✅ `host` - 构建主机
+- ✅ `user` - 构建用户
+- ✅ `id` - 构建 ID
+- ✅ `display` - 显示 ID
+
+### Android 版本信息
+- ✅ `versionRelease` - Android 版本号
+- ✅ `versionCodename` - 版本代号
+- ✅ `versionSdkInt` - SDK 版本
+- ✅ `versionPreviewSdkInt` - 预览版 SDK
+- ✅ `securityPatch` - 安全补丁级别
+- ✅ `baseOs` - 基础操作系统
+- ✅ `incremental` - 增量版本
+- ✅ `releaseOrCodename` - 版本号或代号
+- ✅ `mediaPerformanceClass` - 媒体性能等级
+- ✅ `releaseOrPreviewDisplay` - 版本显示字符串
+
+### RIL 和 CSC 信息（三星设备）
+- ✅ `rilProductCode` - RIL 产品代码
+- ✅ `rilOfficialCscver` - RIL 官方 CSC 版本
+- ✅ `cscSalesCode` - CSC 销售代码
+- ✅ `countryISO` - 国家/地区 ISO 代码
+
+### 设备类型
+- ✅ `formFactor` - 设备类型 (Phone/Tablet)
+- ✅ `isTablet` - 是否为平板
+- ✅ `isPhone` - 是否为手机
+
+### JVM 信息
+- ✅ `jvmName` - JVM 名称
+- ✅ `jvmVendor` - JVM 供应商
+- ✅ `jvmVersion` - JVM 版本
+- ✅ `jvmClassVersion` - Java 类版本
+- ✅ `jvmSpecificationName` - Java 规范名称
+- ✅ `jvmSpecificationVendor` - Java 规范供应商
+- ✅ `jvmSpecificationVersion` - Java 规范版本
+
+### 安全与内核信息
+- ✅ `vendorSecurityPatchLevel` - 厂商安全补丁
+- ✅ `kernelVersion` - 内核版本号
+- ✅ `kernelCompleteVersion` - 完整内核版本
+- ✅ `kernelArchitecture` - 内核架构
+- ✅ `kernelName` - 内核名称
+- ✅ `kernelCommandLine` - 内核命令行
+- ✅ `bootloaderVersion` - Bootloader 版本
+- ✅ `radioVersion` - 基带版本
+- ✅ `procCpuInfo` - CPU 信息
+- ✅ `procMemInfo` - 内存信息
+
+### 分区信息
+- ✅ `fingerprintedPartitions` - 指纹分区列表
+
+### Treble 和系统更新
+- ✅ `isTrebleEnabled` - Treble 支持
+- ✅ `trebleVersion` - Treble 版本
+- ✅ `isSeamlessUpdateSupported` - 无缝更新支持
+- ✅ `currentSlot` - 当前活动插槽
+- ✅ `isVirtualABEnabled` - 虚拟 A/B 支持
+
+### Root 和安全
+- ✅ `isRooted` - Root 状态
+- ✅ `seLinuxStatus` - SELinux 状态
+- ✅ `isDmVerityEnabled` - dm-verity 状态
+
+### Google Play 服务
+- ✅ `googlePlayServicesVersion` - Play 服务版本
+- ✅ `googlePlayServicesVersionCode` - Play 服务版本代码
+- ✅ `googlePlayStoreVersion` - Play 商店版本
+- ✅ `googleServicesFrameworkVersion` - GSF 版本
+
+### 系统工具
+- ✅ `toyboxVersion` - Toybox 版本
+- ✅ `toolboxVersion` - Toolbox 版本
+- ✅ `busyboxVersion` - BusyBox 版本
+
+### SSL/TLS
+- ✅ `openSslVersion` - OpenSSL 版本
+- ✅ `boringSslVersion` - BoringSSL 版本
+- ✅ `tlsVersion` - TLS 版本
+
+### 语言和时区
+- ✅ `systemLanguage` - 系统语言
+- ✅ `languageCode` - 语言代码
+- ✅ `country` - 国家/地区
+- ✅ `countryCode` - 国家/地区代码
+- ✅ `timeZone` - 系统时区
+- ✅ `timeZoneDisplayName` - 时区显示名称
+- ✅ `timeZoneOffset` - UTC 偏移
+
+### 开发者选项
+- ✅ `isUsbDebuggingEnabled` - USB 调试
+- ✅ `isDevelopmentSettingsEnabled` - 开发者选项
+- ✅ `isUnknownSourcesEnabled` - 未知来源安装
+
+### 设备标识符
+- ✅ `androidId` - Android ID
+- ✅ `serialNumber` - 序列号
+- ✅ `deviceUniqueId` - 设备唯一 ID
+
+---
+
+## 🔍 缺失字段总结
+
+### phone.build 表
+**完全实现**: ✅ 15/15 个核心字段
+**新增三星专用字段**: ✅ 4/4 个
+**需应用层处理**: 7 个（buildIdGD, incrementalGD, isManual 等）
+
+### phone.hardware_new 表
+**完全实现**: ✅ 8/8 个基本字段
+**需其他模块**: ⚠️ 16 个（DisplayInfo, NetworkInfo, BatteryInfo 等）
+**需外部数据**: ❌ 10 个（marketingName, releasedDate, price 等）
+
+---
+
+## 📊 使用示例
+
+### 获取 build 表所需数据
+```kotlin
+val buildInfo = AndInfo.instance.build
+
+val buildData = mapOf(
+    "brand" to buildInfo.brand,
+    "model" to buildInfo.model,
+    "product" to buildInfo.product,
+    "sdkInt" to buildInfo.versionSdkInt,
+    "androidVersion" to buildInfo.versionRelease,
+    "buildId" to buildInfo.id,
+    "bootloader" to buildInfo.bootloaderVersion,
+    "display" to buildInfo.display,
+    "buildUser" to buildInfo.user,
+    "incremental" to buildInfo.incremental,
+    "buildHost" to buildInfo.host,
+    "buildFingerprint" to buildInfo.fingerprint,
+    "rilProductCode" to buildInfo.rilProductCode,
+    "rilOfficialCscver" to buildInfo.rilOfficialCscver,
+    "cscSalesCode" to buildInfo.cscSalesCode,
+    "countryISO" to buildInfo.countryISO,
+    "kernelVersion" to buildInfo.kernelVersion,
+    "securityPatch" to buildInfo.securityPatch,
+    "releaseDate" to buildInfo.buildDate
+)
+```
+
+### 获取 hardware_new 表基本字段
+```kotlin
+val buildInfo = AndInfo.instance.build
+
+val hardwareData = mapOf(
+    "brand" to buildInfo.brand,
+    "model" to buildInfo.model,
+    "formFactor" to buildInfo.formFactor,
+    "device" to buildInfo.device,
+    "board" to buildInfo.board,
+    "manufacturer" to buildInfo.manufacturer,
+    "hardware" to buildInfo.hardware,
+    "linuxArchitecture" to buildInfo.kernelArchitecture
+)
+```
+
+---
+
+## ✅ 总结
+
+### BuildInfo.kt 已实现
+- ✅ **phone.build 表**: 15/15 核心字段 + 4 个三星专用字段
+- ✅ **phone.hardware_new 表**: 8/8 基本字段
+- ✅ **额外功能**: 60+ 个系统信息属性
+
+### 需要其他模块支持
+- DisplayInfo: 屏幕相关字段
+- NetworkInfo: 网络和 SIM 卡相关字段
+- BatteryInfo: 电池相关字段
+- StorageInfo: 存储相关字段
+- BluetoothInfo: 蓝牙相关字段
+- MemInfo: 内存类型相关字段
+
+### 需要外部数据源
+- marketingName（市场名称）
+- releasedDate（发布日期）
+- price（价格）
+- weight（重量）
+- 等规格参数需要从产品数据库获取
+
+---
+
+**最后更新**: 2025年12月24日  
+**BuildInfo.kt 版本**: 完整版
+

InputInfo硬件特性检测使用示例.md

@@ -0,0 +1,464 @@
+# InputInfo 硬件特性检测使用示例
+
+## 概述
+InputInfo 类现在提供了完整的硬件特性检测功能，包括输入设备信息和各种硬件特性支持（USB、指纹、NFC、GPS等）。
+
+## 新增功能
+
+### 硬件特性检测方法（12个）
+
+1. **USB 相关**
+   - `hasUsbHostSupport()` - USB Host 模式支持
+   - `hasUsbAccessorySupport()` - USB 配件模式支持
+
+2. **生物识别**
+   - `hasFingerprintSensor()` - 指纹识别器
+
+3. **传感器**
+   - `hasInfraredSensor()` - 红外线传感器（遥控器功能）
+   - `hasUwbSupport()` - UWB 超宽带支持
+
+4. **NFC 相关**
+   - `hasNfcSupport()` - NFC 近场通信支持
+   - `hasNfcHostCardEmulation()` - NFC 主机卡模拟
+   - `hasNfcHostCardEmulationOffHost()` - NFC 离线主机卡模拟
+   - `hasSecureNfcSupport()` - 安全 NFC 支持
+
+5. **定位相关**
+   - `hasGpsSupport()` - GPS 定位支持
+   - `hasNetworkLocationSupport()` - 网络定位支持
+   - `hasLocationSupport()` - 任何定位服务支持
+
+6. **综合方法**
+   - `getHardwareFeatures()` - 获取所有硬件特性支持信息
+
+## 使用方法
+
+### 1. 初始化
+```kotlin
+import com.xyzshell.andinfo.AndInfo
+
+// 在 Application 或 Activity 中初始化
+AndInfo.init(applicationContext)
+
+// 获取 InputInfo 实例
+val inputInfo = AndInfo.instance.input
+```
+
+### 2. USB 功能检测
+
+#### USB Host 支持
+```kotlin
+// 检查是否支持 USB Host 模式
+val hasUsbHost = inputInfo.hasUsbHostSupport()
+println("USB Host 支持: ${if (hasUsbHost) "是" else "否"}")
+
+// USB Host 允许 Android 设备连接：
+// - USB 键盘
+// - USB 鼠标
+// - USB 存储设备
+// - USB 游戏手柄
+// - USB 打印机等
+```
+
+#### USB 配件模式
+```kotlin
+// 检查是否支持 USB 配件模式
+val hasUsbAccessory = inputInfo.hasUsbAccessorySupport()
+println("USB 配件模式: ${if (hasUsbAccessory) "是" else "否"}")
+
+// USB 配件模式允许 Android 设备作为配件连接到：
+// - 汽车娱乐系统
+// - 音频设备
+// - 医疗设备等
+```
+
+### 3. 指纹识别检测
+
+```kotlin
+// 检查是否有指纹识别器
+val hasFingerprint = inputInfo.hasFingerprintSensor()
+println("指纹识别器: ${if (hasFingerprint) "有" else "无"}")
+
+// 用于判断设备是否支持指纹解锁、指纹支付等功能
+if (hasFingerprint) {
+    // 可以使用 BiometricPrompt API 进行指纹认证
+    println("设备支持指纹认证功能")
+}
+```
+
+### 4. 红外线传感器检测
+
+```kotlin
+// 检查是否有红外线传感器（IR Blaster）
+val hasInfrared = inputInfo.hasInfraredSensor()
+println("红外线传感器: ${if (hasInfrared) "有" else "无"}")
+
+// 红外线传感器可用于：
+// - 遥控电视
+// - 遥控空调
+// - 遥控机顶盒等
+if (hasInfrared) {
+    println("设备可以作为万能遥控器使用")
+}
+```
+
+### 5. UWB 超宽带支持检测
+
+```kotlin
+// 检查是否支持 UWB（Ultra-Wideband）
+val hasUwb = inputInfo.hasUwbSupport()
+println("UWB 支持: ${if (hasUwb) "是" else "否"}")
+
+// UWB 技术用于：
+// - 精确室内定位（厘米级）
+// - 数字车钥匙
+// - 查找设备（类似 AirTag）
+// - 设备间高速数据传输
+if (hasUwb) {
+    println("设备支持精确定位和数字车钥匙功能")
+}
+```
+
+### 6. NFC 功能检测
+
+#### 基本 NFC 支持
+```kotlin
+// 检查是否支持 NFC
+val hasNfc = inputInfo.hasNfcSupport()
+println("NFC 支持: ${if (hasNfc) "是" else "否"}")
+
+// NFC 用于：
+// - 移动支付（Apple Pay、Google Pay等）
+// - 读取 NFC 标签
+// - 点对点数据传输
+// - 公交卡模拟
+```
+
+#### NFC 主机卡模拟（HCE）
+```kotlin
+// 检查是否支持 NFC HCE
+val hasNfcHce = inputInfo.hasNfcHostCardEmulation()
+println("NFC HCE 支持: ${if (hasNfcHce) "是" else "否"}")
+
+// HCE 允许应用模拟 NFC 卡片，无需物理安全元素
+// 用于：
+// - 虚拟公交卡
+// - 虚拟门禁卡
+// - 虚拟会员卡
+```
+
+#### NFC 离线主机卡模拟
+```kotlin
+// 检查是否支持离线 HCE
+val hasNfcOffHost = inputInfo.hasNfcHostCardEmulationOffHost()
+println("NFC 离线 HCE: ${if (hasNfcOffHost) "是" else "否"}")
+
+// 允许在设备离线时进行 NFC 交易
+```
+
+#### 安全 NFC
+```kotlin
+// 检查是否支持安全 NFC
+val hasSecureNfc = inputInfo.hasSecureNfcSupport()
+println("安全 NFC: ${if (hasSecureNfc) "是" else "否"}")
+
+// 安全 NFC 使用安全元素（Secure Element）
+// 提供更高的安全性，用于：
+// - 金融级支付
+// - 敏感数据交换
+```
+
+### 7. GPS 定位检测
+
+#### GPS 支持
+```kotlin
+// 检查是否支持 GPS
+val hasGps = inputInfo.hasGpsSupport()
+println("GPS 支持: ${if (hasGps) "是" else "否"}")
+
+// GPS 提供卫星定位功能
+// 用于：
+// - 导航
+// - 位置追踪
+// - 地理标记
+```
+
+#### 网络定位
+```kotlin
+// 检查是否支持网络定位
+val hasNetworkLocation = inputInfo.hasNetworkLocationSupport()
+println("网络定位: ${if (hasNetworkLocation) "是" else "否"}")
+
+// 网络定位使用：
+// - Wi-Fi 定位
+// - 基站定位
+// 比 GPS 更省电但精度较低
+```
+
+#### 任何定位服务
+```kotlin
+// 检查是否支持任何定位服务
+val hasLocation = inputInfo.hasLocationSupport()
+println("定位服务: ${if (hasLocation) "是" else "否"}")
+
+// 综合检测设备是否有定位能力
+```
+
+### 8. 获取所有硬件特性
+
+```kotlin
+// 一次性获取所有硬件特性支持信息
+val features = inputInfo.getHardwareFeatures()
+
+println("=== 硬件特性汇总 ===")
+println("USB Host: ${if (features.usbHost) "✓" else "✗"}")
+println("USB 配件: ${if (features.usbAccessory) "✓" else "✗"}")
+println("指纹识别: ${if (features.fingerprint) "✓" else "✗"}")
+println("红外线: ${if (features.infrared) "✓" else "✗"}")
+println("UWB: ${if (features.uwb) "✓" else "✗"}")
+println("NFC: ${if (features.nfc) "✓" else "✗"}")
+println("NFC HCE: ${if (features.nfcHce) "✓" else "✗"}")
+println("NFC 离线: ${if (features.nfcHceOffHost) "✓" else "✗"}")
+println("安全 NFC: ${if (features.secureNfc) "✓" else "✗"}")
+println("GPS: ${if (features.gps) "✓" else "✗"}")
+println("网络定位: ${if (features.networkLocation) "✓" else "✗"}")
+println("定位服务: ${if (features.location) "✓" else "✗"}")
+```
+
+### 9. 输入设备信息（原有功能）
+
+```kotlin
+// 获取所有输入设备
+val devices = inputInfo.getInputDevices()
+println("输入设备数量: ${devices.size}")
+
+devices.forEach { device ->
+    println("--- ${device.name} ---")
+    println("ID: ${device.id}")
+    println("类型: ${when {
+        device.sources and InputDevice.SOURCE_KEYBOARD != 0 -> "键盘"
+        device.sources and InputDevice.SOURCE_MOUSE != 0 -> "鼠标"
+        device.sources and InputDevice.SOURCE_TOUCHSCREEN != 0 -> "触摸屏"
+        device.sources and InputDevice.SOURCE_GAMEPAD != 0 -> "游戏手柄"
+        else -> "其他"
+    }}")
+    println("虚拟设备: ${device.isVirtual}")
+    println("外部设备: ${device.isExternal}")
+    println("有震动: ${device.hasVibrator}")
+    println("有麦克风: ${device.hasMicrophone}")
+    println()
+}
+```
+
+## HardwareFeatures 数据类
+
+```kotlin
+data class HardwareFeatures(
+    val usbHost: Boolean,              // USB Host 支持
+    val usbAccessory: Boolean,         // USB 配件支持
+    val fingerprint: Boolean,          // 指纹识别器
+    val infrared: Boolean,             // 红外线传感器
+    val uwb: Boolean,                  // UWB 支持
+    val nfc: Boolean,                  // NFC 支持
+    val nfcHce: Boolean,               // NFC 主机卡模拟
+    val nfcHceOffHost: Boolean,        // NFC 离线主机卡模拟
+    val secureNfc: Boolean,            // 安全 NFC
+    val gps: Boolean,                  // GPS 支持
+    val networkLocation: Boolean,      // 网络定位支持
+    val location: Boolean              // 任何定位支持
+)
+```
+
+## 典型应用场景
+
+### 1. 功能适配检查
+```kotlin
+fun checkDeviceCapabilities(): DeviceCapabilities {
+    val inputInfo = AndInfo.instance.input
+    
+    return DeviceCapabilities(
+        canUseUsbAccessories = inputInfo.hasUsbHostSupport(),
+        canUseFingerprint = inputInfo.hasFingerprintSensor(),
+        canControlTv = inputInfo.hasInfraredSensor(),
+        canUseNfcPayment = inputInfo.hasNfcSupport(),
+        canUseDigitalKey = inputInfo.hasUwbSupport(),
+        canUseGps = inputInfo.hasGpsSupport()
+    )
+}
+```
+
+### 2. 功能引导
+```kotlin
+fun showFeatureTips() {
+    val inputInfo = AndInfo.instance.input
+    
+    if (inputInfo.hasInfraredSensor()) {
+        showTip("您的设备支持红外遥控功能，可以控制电视、空调等设备")
+    }
+    
+    if (inputInfo.hasUwbSupport()) {
+        showTip("您的设备支持 UWB，可以使用数字车钥匙功能")
+    }
+    
+    if (inputInfo.hasNfcSupport()) {
+        showTip("您的设备支持 NFC，可以使用移动支付和刷卡功能")
+    }
+}
+```
+
+### 3. 支付功能检查
+```kotlin
+fun canUseNfcPayment(): Boolean {
+    val inputInfo = AndInfo.instance.input
+    
+    // 检查基本 NFC 支持
+    if (!inputInfo.hasNfcSupport()) {
+        return false
+    }
+    
+    // 检查 HCE 支持（用于虚拟卡片）
+    val hasHce = inputInfo.hasNfcHostCardEmulation()
+    
+    // 检查安全 NFC（用于金融级支付）
+    val hasSecureNfc = inputInfo.hasSecureNfcSupport()
+    
+    return hasHce || hasSecureNfc
+}
+```
+
+### 4. 定位功能检查
+```kotlin
+fun getBestLocationMethod(): String {
+    val inputInfo = AndInfo.instance.input
+    
+    return when {
+        inputInfo.hasGpsSupport() -> "GPS（高精度）"
+        inputInfo.hasNetworkLocationSupport() -> "网络定位（省电）"
+        inputInfo.hasLocationSupport() -> "基础定位"
+        else -> "不支持定位"
+    }
+}
+```
+
+### 5. 设备档案生成
+```kotlin
+fun generateDeviceProfile(): String {
+    val inputInfo = AndInfo.instance.input
+    val features = inputInfo.getHardwareFeatures()
+    
+    return buildString {
+        appendLine("=== 设备功能档案 ===")
+        appendLine()
+        appendLine("📱 连接性")
+        appendLine("USB Host: ${if (features.usbHost) "✓" else "✗"}")
+        appendLine("USB 配件: ${if (features.usbAccessory) "✓" else "✗"}")
+        appendLine("NFC: ${if (features.nfc) "✓" else "✗"}")
+        appendLine("UWB: ${if (features.uwb) "✓" else "✗"}")
+        appendLine()
+        appendLine("🔐 安全性")
+        appendLine("指纹: ${if (features.fingerprint) "✓" else "✗"}")
+        appendLine("安全 NFC: ${if (features.secureNfc) "✓" else "✗"}")
+        appendLine()
+        appendLine("📍 定位")
+        appendLine("GPS: ${if (features.gps) "✓" else "✗"}")
+        appendLine("网络定位: ${if (features.networkLocation) "✓" else "✗"}")
+        appendLine()
+        appendLine("🔌 特殊功能")
+        appendLine("红外遥控: ${if (features.infrared) "✓" else "✗"}")
+    }
+}
+```
+
+## 示例输出
+
+### 完整硬件特性检测结果
+```
+=== 硬件特性汇总 ===
+USB Host: ✓
+USB 配件: ✓
+指纹识别: ✓
+红外线: ✗
+UWB: ✓
+NFC: ✓
+NFC HCE: ✓
+NFC 离线: ✗
+安全 NFC: ✓
+GPS: ✓
+网络定位: ✓
+定位服务: ✓
+```
+
+### 高端设备示例（如 Samsung Galaxy S24 Ultra）
+```
+USB Host: ✓
+USB 配件: ✓
+指纹识别: ✓（屏下指纹）
+红外线: ✗
+UWB: ✓（数字车钥匙、SmartTag+ 支持）
+NFC: ✓
+NFC HCE: ✓
+安全 NFC: ✓（Samsung Pay）
+GPS: ✓
+```
+
+### 中端设备示例（如 Google Pixel 7a）
+```
+USB Host: ✓
+USB 配件: ✓
+指纹识别: ✓（屏下指纹）
+红外线: ✗
+UWB: ✗
+NFC: ✓
+NFC HCE: ✓
+安全 NFC: ✗
+GPS: ✓
+```
+
+### 预算设备示例
+```
+USB Host: ✓
+USB 配件: ✓
+指纹识别: ✓（侧面指纹）
+红外线: ✗
+UWB: ✗
+NFC: ✗
+NFC HCE: ✗
+安全 NFC: ✗
+GPS: ✓
+```
+
+## 注意事项
+
+1. **权限要求**：
+   - USB 功能不需要特殊权限
+   - 指纹使用需要 `USE_BIOMETRIC` 权限
+   - NFC 使用需要 `NFC` 权限
+   - 定位使用需要 `ACCESS_FINE_LOCATION` 或 `ACCESS_COARSE_LOCATION` 权限
+
+2. **版本兼容性**：
+   - UWB 支持需要 Android 12+
+   - 某些 NFC 功能需要 Android 4.4+
+
+3. **设备差异**：
+   - 不同品牌和型号的设备支持的功能不同
+   - 某些功能可能被厂商禁用
+
+4. **用户设置**：
+   - 即使硬件支持，用户也可能在设置中禁用某些功能
+   - 建议在使用前检查功能是否已启用
+
+## 完成度
+
+✅ **100%** - 所有请求的功能都已实现
+- USB Host 支持检测 ✅
+- USB 配件支持检测 ✅
+- 指纹识别器检测 ✅
+- 红外线传感器检测 ✅
+- UWB 支持检测 ✅
+- NFC 支持检测 ✅
+- 安全 NFC 支持检测 ✅
+- GPS 支持检测 ✅
+- 完整的中文注释 ✅
+- 综合查询方法 ✅
+

myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/BuildInfo.kt

@@ -31,6 +31,55 @@ class BuildInfo(private val context: Context) {
     val fingerprint: String
         get() = Build.FINGERPRINT
 
+    /**
+     * 品牌
+     * 示例: "samsung", "google", "xiaomi"
+     */
+    val brand: String
+        get() = Build.BRAND
+
+    /**
+     * 机型
+     * 示例: "SM-G998B", "Pixel 6 Pro"
+     */
+    val model: String
+        get() = Build.MODEL
+
+    /**
+     * 产品名称
+     * 示例: "x1seea", "redfin"
+     */
+    val product: String
+        get() = Build.PRODUCT
+
+    /**
+     * 设备代号
+     * 示例: "p3s", "redfin"
+     */
+    val device: String
+        get() = Build.DEVICE
+
+    /**
+     * 主板名称
+     * 示例: "s5e9925"
+     */
+    val board: String
+        get() = Build.BOARD
+
+    /**
+     * 制造商
+     * 示例: "samsung", "Google"
+     */
+    val manufacturer: String
+        get() = Build.MANUFACTURER
+
+    /**
+     * 硬件标识
+     * 示例: "qcom", "exynos2200"
+     */
+    val hardware: String
+        get() = Build.HARDWARE
+
     /**
      * 构建标签
      * 通常为 "release-keys" (正式版) 或 "test-keys" (测试版)
@@ -158,6 +207,111 @@ class BuildInfo(private val context: Context) {
     val releaseOrPreviewDisplay: String?
         get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) Build.VERSION.RELEASE_OR_PREVIEW_DISPLAY else null
 
+    // ==================== RIL 和 CSC 信息 ====================
+
+    /**
+     * RIL 产品代码
+     * Radio Interface Layer 产品代码（三星设备）
+     * 示例: "SM-G998BZKDEUB"
+     */
+    val rilProductCode: String?
+        get() = getSystemProperty("ro.ril.product_code")
+            ?: getSystemProperty("ril.product_code")
+
+    /**
+     * RIL 官方 CSC 版本
+     * CSC (Customer Service Code) 官方版本（三星设备）
+     * 示例: "G998BXXU4CWE1"
+     */
+    val rilOfficialCscver: String?
+        get() = getSystemProperty("ro.ril.official_cscver")
+            ?: getSystemProperty("ril.official_cscver")
+
+    /**
+     * CSC 销售代码
+     * 表示设备的销售地区/运营商代码（三星设备）
+     * 示例: "XEU" (欧洲未锁定), "ATT" (AT&T), "TMB" (T-Mobile)
+     */
+    val cscSalesCode: String?
+        get() = getSystemProperty("ro.csc.sales_code")
+            ?: getSystemProperty("ril.sales_code")
+            ?: getSystemProperty("persist.sys.omc_etcpath")?.substringAfterLast("/")
+
+    /**
+     * 国家/地区 ISO 代码
+     * 小写 ISO 标准代码，世界版本为 "zz"
+     * 示例: "us", "cn", "kr", "zz"
+     */
+    val countryISO: String?
+        get() {
+            // 尝试多个来源获取国家代码
+            val country = getSystemProperty("ro.product.locale.region")
+                ?: getSystemProperty("persist.sys.country")
+                ?: getSystemProperty("ro.product.country")
+                ?: Locale.getDefault().country
+
+            return country?.lowercase()?.takeIf { it.isNotEmpty() }
+        }
+
+    // ==================== 设备类型 ====================
+
+    /**
+     * 设备外形因素/类型
+     * 判断设备是手机(Phone)还是平板(Tablet)
+     * @return "Phone", "Tablet" 或 "Unknown"
+     */
+    val formFactor: String
+        get() {
+            // 检查系统属性
+            val deviceType = getSystemProperty("ro.build.characteristics")
+            if (deviceType != null) {
+                return when {
+                    deviceType.contains("tablet", ignoreCase = true) -> "Tablet"
+                    deviceType.contains("phone", ignoreCase = true) -> "Phone"
+                    else -> deviceType
+                }
+            }
+
+            // 通过 PackageManager 特性判断
+            val packageManager = context.packageManager
+            return when {
+                // 检查是否有电话功能（手机的标志）
+                packageManager.hasSystemFeature(PackageManager.FEATURE_TELEPHONY) -> {
+                    // 有电话功能，但还要检查屏幕尺寸
+                    val config = context.resources.configuration
+                    val screenLayout = config.screenLayout and android.content.res.Configuration.SCREENLAYOUT_SIZE_MASK
+                    // 大屏幕且有电话功能可能是平板带电话（如某些三星平板）
+                    if (screenLayout >= android.content.res.Configuration.SCREENLAYOUT_SIZE_XLARGE) {
+                        "Tablet"
+                    } else {
+                        "Phone"
+                    }
+                }
+                // 没有电话功能，通过屏幕尺寸判断
+                else -> {
+                    val config = context.resources.configuration
+                    val screenLayout = config.screenLayout and android.content.res.Configuration.SCREENLAYOUT_SIZE_MASK
+                    when {
+                        screenLayout >= android.content.res.Configuration.SCREENLAYOUT_SIZE_LARGE -> "Tablet"
+                        else -> "Unknown"
+                    }
+                }
+            }
+        }
+
+
+    /**
+     * 是否为平板设备
+     */
+    val isTablet: Boolean
+        get() = formFactor == "Tablet"
+
+    /**
+     * 是否为手机设备
+     */
+    val isPhone: Boolean
+        get() = formFactor == "Phone"
+
     // ==================== JVM 信息 ====================
 
     /**
@@ -684,6 +838,14 @@ class BuildInfo(private val context: Context) {
         // 基本构建信息
         sb.append("=== 系统构建信息 ===\n")
         sb.append("指纹: $fingerprint\n")
+        sb.append("品牌: $brand\n")
+        sb.append("机型: $model\n")
+        sb.append("产品: $product\n")
+        sb.append("设备代号: $device\n")
+        sb.append("主板: $board\n")
+        sb.append("制造商: $manufacturer\n")
+        sb.append("硬件: $hardware\n")
+        sb.append("设备类型: $formFactor\n")
         sb.append("显示ID: $display\n")
         sb.append("构建ID: $id\n")
         sb.append("类型: $type\n")
@@ -692,6 +854,15 @@ class BuildInfo(private val context: Context) {
         sb.append("构建用户: $user\n")
         sb.append("构建主机: $host\n")
 
+        // RIL 和 CSC 信息（主要用于三星设备）
+        if (rilProductCode != null || rilOfficialCscver != null || cscSalesCode != null) {
+            sb.append("\n=== RIL/CSC 信息 ===\n")
+            rilProductCode?.let { sb.append("RIL产品代码: $it\n") }
+            rilOfficialCscver?.let { sb.append("RIL官方CSC版本: $it\n") }
+            cscSalesCode?.let { sb.append("CSC销售代码: $it\n") }
+            countryISO?.let { sb.append("国家/地区ISO: $it\n") }
+        }
+
         // Android 版本信息
         sb.append("\n=== Android 版本 ===\n")
         sb.append("版本号: $versionRelease\n")

myphoneinfo/andinfo/src/main/java/com/xyzshell/andinfo/libs/InputInfo.kt

@@ -1,55 +1,307 @@
 package com.xyzshell.andinfo.libs
 
 import android.content.Context
+import android.content.pm.PackageManager
 import android.hardware.input.InputManager
 import android.os.Build
 import android.view.InputDevice
 import android.view.KeyCharacterMap
 import androidx.annotation.RequiresApi
 
+/**
+ * 输入设备信息工具类
+ * 提供所有输入设备（键盘、鼠标、触摸屏、游戏手柄等）的详细信息
+ */
 class InputInfo(private val context: Context) {
+
+    /**
+     * 输入管理器
+     */
     private val inputManager = context.getSystemService(InputManager::class.java)
 
+    /**
+     * 获取所有输入设备列表
+     * @return 输入设备信息列表
+     */
     fun getInputDevices(): List<InputDeviceInfo> {
         return inputManager.inputDeviceIds.toList().mapNotNull { id ->
             inputManager.getInputDevice(id)?.let { device -> InputDeviceInfo(device) }
         }
     }
 
+    /**
+     * 根据设备ID获取指定的输入设备信息
+     * @param deviceId 设备ID
+     * @return 输入设备信息，如果设备不存在则返回null
+     */
     fun getInputDevice(deviceId: Int): InputDeviceInfo? {
         return inputManager.getInputDevice(deviceId)?.let { device ->
             InputDeviceInfo(device)
         }
     }
 
+    /**
+     * 获取触摸的最大遮挡不透明度
+     * Android 12+ 可用
+     * 用于安全性，防止恶意应用遮挡触摸事件
+     * @return 最大不透明度值 (0.0-1.0)
+     */
     @RequiresApi(Build.VERSION_CODES.S)
     fun getMaximumObscuringOpacityForTouch(): Float {
         return inputManager.maximumObscuringOpacityForTouch
     }
 
+    /**
+     * 检查是否启用了触控笔指针图标
+     * Android 14+ 可用
+     * @return 是否启用触控笔指针图标
+     */
     @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
     fun isStylusPointerIconEnabled(): Boolean {
         return inputManager.isStylusPointerIconEnabled
     }
 
+    // ==================== 硬件特性检测 ====================
+
+    /**
+     * 检查设备是否支持 USB Host 模式
+     * USB Host 模式允许 Android 设备作为主机连接其他 USB 设备
+     * @return 是否支持 USB Host
+     */
+    fun hasUsbHostSupport(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)
+    }
+
+    /**
+     * 检查设备是否支持 USB 配件模式
+     * USB 配件模式允许 Android 设备作为 USB 配件连接到其他设备
+     * @return 是否支持 USB 配件模式
+     */
+    fun hasUsbAccessorySupport(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_USB_ACCESSORY)
+    }
+
+    /**
+     * 检查设备是否有指纹识别器
+     * @return 是否有指纹识别器
+     */
+    fun hasFingerprintSensor(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)
+    }
+
+    /**
+     * 检查设备是否有红外线传感器（IR Blaster）
+     * 红外线传感器可用于遥控电视、空调等设备
+     * @return 是否有红外线传感器
+     */
+    fun hasInfraredSensor(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_CONSUMER_IR)
+    }
+
+    /**
+     * 检查设备是否支持 UWB（Ultra-Wideband 超宽带）
+     * UWB 用于精确定位和设备间通信
+     * Android 12+ 可用
+     * @return 是否支持 UWB
+     */
+    fun hasUwbSupport(): Boolean {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            context.packageManager.hasSystemFeature(PackageManager.FEATURE_UWB)
+        } else {
+            false
+        }
+    }
+
+    /**
+     * 检查设备是否支持 NFC（Near Field Communication 近场通信）
+     * @return 是否支持 NFC
+     */
+    fun hasNfcSupport(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_NFC)
+    }
+
+    /**
+     * 检查设备是否支持 NFC HCE（Host Card Emulation 主机卡模拟）
+     * HCE 允许应用模拟 NFC 卡片
+     * @return 是否支持 NFC HCE
+     */
+    fun hasNfcHostCardEmulation(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_NFC_HOST_CARD_EMULATION)
+    }
+
+    /**
+     * 检查设备是否支持 NFC 离线主机卡模拟
+     * 允许在设备离线时进行 NFC 交易
+     * @return 是否支持离线 HCE
+     */
+    fun hasNfcHostCardEmulationOffHost(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_NFC_HOST_CARD_EMULATION_NFCF)
+    }
+
+    /**
+     * 检查设备是否支持安全 NFC（NFC with Secure Element）
+     * 使用安全元素进行 NFC 交易，更安全
+     * @return 是否支持安全 NFC
+     */
+    fun hasSecureNfcSupport(): Boolean {
+        // 检查是否有安全元素相关的 NFC 功能
+        return context.packageManager.hasSystemFeature("android.hardware.nfc.ese") ||
+               context.packageManager.hasSystemFeature("android.hardware.nfc.uicc")
+    }
+
+    /**
+     * 检查设备是否支持 GPS 定位
+     * @return 是否支持 GPS
+     */
+    fun hasGpsSupport(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS)
+    }
+
+    /**
+     * 检查设备是否支持网络定位
+     * @return 是否支持网络定位
+     */
+    fun hasNetworkLocationSupport(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_LOCATION_NETWORK)
+    }
+
+    /**
+     * 检查设备是否支持任何定位服务
+     * @return 是否支持定位
+     */
+    fun hasLocationSupport(): Boolean {
+        return context.packageManager.hasSystemFeature(PackageManager.FEATURE_LOCATION)
+    }
+
+    /**
+     * 获取所有硬件特性支持信息
+     * @return 硬件特性支持信息数据类
+     */
+    fun getHardwareFeatures(): HardwareFeatures {
+        return HardwareFeatures(
+            usbHost = hasUsbHostSupport(),
+            usbAccessory = hasUsbAccessorySupport(),
+            fingerprint = hasFingerprintSensor(),
+            infrared = hasInfraredSensor(),
+            uwb = hasUwbSupport(),
+            nfc = hasNfcSupport(),
+            nfcHce = hasNfcHostCardEmulation(),
+            nfcHceOffHost = hasNfcHostCardEmulationOffHost(),
+            secureNfc = hasSecureNfcSupport(),
+            gps = hasGpsSupport(),
+            networkLocation = hasNetworkLocationSupport(),
+            location = hasLocationSupport()
+        )
+    }
+
+    /**
+     * 硬件特性支持信息数据类
+     */
+    data class HardwareFeatures(
+        val usbHost: Boolean,              // USB Host 支持
+        val usbAccessory: Boolean,         // USB 配件支持
+        val fingerprint: Boolean,          // 指纹识别器
+        val infrared: Boolean,             // 红外线传感器
+        val uwb: Boolean,                  // UWB 支持
+        val nfc: Boolean,                  // NFC 支持
+        val nfcHce: Boolean,               // NFC 主机卡模拟
+        val nfcHceOffHost: Boolean,        // NFC 离线主机卡模拟
+        val secureNfc: Boolean,            // 安全 NFC
+        val gps: Boolean,                  // GPS 支持
+        val networkLocation: Boolean,      // 网络定位支持
+        val location: Boolean              // 任何定位支持
+    )
+
+    /**
+     * 输入设备详细信息数据类
+     * 包含设备的所有属性和功能
+     */
     data class InputDeviceInfo(val inputDevice: InputDevice) {
+
+        /**
+         * 设备ID
+         * 唯一标识一个输入设备
+         */
         val id: Int get() = inputDevice.id
+
+        /**
+         * 控制器编号
+         * 对于游戏手柄，表示第几个手柄（1-4）
+         */
         val controllerNumber: Int get() = inputDevice.controllerNumber
+
+        /**
+         * 供应商ID
+         * USB设备的供应商标识
+         */
         val vendorId: Int get() = inputDevice.vendorId
+
+        /**
+         * 产品ID
+         * USB设备的产品标识
+         */
         val productId: Int get() = inputDevice.productId
+
+        /**
+         * 设备描述符
+         * 设备的唯一描述字符串
+         */
         val descriptor: String? get() = inputDevice.descriptor
+
+        /**
+         * 是否为虚拟设备
+         * 虚拟设备如软键盘、注入的输入事件等
+         */
         val isVirtual: Boolean get() = inputDevice.isVirtual
+
+        /**
+         * 是否为外部设备
+         * Android 10+ 可用
+         * 外部设备如USB键盘、蓝牙鼠标等
+         */
         val isExternal: Boolean
             get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                 inputDevice.isExternal
             } else {
                 false
             }
+
+        /**
+         * 设备名称
+         * 示例: "Virtual Keyboard", "USB Mouse", "Bluetooth Gamepad"
+         */
         val name: String get() = inputDevice.name
+
+        /**
+         * 输入源类型标志位
+         * 表示设备支持的输入类型（键盘、鼠标、触摸屏等）
+         */
         val sources: Int get() = inputDevice.sources
+
+        /**
+         * 键盘类型
+         * KEYBOARD_TYPE_NONE - 无键盘
+         * KEYBOARD_TYPE_NON_ALPHABETIC - 非字母键盘（如数字键盘）
+         * KEYBOARD_TYPE_ALPHABETIC - 字母键盘
+         */
         val keyboardType: Int get() = inputDevice.keyboardType
+
+        /**
+         * 键盘字符映射类型
+         * 表示键盘的字符映射能力
+         */
         val keyCharacterMapKeyboardType: Int get() = inputDevice.keyCharacterMap.keyboardType
+
+        /**
+         * 运动范围数量
+         * 表示设备支持的轴数量（如游戏手柄的摇杆、扳机键等）
+         */
         val motionRangesCount: Int get() = inputDevice.motionRanges.size
+
+        /**
+         * 是否有震动功能
+         * Android 12+ 使用 vibratorManager，之前版本使用 vibrator
+         */
         val hasVibrator: Boolean
             get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                 inputDevice.vibratorManager.vibratorIds.isNotEmpty()
@@ -57,21 +309,47 @@ class InputInfo(private val context: Context) {
                 @Suppress("DEPRECATION")
                 inputDevice.vibrator.hasVibrator()
             }
+
+        /**
+         * 设备是否已启用
+         * Android 8.1+ 可用
+         * 禁用的设备不会产生输入事件
+         */
         val isEnabled: Boolean
             get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
                 inputDevice.isEnabled
             } else {
                 true
             }
+
+        /**
+         * 是否有麦克风
+         * 某些输入设备（如游戏手柄）可能内置麦克风
+         */
         val hasMicrophone: Boolean get() = inputDevice.hasMicrophone()
 
         companion object {
+            /**
+             * 键盘类型映射表（英文）
+             */
             val keyboardTypeToString = mapOf(
                 InputDevice.KEYBOARD_TYPE_NONE to "None",
                 InputDevice.KEYBOARD_TYPE_NON_ALPHABETIC to "Non-alphabetic",
                 InputDevice.KEYBOARD_TYPE_ALPHABETIC to "Alphabetic",
             )
 
+            /**
+             * 键盘类型映射表（中文）
+             */
+            val keyboardTypeToStringChinese = mapOf(
+                InputDevice.KEYBOARD_TYPE_NONE to "无键盘",
+                InputDevice.KEYBOARD_TYPE_NON_ALPHABETIC to "非字母键盘",
+                InputDevice.KEYBOARD_TYPE_ALPHABETIC to "字母键盘",
+            )
+
+            /**
+             * 键盘字符映射类型映射表（英文）
+             */
             val keyCharacterMapKeyboardTypeToString = mapOf(
                 KeyCharacterMap.NUMERIC to "Numeric",
                 KeyCharacterMap.PREDICTIVE to "Predictive",
@@ -80,6 +358,20 @@ class InputInfo(private val context: Context) {
                 KeyCharacterMap.SPECIAL_FUNCTION to "Special Function",
             )
 
+            /**
+             * 键盘字符映射类型映射表（中文）
+             */
+            val keyCharacterMapKeyboardTypeToStringChinese = mapOf(
+                KeyCharacterMap.NUMERIC to "数字键盘",
+                KeyCharacterMap.PREDICTIVE to "预测输入",
+                KeyCharacterMap.ALPHA to "字母键盘",
+                KeyCharacterMap.FULL to "完整键盘",
+                KeyCharacterMap.SPECIAL_FUNCTION to "特殊功能键盘",
+            )
+
+            /**
+             * 输入源类别映射表（英文）
+             */
             val sourceClassToString = mapOf(
                 InputDevice.SOURCE_CLASS_BUTTON to "Button",
                 InputDevice.SOURCE_CLASS_POINTER to "Pointer",
@@ -88,6 +380,20 @@ class InputInfo(private val context: Context) {
                 InputDevice.SOURCE_CLASS_JOYSTICK to "Joystick",
             )
 
+            /**
+             * 输入源类别映射表（中文）
+             */
+            val sourceClassToStringChinese = mapOf(
+                InputDevice.SOURCE_CLASS_BUTTON to "按钮",
+                InputDevice.SOURCE_CLASS_POINTER to "指针",
+                InputDevice.SOURCE_CLASS_TRACKBALL to "轨迹球",
+                InputDevice.SOURCE_CLASS_POSITION to "位置",
+                InputDevice.SOURCE_CLASS_JOYSTICK to "游戏杆",
+            )
+
+            /**
+             * 输入源类型映射表（英文）
+             */
             val sourceToString = mapOf(
                 InputDevice.SOURCE_KEYBOARD to "Keyboard",
                 InputDevice.SOURCE_DPAD to "D-Pad",
@@ -102,6 +408,24 @@ class InputInfo(private val context: Context) {
                 InputDevice.SOURCE_JOYSTICK to "Joystick",
                 InputDevice.SOURCE_HDMI to "HDMI",
             )
+
+            /**
+             * 输入源类型映射表（中文）
+             */
+            val sourceToStringChinese = mapOf(
+                InputDevice.SOURCE_KEYBOARD to "键盘",
+                InputDevice.SOURCE_DPAD to "方向键",
+                InputDevice.SOURCE_GAMEPAD to "游戏手柄",
+                InputDevice.SOURCE_TOUCHSCREEN to "触摸屏",
+                InputDevice.SOURCE_MOUSE to "鼠标",
+                InputDevice.SOURCE_STYLUS to "触控笔",
+                InputDevice.SOURCE_TRACKBALL to "轨迹球",
+                InputDevice.SOURCE_TOUCHPAD to "触控板",
+                InputDevice.SOURCE_TOUCH_NAVIGATION to "触摸导航",
+                InputDevice.SOURCE_ROTARY_ENCODER to "旋转编码器",
+                InputDevice.SOURCE_JOYSTICK to "游戏杆",
+                InputDevice.SOURCE_HDMI to "HDMI",
+            )
         }
     }
 }