# CpuInfo 核心详细信息使用示例

## 新增功能说明

`CpuInfo` 类新增了获取每个 CPU 核心详细信息的功能，包括：
- 每个核心的最大频率
- 每个核心的最小频率
- 每个核心的当前频率
- 每个核心的速度度量值
- 可用频率列表

## 核心数据类

### CoreDetailedInfo
```kotlin
data class CoreDetailedInfo(
    val core: Core,                      // 核心基本信息
    val currentFrequency: Long,          // 当前频率（Hz）
    val minFrequency: Long,              // 最小频率（Hz）
    val maxFrequency: Long,              // 最大频率（Hz）
    val availableFrequencies: List<Long>, // 可用频率列表（Hz）
    val speedMetric: Double              // 速度度量值（GHz）
)
```

## 使用示例

### 1. 获取所有核心的详细信息

```kotlin
val cpuInfo = CpuInfo()

// 获取所有核心的详细信息
val detailedCores = cpuInfo.getCoresDetailedInfo()

detailedCores.forEachIndexed { index, coreInfo ->
    println("CPU $index:")
    println("  架构: ${coreInfo.core.uarch.name}")
    println("  供应商: ${coreInfo.core.vendor.name}")
    println("  当前频率: ${coreInfo.currentFrequency / 1_000_000} MHz")
    println("  最小频率: ${coreInfo.minFrequency / 1_000_000} MHz")
    println("  最大频率: ${coreInfo.maxFrequency / 1_000_000} MHz")
    println("  速度度量: ${String.format("%.2f GHz", coreInfo.speedMetric)}")
    println("  可用频率数量: ${coreInfo.availableFrequencies.size}")
}
```

### 2. 获取指定核心的详细信息

```kotlin
val cpuInfo = CpuInfo()

// 获取第一个核心（大核）的详细信息
val core0 = cpuInfo.getCoreDetailedInfo(0)

core0?.let {
    println("大核信息:")
    println("当前频率: ${it.currentFrequency / 1_000_000} MHz")
    println("最大频率: ${it.maxFrequency / 1_000_000} MHz")
    println("最小频率: ${it.minFrequency / 1_000_000} MHz")
    println("速度度量: ${it.speedMetric} GHz")
}
```

### 3. 获取所有核心的频率列表

```kotlin
val cpuInfo = CpuInfo()

// 获取所有核心的最大频率
val maxFreqs = cpuInfo.getCoresMaxFrequencies()
println("所有核心最大频率: ${maxFreqs.map { it / 1_000_000 }} MHz")

// 获取所有核心的最小频率
val minFreqs = cpuInfo.getCoresMinFrequencies()
println("所有核心最小频率: ${minFreqs.map { it / 1_000_000 }} MHz")

// 获取所有核心的当前频率
val currentFreqs = cpuInfo.getCoresCurrentFrequencies()
println("所有核心当前频率: ${currentFreqs.map { it / 1_000_000 }} MHz")

// 获取所有核心的速度度量值
val speedMetrics = cpuInfo.getCoresSpeedMetrics()
println("所有核心速度度量: ${speedMetrics.map { String.format("%.2f", it) }} GHz")
```

### 4. 分析大小核配置

```kotlin
val cpuInfo = CpuInfo()
val detailedCores = cpuInfo.getCoresDetailedInfo()

// 按最大频率排序，找出大核和小核
val sortedByFreq = detailedCores.sortedByDescending { it.maxFrequency }

println("大核（性能核心）:")
sortedByFreq.take(2).forEachIndexed { index, core ->
    println("  核心 ${core.core.processorStart}: ${core.core.uarch.name}, ${core.maxFrequency / 1_000_000} MHz")
}

println("\n小核（效率核心）:")
sortedByFreq.takeLast(6).forEach { core ->
    println("  核心 ${core.core.processorStart}: ${core.core.uarch.name}, ${core.maxFrequency / 1_000_000} MHz")
}
```

### 5. 监控实时频率变化

```kotlin
val cpuInfo = CpuInfo()

// 创建一个协程来监控频率变化
lifecycleScope.launch {
    while (isActive) {
        val currentFreqs = cpuInfo.getCoresCurrentFrequencies()
        
        println("实时频率:")
        currentFreqs.forEachIndexed { index, freq ->
            println("  CPU$index: ${freq / 1_000_000} MHz")
        }
        
        delay(1000) // 每秒更新一次
    }
}
```

### 6. 计算 CPU 负载百分比

