APM

object APMConfig {
    // 开关配置
    const val ENABLE_LAUNCH_MONITOR = true // 启动监控
    const val ENABLE_JANK_MONITOR = true   // 卡顿监控
    const val ENABLE_ANR_MONITOR = true    // ANR监控
    const val ENABLE_CRASH_MONITOR = true  // Crash监控

    // 上报配置
    const val REPORT_URL = "https://your-api.com/apm/report" // 替换为你的后台接口
    const val BATCH_REPORT_INTERVAL = 30_000L // 批量上报间隔（30秒）
    const val MAX_QUEUE_SIZE = 100 // 最大缓存队列长度

    // 卡顿阈值（主线程消息执行>200ms判定为卡顿）
    const val JANK_THRESHOLD_MS = 200L
    // FPS阈值（<45判定为卡顿）
    const val FPS_LOW_THRESHOLD = 45.0

    // 设备信息（全局缓存）
    val DEVICE_INFO by lazy {
        mapOf(
            "device_model" to android.os.Build.MODEL,
            "os_version" to android.os.Build.VERSION.RELEASE,
            "app_version" to BuildConfig.VERSION_NAME,
            "app_version_code" to BuildConfig.VERSION_CODE.toString(),
            "package_name" to BuildConfig.APPLICATION_ID,
            "cpu_abi" to android.os.Build.CPU_ABI
        )
    }
}

import android.content.Context
import android.content.SharedPreferences
import com.google.gson.Gson
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.util.*
import java.util.concurrent.ConcurrentLinkedQueue
import java.util.concurrent.Executors

object APMReporter {
    private val gson = Gson()
    private val executor = Executors.newSingleThreadExecutor()
    private val metricsQueue = ConcurrentLinkedQueue<Map<String, Any>>()
    private val okHttpClient = OkHttpClient.Builder().build()
    private lateinit var sp: SharedPreferences
    private val MEDIA_TYPE = "application/json; charset=utf-8".toMediaType()

    // 初始化（在Application中调用）
    fun init(context: Context) {
        sp = context.getSharedPreferences("apm_cache", Context.MODE_PRIVATE)
        // 加载本地缓存的未上报数据
        val cacheData = sp.getString("apm_queue", null)
        if (cacheData != null) {
            val list = gson.fromJson(cacheData, Array<Map<String, Any>>::class.java).toList()
            metricsQueue.addAll(list)
        }
        // 启动定时批量上报
        executor.scheduleAtFixedRate({
            batchReport()
        }, 0, APMConfig.BATCH_REPORT_INTERVAL, java.util.concurrent.TimeUnit.MILLISECONDS)
    }

    // 上报单个指标
    fun report(metricType: String, data: Map<String, Any>) {
        if (metricsQueue.size >= APMConfig.MAX_QUEUE_SIZE) {
            metricsQueue.poll() // 队列满了，移除最早的一条
        }
        // 拼接基础信息
        val finalData = mutableMapOf<String, Any>().apply {
            putAll(APMConfig.DEVICE_INFO)
            put("metric_type", metricType)
            put("timestamp", System.currentTimeMillis())
            putAll(data)
        }
        metricsQueue.offer(finalData)
        // 紧急指标（Crash/ANR）立即上报，不等待批量
        if (metricType in listOf("crash", "anr")) {
            executor.submit {
                val singleData = listOf(finalData)
                doReport(singleData)
            }
        }
    }

    // 批量上报
    private fun batchReport() {
        if (metricsQueue.isEmpty()) return
        val dataList = mutableListOf<Map<String, Any>>()
        metricsQueue.drainTo(dataList)
        // 上报前缓存到本地，避免进程被杀丢失
        sp.edit().putString("apm_queue", gson.toJson(metricsQueue)).apply()
        // 异步上报
        executor.submit {
            val success = doReport(dataList)
            if (success) {
                // 上报成功，清空本地缓存
                sp.edit().remove("apm_queue").apply()
            } else {
                // 上报失败，把数据放回队列
                metricsQueue.addAll(dataList)
            }
        }
    }

