# MemInfo 内存类型检测使用示例

## 概述
MemInfo 类提供了完整的内存信息检测功能，特别是增强了内存类型（LPDDR5、LPDDR4X等）的检测能力。

## 增强的功能

### 内存类型检测方法（5种）

1. **系统属性检测** - 从 Android 系统属性获取
   - `ro.boot.ddr_type`
   - `ro.boot.ddrtype`
   - `ro.vendor.boot.ddr_type`
   - `persist.vendor.ddr.type`
   - 等多个属性路径

2. **Sysfs 文件系统检测** - 从设备文件系统读取
   - Qualcomm 设备路径
   - MediaTek 设备路径
   - Samsung Exynos 设备路径
   - 通用路径

3. **设备树检测** - 从设备树 (Device Tree) 获取
   - `/proc/device-tree/memory/ddr-type`
   - `/sys/firmware/devicetree/base/memory/ddr-type`

4. **内核日志检测** - 从 dmesg 日志分析
   - 搜索 DDR、LPDDR、memory type 关键词

5. **智能推测** - 根据 Android 版本和发布年份估算
   - Android 14+ (2023+) → LPDDR5X
   - Android 13 (2022+) → LPDDR5
   - Android 12 (2021+) → LPDDR5
   - Android 11 (2020+) → LPDDR4X
   - Android 10 (2019+) → LPDDR4X

### 支持的内存类型

- **LPDDR5X** - 最新旗舰设备（2023+）
- **LPDDR5** - 高端设备（2021-2023）
- **LPDDR4X** - 中高端设备（2019-2021）
- **LPDDR4** - 主流设备（2017-2019）
- **LPDDR3** - 老旧设备（2015-2017）
- **LPDDR2** - 更老设备（2013-2015）
- **DDR5/DDR4/DDR3** - 非移动设备

## 使用方法

### 1. 初始化

```kotlin
import com.xyzshell.andinfo.AndInfo

// 在 Application 或 Activity 中初始化
AndInfo.init(applicationContext)

// 获取 MemInfo 实例
val memInfo = AndInfo.instance.mem
```

### 2. 获取完整内存信息

```kotlin
val memoryInfo = memInfo.getMemoryInfo()

println("=== 内存信息 ===")
println("总内存: ${memInfo.formatBytes(memoryInfo.totalRam)}")
println("可用内存: ${memInfo.formatBytes(memoryInfo.availableRam)}")
println("已使用: ${memInfo.formatBytes(memoryInfo.usedRam)}")
println("内存类型: ${memoryInfo.memType}")
println("内存通道: ${memoryInfo.channels} 通道")
println("ZRAM 总大小: ${memInfo.formatBytes(memoryInfo.zramTotal)}")
println("ZRAM 已使用: ${memInfo.formatBytes(memoryInfo.zramUsed)}")
```

### 3. 仅获取内存类型

```kotlin
val memoryInfo = memInfo.getMemoryInfo()
val memType = memoryInfo.memType

when {
    memType.contains("LPDDR5X") -> {
        println("✅ 最新旗舰内存：LPDDR5X")
        println("特点：最高性能，最低功耗，用于2023年后的旗舰设备")
    }
    memType.contains("LPDDR5") -> {
        println("✅ 高端内存：LPDDR5")
        println("特点：高性能，低功耗，用于2021-2023年的高端设备")
    }
    memType.contains("LPDDR4X") -> {
        println("✅ 主流内存：LPDDR4X")
        println("特点：均衡性能与功耗，用于大多数中高端设备")
    }
    memType.contains("LPDDR4") -> {
        println("✅ 标准内存：LPDDR4")
        println("特点：标准性能，用于主流设备")
    }
    memType.contains("estimated") -> {
        println("ℹ️ 估算的内存类型：$memType")
        println("提示：系统无法直接读取内存类型，基于设备信息估算")
    }
    else -> {
        println("❓ 未知内存类型")
    }
}
```

### 4. 内存性能评估

