// 在需要分析的代碼段前后添加跟蹤代碼
fun analyzeHeavyOperation() {
    // 開始記錄（文件保存在應(yīng)用沙盒目錄）
    val tracePath = getExternalFilesDir(null)?.path + "/app_trace.trace"
    Debug.startMethodTracingSampling(tracePath, 8 * 1024 * 1024, 1) // 8MB緩沖區(qū)，1ms采樣間隔
    
    try {
        // 需要分析的耗時(shí)操作
        performDataProcessing()
        renderComplexUI()
    } finally {
        // 確保在異常情況下也停止跟蹤
        Debug.stopMethodTracing()
    }
}

// 示例耗時(shí)函數(shù)
private fun performDataProcessing() {
    // 模擬耗時(shí)操作
    Thread.sleep(200)
    processLargeDataset()
}

private fun processLargeDataset() {
    // 模擬數(shù)據(jù)處理
    val data = List(10000) { it * 1.5 }
    data.sortedByDescending { it } // 故意使用低效排序
}

# 啟動應(yīng)用
adb shell am start -n com.example.app/.MainActivity

# 開始跟蹤
adb shell am profile start com.example.app /sdcard/trace.trace

# 執(zhí)行需要分析的操作（如點(diǎn)擊按鈕）

# 停止跟蹤
adb shell am profile stop com.example.app

# 拉取文件
adb pull /sdcard/trace.trace .

# 轉(zhuǎn)換 trace 文件格式
traceconv app_trace.trace app_trace.perfetto-trace

fun processDataInefficiently(data: List<Double>) {
    // 低效冒泡排序 O(n2)
    val sorted = data.toMutableList()
    for (i in 0 until sorted.size) {
        for (j in 0 until sorted.size - 1) {
            if (sorted[j] > sorted[j + 1]) {
                val temp = sorted[j]
                sorted[j] = sorted[j + 1]
                sorted[j + 1] = temp
            }
        }
    }
}

processDataInefficiently - Incl Cpu Time: 450ms (98%)
  ∟ compareValues - Incl Cpu Time: 420ms (93%)

fun processDataEfficiently(data: List<Double>) {
    // 使用快速排序 O(n log n)
    val sorted = data.sorted() // 使用標(biāo)準(zhǔn)庫高效實(shí)現(xiàn)
    
    // 進(jìn)一步優(yōu)化：使用并行處理
    withContext(Dispatchers.Default) {
        val processed = sorted.map { heavyTransformation(it) }
    }
}

suspend fun heavyTransformation(value: Double): Double {
    // 模擬復(fù)雜計(jì)算
    return coroutineScope {
        async { value * 2.5 }.await()
    }
}

// 使用協(xié)程優(yōu)化UI線程阻塞問題
suspend fun loadAndProcessData() = coroutineScope {
    // 并行加載數(shù)據(jù)
    val dataDeferred = async(Dispatchers.IO) { fetchDataFromNetwork() }
    val configDeferred = async(Dispatchers.IO) { loadConfig() }
    
    // 等待數(shù)據(jù)
    val data = dataDeferred.await()
    val config = configDeferred.await()
    
    // 使用后臺線程處理
    val processedData = withContext(Dispatchers.Default) {
        processLargeDataset(data, config)
    }
    
    // 更新UI
    withContext(Dispatchers.Main) {
        updateUI(processedData)
    }
}

// 使用內(nèi)存緩存避免重復(fù)計(jì)算
object DataProcessor {
    private val cache = LruCache<String, Result>(10)
    
    suspend fun processWithCache(key: String): Result {
        return cache[key] ?: processAndCache(key)
    }
    
    private suspend fun processAndCache(key: String): Result {
        return withContext(Dispatchers.Default) {
            val result = heavyProcessing(key)
            cache.put(key, result)
            result
        }
    }
    
    private fun heavyProcessing(key: String): Result {
        // 復(fù)雜計(jì)算...
    }
}

# 捕獲系統(tǒng)級 trace
adb shell perfetto -o /data/misc/perfetto-traces/trace.perfetto-trace \
  -c - --txt \
<<EOF
buffers: { size_kb: 63488 }
data_sources: {
    config: {
        name: "linux.process_stats"
        target_buffer: 0
        process_stats_config: { scan_all_processes_on_start: true }
    }
}
duration_ms: 10000
EOF

# 拉取文件
adb pull /data/misc/perfetto-traces/trace.perfetto-trace

// 使用采樣模式減少開銷
Debug.startMethodTracingSampling(
    "sampled_trace",
    8 * 1024 * 1024, // 8MB 緩沖區(qū)
    5 // 5ms 采樣間隔
)

<!-- AndroidManifest.xml -->
<application
    android:requestLegacyExternalStorage="true"
    ... >

// 使用 Firebase Performance Monitoring 監(jiān)控關(guān)鍵路徑
val trace = Firebase.performance.newTrace("data_processing")
trace.start()

try {
    processUserData()
    trace.incrementMetric("success", 1)
} catch (e: Exception) {
    trace.incrementMetric("failure", 1)
} finally {
    trace.stop()
}