    // 实际上报逻辑
    private fun doReport(dataList: List<Map<String, Any>>): Boolean {
        return try {
            val json = gson.toJson(dataList)
            val requestBody = json.toRequestBody(MEDIA_TYPE)
            val request = Request.Builder()
                .url(APMConfig.REPORT_URL)
                .post(requestBody)
                .build()
            val response = okHttpClient.newCall(request).execute()
            response.isSuccessful
        } catch (e: Exception) {
            e.printStackTrace()
            false
        }
    }
}

object UserBehaviorTracker {
    private val behaviorList = LinkedList<String>()
    private const val MAX_BEHAVIOR_COUNT = 10 // 最多保留10条

    // 记录用户行为
    fun track(behavior: String) {
        if (behaviorList.size >= MAX_BEHAVIOR_COUNT) {
            behaviorList.removeFirst()
        }
        behaviorList.add("${System.currentTimeMillis()}: $behavior")
    }

    // 获取最近行为（用于上报）
    fun getLastBehaviors(): String {
        return behaviorList.joinToString("\n")
    }

    // 清空行为记录
    fun clear() {
        behaviorList.clear()
    }
}

import android.content.ContentProvider
import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.net.Uri
import android.os.Handler
import android.os.Looper
import android.view.Window

class LaunchMonitor {
    companion object {
        var processStartTime = 0L // 进程启动时间（最早起点）
        var appCreateTime = 0L    // Application.onCreate 时间
        var firstFrameTime = 0L   // 首帧渲染时间

        // 初始化（在Application中调用）
        fun init(application: Context) {
            if (!APMConfig.ENABLE_LAUNCH_MONITOR) return

            // 记录Application.onCreate时间
            appCreateTime = System.currentTimeMillis()

            // 监听首帧渲染（冷启动终点）
            Handler(Looper.getMainLooper()).postAtFrontOfQueue {
                firstFrameTime = System.currentTimeMillis()
                reportLaunchData()
            }
        }

        // 上报启动数据
        private fun reportLaunchData() {
            val coldLaunchTime = firstFrameTime - processStartTime // 冷启动总耗时
            val appCreateDuration = appCreateTime - processStartTime // 进程→AppCreate耗时
            val firstFrameDuration = firstFrameTime - appCreateTime // AppCreate→首帧耗时

            val launchData = mapOf(
                "launch_type" to "cold", // 可扩展区分温/热启动
                "cold_launch_total" to coldLaunchTime,
                "process_to_app_create" to appCreateDuration,
                "app_create_to_first_frame" to firstFrameDuration,
                "last_behavior" to UserBehaviorTracker.getLastBehaviors()
            )
            APMReporter.report("launch", launchData)
        }

        // 监听Activity首帧（可选，精准化页面启动耗时）
        fun monitorActivityFirstFrame(window: Window, activityName: String) {
            if (!APMConfig.ENABLE_LAUNCH_MONITOR) return

            val activityStartTime = System.currentTimeMillis()
            window.decorView.viewTreeObserver.addOnDrawListener(object : android.view.ViewTreeObserver.OnDrawListener {
                override fun onDraw() {
                    window.decorView.viewTreeObserver.removeOnDrawListener(this)
                    val activityLaunchTime = System.currentTimeMillis() - activityStartTime
                    val data = mapOf(
                        "activity_name" to activityName,
                        "launch_time" to activityLaunchTime
                    )
                    APMReporter.report("activity_launch", data)
                }
            })
        }
    }
}

// 用于捕获进程启动时间的ContentProvider（进程启动时优先初始化）
class LaunchProvider : ContentProvider() {
    override fun onCreate(): Boolean {
        LaunchMonitor.processStartTime = System.currentTimeMillis()
        return true
    }

    override fun query(uri: Uri, projection: Array<String>?, selection: String?, selectionArgs: Array<String>?, sortOrder: String?): Cursor? = null
    override fun getType(uri: Uri): String? = null
    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?): Int = 0
    override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<String>?): Int = 0
}

import android.os.Looper
import android.view.Choreographer
import java.lang.Exception
import java.lang.StringBuilder

class JankMonitor {
    private var frameCount = 0
    private var fpsStartTime = 0L
    private val mainLooper = Looper.getMainLooper()

    // 初始化（在Application中调用）
    fun init() {
        if (!APMConfig.ENABLE_JANK_MONITOR) return
        // 监控FPS
        startFPSMonitor()
        // 监控主线程阻塞
        startMainThreadBlockMonitor()
    }