```kotlin
val memoryInfo = memInfo.getMemoryInfo()

// 评估内存性能等级
val performanceLevel = when {
    memoryInfo.memType.contains("LPDDR5X") -> "旗舰级"
    memoryInfo.memType.contains("LPDDR5") -> "高端"
    memoryInfo.memType.contains("LPDDR4X") -> "中高端"
    memoryInfo.memType.contains("LPDDR4") -> "中端"
    else -> "入门"
}

println("内存性能等级: $performanceLevel")
println("理论带宽估算:")

when {
    memoryInfo.memType.contains("LPDDR5X") -> {
        val bandwidth = 8533 * memoryInfo.channels // LPDDR5X-8533
        println("  约 ${bandwidth} MB/s (${memoryInfo.channels}通道)")
    }
    memoryInfo.memType.contains("LPDDR5") -> {
        val bandwidth = 6400 * memoryInfo.channels // LPDDR5-6400
        println("  约 ${bandwidth} MB/s (${memoryInfo.channels}通道)")
    }
    memoryInfo.memType.contains("LPDDR4X") -> {
        val bandwidth = 4266 * memoryInfo.channels // LPDDR4X-4266
        println("  约 ${bandwidth} MB/s (${memoryInfo.channels}通道)")
    }
}
```

### 5. 内存使用情况分析

```kotlin
val memoryInfo = memInfo.getMemoryInfo()

// 计算使用率
val usagePercentage = (memoryInfo.usedRam.toDouble() / memoryInfo.totalRam * 100).toInt()

println("=== 内存使用情况 ===")
println("总内存: ${memInfo.formatBytes(memoryInfo.totalRam)}")
println("已使用: ${memInfo.formatBytes(memoryInfo.usedRam)} (${usagePercentage}%)")
println("可用: ${memInfo.formatBytes(memoryInfo.availableRam)}")

// 使用状态
when {
    usagePercentage >= 90 -> println("⚠️ 内存严重不足")
    usagePercentage >= 75 -> println("⚠️ 内存偏紧")
    usagePercentage >= 50 -> println("✓ 内存使用正常")
    else -> println("✓ 内存充裕")
}

// ZRAM 情况
if (memoryInfo.zramTotal > 0) {
    val zramUsagePercent = (memoryInfo.zramUsed.toDouble() / memoryInfo.zramTotal * 100).toInt()
    println("\n=== ZRAM (压缩内存) ===")
    println("ZRAM 大小: ${memInfo.formatBytes(memoryInfo.zramTotal)}")
    println("ZRAM 已使用: ${memInfo.formatBytes(memoryInfo.zramUsed)} (${zramUsagePercent}%)")
}
```

### 6. 完整示例

```kotlin
class MemoryInfoActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        displayMemoryInfo()
    }
    
    private fun displayMemoryInfo() {
        val memInfo = AndInfo.instance.mem
        val memoryInfo = memInfo.getMemoryInfo()
        
        val info = buildString {
            appendLine("╔════════════════════════════════╗")
            appendLine("║       设备内存信息报告         ║")
            appendLine("╚════════════════════════════════╝")
            appendLine()
            
            // 内存容量
            appendLine("【内存容量】")
            appendLine("  总内存：${memInfo.formatBytes(memoryInfo.totalRam)}")
            appendLine("  可用：${memInfo.formatBytes(memoryInfo.availableRam)}")
            appendLine("  已使用：${memInfo.formatBytes(memoryInfo.usedRam)}")
            
            val usagePercent = (memoryInfo.usedRam.toDouble() / memoryInfo.totalRam * 100).toInt()
            appendLine("  使用率：${usagePercent}%")
            appendLine()
            
            // 内存类型
            appendLine("【内存规格】")
            appendLine("  类型：${memoryInfo.memType}")
            appendLine("  通道：${memoryInfo.channels} 通道")
            
            // 性能评级
            val perfLevel = when {
                memoryInfo.memType.contains("LPDDR5X") -> "⭐⭐⭐⭐⭐ 旗舰级"
                memoryInfo.memType.contains("LPDDR5") -> "⭐⭐⭐⭐ 高端"
                memoryInfo.memType.contains("LPDDR4X") -> "⭐⭐⭐ 中高端"
                memoryInfo.memType.contains("LPDDR4") -> "⭐⭐ 中端"
                else -> "⭐ 入门"
            }
            appendLine("  性能等级：$perfLevel")
            appendLine()
            
            // ZRAM 信息
            if (memoryInfo.zramTotal > 0) {
                appendLine("【ZRAM 压缩内存】")
                appendLine("  总大小：${memInfo.formatBytes(memoryInfo.zramTotal)}")
                appendLine("  已使用：${memInfo.formatBytes(memoryInfo.zramUsed)}")
                val zramPercent = (memoryInfo.zramUsed.toDouble() / memoryInfo.zramTotal * 100).toInt()
                appendLine("  使用率：${zramPercent}%")
            }
        }
        
        println(info)
        // 或者显示在 TextView 中
        // textView.text = info
    }
}
```