```kotlin
val cpuInfo = CpuInfo()
val detailedCores = cpuInfo.getCoresDetailedInfo()

detailedCores.forEachIndexed { index, core ->
    // 计算当前频率占最大频率的百分比
    val loadPercentage = if (core.maxFrequency > 0) {
        (core.currentFrequency.toDouble() / core.maxFrequency * 100)
    } else {
        0.0
    }
    
    println("CPU$index 负载: ${String.format("%.1f%%", loadPercentage)}")
}
```

### 7. 在 Compose UI 中显示

```kotlin
@Composable
fun CpuCoresList() {
    val cpuInfo = remember { CpuInfo() }
    var detailedCores by remember { mutableStateOf(cpuInfo.getCoresDetailedInfo()) }
    
    // 自动刷新
    LaunchedEffect(Unit) {
        while (true) {
            delay(1000)
            detailedCores = cpuInfo.getCoresDetailedInfo()
        }
    }
    
    LazyColumn {
        itemsIndexed(detailedCores) { index, core ->
            Card(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(8.dp)
            ) {
                Column(modifier = Modifier.padding(16.dp)) {
                    Text(
                        text = "CPU $index",
                        style = MaterialTheme.typography.titleMedium
                    )
                    Spacer(modifier = Modifier.height(8.dp))
                    
                    Text("架构: ${core.core.uarch.name}")
                    Text("当前: ${core.currentFrequency / 1_000_000} MHz")
                    Text("范围: ${core.minFrequency / 1_000_000} - ${core.maxFrequency / 1_000_000} MHz")
                    Text("速度度量: ${String.format("%.2f GHz", core.speedMetric)}")
                    
                    // 频率进度条
                    LinearProgressIndicator(
                        progress = if (core.maxFrequency > 0) {
                            core.currentFrequency.toFloat() / core.maxFrequency
                        } else 0f,
                        modifier = Modifier
                            .fillMaxWidth()
                            .padding(top = 8.dp)
                    )
                }
            }
        }
    }
}
```

## 获取 CPU 性能摘要

使用 `text()` 方法可以获取完整的 CPU 信息摘要（包括新增的核心详细信息）：

```kotlin
val cpuInfo = CpuInfo()
val summary = cpuInfo.text()
println(summary)
```

输出示例：
```
=== CPU Basic Info ===
Processor Name: Qualcomm Snapdragon 888
Vendor: ARM
Process: 5nm
Foundry: Samsung
Process Node: Samsung 5LPE
Physical Cores: 8
Logical Processors: 8

=== Core Cluster Configuration ===
Big Cores: 1, Max Frequency: 2.84 GHz
Mid Cores: 3, Max Frequency: 2.42 GHz
Little Cores: 4, Max Frequency: 1.80 GHz

=== Architecture Info ===
Architecture: Cortex-X1, Cortex-A78, Cortex-A55
ABI: arm64-v8a
Supported ABIs: arm64-v8a, armeabi-v7a, armeabi

=== Performance Metrics ===
Performance Level: Flagship
Performance Index: 95.2
Total Score: 17984.5
BogoMIPS: 38.40

=== Governor ===
Current Governor: schedutil
Available Governors: schedutil, performance, powersave

=== Core Detailed Info ===
CPU0: Current=2.84 GHz, Range=300 MHz-2.84 GHz, Metric=2.84 GHz, Arch=Cortex-X1
CPU1: Current=2.42 GHz, Range=300 MHz-2.42 GHz, Metric=2.42 GHz, Arch=Cortex-A78
...
```

## 注意事项

1. **频率单位**: 所有频率值都以 Hz（赫兹）为单位返回
   - 转换为 MHz: `frequency / 1_000_000`
   - 转换为 GHz: `frequency / 1_000_000_000.0`

2. **权限**: 读取频率信息不需要特殊权限

3. **实时性**: `currentFrequency` 是实时读取的，会随 CPU 负载变化而变化

4. **可用频率**: 某些设备可能不提供 `availableFrequencies` 列表，返回空列表

5. **速度度量**: `speedMetric` 是根据最大频率计算的，单位为 GHz，可以用来比较不同核心的性能

6. **中英文**: 所有返回的文本信息已改为英文，中文保留在注释中

## 兼容性

- 最低 Android 版本: 与原 CpuInfo 类相同
- 支持所有架构: ARM, ARM64, x86, x86_64
- 向后兼容: 所有原有方法保持不变