    // 1. FPS监控（基于Choreographer）
    private fun startFPSMonitor() {
        val choreographer = Choreographer.getInstance()
        choreographer.postFrameCallback(object : Choreographer.FrameCallback {
            override fun doFrame(frameTimeNanos: Long) {
                if (fpsStartTime == 0L) {
                    fpsStartTime = System.currentTimeMillis()
                }
                frameCount++

                val currentTime = System.currentTimeMillis()
                if (currentTime - fpsStartTime >= 1000) {
                    // 计算FPS
                    val fps = frameCount / ((currentTime - fpsStartTime) / 1000.0)
                    val isJank = fps < APMConfig.FPS_LOW_THRESHOLD

                    // 上报FPS数据
                    val fpsData = mapOf(
                        "fps" to fps,
                        "is_jank" to isJank,
                        "timestamp" to System.currentTimeMillis()
                    )
                    APMReporter.report("fps", fpsData)

                    // 重置计数
                    frameCount = 0
                    fpsStartTime = currentTime
                }
                // 继续监听下一帧
                choreographer.postFrameCallback(this)
            }
        })
    }

    // 2. 主线程阻塞监控（基于Looper消息拦截）
    private fun startMainThreadBlockMonitor() {
        val originalLogging = mainLooper.messageLogging
        mainLooper.setMessageLogging { msg ->
            // 拦截Looper消息日志，捕获消息开始/结束
            if (msg.startsWith(">>>>> Dispatching to")) {
                // 消息开始执行
                BlockTrace.beginTrace(msg)
            } else if (msg.startsWith("<<<<< Finished to")) {
                // 消息执行结束，计算耗时
                val costTime = BlockTrace.endTrace(msg)
                if (costTime > APMConfig.JANK_THRESHOLD_MS) {
                    // 卡顿，上报堆栈和耗时
                    val stackTrace = getMainThreadStackTrace()
                    val blockData = mapOf(
                        "cost_time" to costTime,
                        "stack_trace" to stackTrace,
                        "message" to msg,
                        "last_behavior" to UserBehaviorTracker.getLastBehaviors()
                    )
                    APMReporter.report("main_thread_block", blockData)
                }
            }
            // 保留原有日志逻辑
            originalLogging?.let { it.println(msg) }
        }
    }

    // 获取主线程堆栈
    private fun getMainThreadStackTrace(): String {
        return try {
            val stackTrace = mainLooper.thread.stackTrace
            val sb = StringBuilder()
            stackTrace.forEach {
                sb.append(it.toString()).append("\n")
            }
            sb.toString()
        } catch (e: Exception) {
            e.stackTraceToString()
        }
    }
}

// 辅助类：记录消息执行时间
object BlockTrace {
    private val traceMap = mutableMapOf<String, Long>()

    fun beginTrace(msg: String) {
        val key = msg.substringAfter("Dispatching to ").substringBefore(":")
        traceMap[key] = System.currentTimeMillis()
    }

    fun endTrace(msg: String): Long {
        val key = msg.substringAfter("Finished to ").substringBefore(":")
        val startTime = traceMap.remove(key) ?: return 0
        return System.currentTimeMillis() - startTime
    }
}

import android.os.FileObserver
import java.io.File
import java.lang.Exception

class AnrMonitor {
    // 初始化（在Application中调用）
    fun init() {
        if (!APMConfig.ENABLE_ANR_MONITOR) return
        startAnrFileMonitor()
    }

    // 监听ANR日志文件
    private fun startAnrFileMonitor() {
        val anrFile = File("/data/anr/traces.txt")
        if (!anrFile.exists()) return

        val fileObserver = object : FileObserver(anrFile.absolutePath, FileObserver.MODIFY or FileObserver.CREATE) {
            override fun onEvent(event: Int, path: String?) {
                if (event == FileObserver.MODIFY && path == "traces.txt") {
                    // ANR发生，读取日志并上报
                    executor.submit {
                        val anrLog = readAnrLog(anrFile)
                        val anrData = mapOf(
                            "anr_log" to anrLog,
                            "last_behavior" to UserBehaviorTracker.getLastBehaviors(),
                            "memory_info" to getMemoryInfo()
                        )
                        APMReporter.report("anr", anrData)
                    }
                }
            }
        }
        fileObserver.startWatching()
    }