## 检测原理说明

### 1. 系统属性检测
```kotlin
// 尝试读取系统属性
getprop ro.boot.ddr_type
// 可能返回: "LPDDR5", "4", "5" 等
```

### 2. Sysfs 文件检测
```kotlin
// Qualcomm 设备
/sys/class/devfreq/soc:qcom,cpu-cpu-llcc-bw/device/type

// MediaTek 设备
/sys/kernel/debug/emi_mbw/dram_type

// Samsung Exynos 设备
/sys/class/devfreq/17000010.devfreq_mif/device/type
```

### 3. 设备树检测
```kotlin
// 设备树路径
/proc/device-tree/memory/ddr-type
/sys/firmware/devicetree/base/memory/ddr-type
```

### 4. 内核日志检测
```bash
# 搜索内核日志
dmesg | grep -iE 'ddr|lpddr|memory.*type'
# 可能输出: "LPDDR5 detected", "DDR Type: 5" 等
```

### 5. 智能推测规则

| Android 版本 | 发布年份 | 估算类型 |
|-------------|---------|---------|
| 14+ | 2023+ | LPDDR5X |
| 13 | 2022-2023 | LPDDR5 |
| 12 | 2021-2022 | LPDDR5 |
| 11 | 2020-2021 | LPDDR4X |
| 10 | 2019-2020 | LPDDR4X |
| 9 | 2018-2019 | LPDDR4 |
| ≤8 | ≤2017 | LPDDR3 |

## 典型设备示例

### 高端旗舰（2023+）
```
内存类型: LPDDR5X
通道: 4 通道
理论带宽: 约 34,132 MB/s
性能等级: ⭐⭐⭐⭐⭐ 旗舰级
代表设备: Samsung S24 Ultra, Xiaomi 14 Pro
```

### 高端设备（2021-2023）
```
内存类型: LPDDR5
通道: 4 通道
理论带宽: 约 25,600 MB/s
性能等级: ⭐⭐⭐⭐ 高端
代表设备: Pixel 7 Pro, OnePlus 11
```

### 中高端设备（2019-2021）
```
内存类型: LPDDR4X
通道: 2 通道
理论带宽: 约 8,532 MB/s
性能等级: ⭐⭐⭐ 中高端
代表设备: Pixel 5, Mi 10T
```

## 注意事项

1. **权限要求**：
   - 无需特殊权限
   - 某些检测路径可能需要 root 权限才能访问

2. **检测准确性**：
   - 优先级：系统属性 > Sysfs > 设备树 > 内核日志 > 估算
   - 带 "(estimated)" 标记表示是推测值

3. **设备差异**：
   - 不同厂商的设备，内存信息存储位置可能不同
   - 某些定制 ROM 可能修改了相关路径

4. **性能差异**：
   - 相同类型的内存，不同频率性能也不同
   - 通道数会显著影响实际带宽

## 完成度

✅ **100%** - 所有功能都已实现
- 系统属性检测 ✅
- Sysfs 文件系统检测 ✅
- 设备树检测 ✅
- 内核日志检测 ✅
- 智能推测 ✅
- 内存类型解析 ✅
- 支持所有主流内存类型 ✅
- 完整的中文注释 ✅
- 详细的使用文档 ✅

所有功能都已正确实现并可以使用！🎉