    // 读取ANR日志
    private fun readAnrLog(file: File): String {
        return try {
            file.readText()
        } catch (e: Exception) {
            "Read ANR log failed: ${e.message}"
        }
    }

    // 获取ANR时的内存信息
    private fun getMemoryInfo(): String {
        val runtime = Runtime.getRuntime()
        val usedMem = (runtime.totalMemory() - runtime.freeMemory()) / (1024 * 1024)
        val maxMem = runtime.maxMemory() / (1024 * 1024)
        return "Used: $usedMem MB, Max: $maxMem MB"
    }

    private val executor = java.util.concurrent.Executors.newSingleThreadExecutor()
}

import android.content.Context
import android.os.Build
import android.os.Process
import java.io.PrintWriter
import java.io.StringWriter
import java.lang.Thread.UncaughtExceptionHandler

class CrashHandler : UncaughtExceptionHandler {
    private lateinit var context: Context
    private val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()

    // 初始化（在Application中调用）
    fun init(context: Context) {
        this.context = context
        if (APMConfig.ENABLE_CRASH_MONITOR) {
            Thread.setDefaultUncaughtExceptionHandler(this)
        }
    }

    override fun uncaughtException(t: Thread, e: Throwable) {
        // 1. 收集Crash信息
        val crashInfo = collectCrashInfo(t, e)
        // 2. 上报Crash
        APMReporter.report("crash", crashInfo)
        // 3. 交给默认处理器（避免应用卡死）
        defaultHandler?.uncaughtException(t, e)
        // 4. 退出进程（可选）
        Process.killProcess(Process.myPid())
    }

    // 收集Crash上下文信息
    private fun collectCrashInfo(thread: Thread, e: Throwable): Map<String, Any> {
        val stackTrace = getStackTraceString(e)
        return mutableMapOf<String, Any>().apply {
            put("thread_name", thread.name)
            put("thread_id", thread.id)
            put("exception_type", e.javaClass.simpleName)
            put("exception_msg", e.message ?: "null")
            put("stack_trace", stackTrace)
            put("last_behavior", UserBehaviorTracker.getLastBehaviors())
            put("android_version", Build.VERSION.SDK_INT)
            put("is_debug", APMConfig.DEBUG)
            // 可选：添加内存/CPU信息
            put("memory_info", getMemoryInfo())
        }
    }

    // 拼接完整堆栈
    private fun getStackTraceString(e: Throwable): String {
        val sw = StringWriter()
        val pw = PrintWriter(sw)
        e.printStackTrace(pw)
        var cause = e.cause
        while (cause != null) {
            cause.printStackTrace(pw)
            cause = cause.cause
        }
        pw.close()
        return sw.toString()
    }

    // 获取内存信息
    private fun getMemoryInfo(): String {
        val runtime = Runtime.getRuntime()
        val used = (runtime.totalMemory() - runtime.freeMemory()) / (1024 * 1024)
        val max = runtime.maxMemory() / (1024 * 1024)
        return "Used: $used MB, Max: $max MB"
    }
}

import android.app.Application
import android.content.Context

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        // 1. 初始化APM上报器
        APMReporter.init(this)
        // 2. 初始化启动监控
        LaunchMonitor.init(this)
        // 3. 初始化卡顿监控
        JankMonitor().init()
        // 4. 初始化ANR监控
        AnrMonitor().init()
        // 5. 初始化Crash监控
        CrashHandler().init(this)

        // 示例：记录应用启动行为
        UserBehaviorTracker.track("Application onCreate")
    }

    // 全局Context（可选）
    companion object {
        lateinit var context: Context
            private set
    }
}

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

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

        // 1. 记录用户行为（用于ANR/Crash时还原路径）
        UserBehaviorTracker.track("MainActivity onCreate")

        // 2. 监控Activity首帧耗时
        LaunchMonitor.monitorActivityFirstFrame(window, "MainActivity")

        // 3. 模拟卡顿（测试用，实际项目删除）
        findViewById<android.view.View>(R.id.btn_test).setOnClickListener {
            UserBehaviorTracker.track("Click test button")
            // 主线程阻塞300ms，触发卡顿监控
            Thread.sleep(300)
        }
    }
}