Choreographer

// 获取当前线程对应的 Choreographer 实例（主线程调用即为 UI 渲染的核心实例）
val choreographer = Choreographer.getInstance()

private var lastFrameTimeNanos: Long = 0

/**
 * 注册帧回调，监控帧率与每帧耗时
 */
private fun monitorFrameRate() {
    val choreographer = Choreographer.getInstance()
    choreographer.postFrameCallback(object : Choreographer.FrameCallback {
        override fun doFrame(frameTimeNanos: Long) {
            // frameTimeNanos：当前帧的 VSYNC 信号时间戳（纳秒）
            if (lastFrameTimeNanos != 0L) {
                // 计算两帧之间的耗时（毫秒）
                val frameCostMs = (frameTimeNanos - lastFrameTimeNanos) / 1_000_000.0
                // 计算帧率（理论值，实际需平滑处理）
                val frameRate = 1000.0 / frameCostMs
                
                // 打印日志：每帧耗时与帧率
                android.util.Log.d("ChoreographerDemo", "每帧耗时：${String.format("%.2f", frameCostMs)}ms，帧率：${String.format("%.0f", frameRate)}fps")
                
                // 判定卡顿：若每帧耗时 > 16.67ms（60Hz 屏幕），则视为掉帧/卡顿
                if (frameCostMs > 16.67) {
                    android.util.Log.w("ChoreographerDemo", "出现卡顿，当前帧耗时：${String.format("%.2f", frameCostMs)}ms")
                }
            }
            
            // 更新上一帧的时间戳
            lastFrameTimeNanos = frameTimeNanos
            
            // 重新注册回调，实现持续监控（取消监控可停止调用此方法）
            choreographer.postFrameCallback(this)
        }
    })
}

// 提交任务到 ANIMATION 队列，与动画任务同步执行
Choreographer.getInstance().postCallback(
    Choreographer.CALLBACK_ANIMATION, // 任务队列类型
    Runnable {
        // 自定义任务：如更新动画相关数据
        android.util.Log.d("ChoreographerDemo", "执行动画队列自定义任务")
    },
    null // 额外参数，可传递任务相关数据
)

// 取消帧回调监控
choreographer.removeFrameCallback(frameCallbackInstance)

import android.os.Bundle
import android.view.Choreographer
import androidx.appcompat.app.AppCompatActivity
import java.util.concurrent.TimeUnit

class VSyncMonitorActivity : AppCompatActivity() {
    // 1. 声明 Choreographer 实例和 FrameCallback 实例（便于后续取消监听）
    private lateinit var choreographer: Choreographer
    private val frameCallback = object : Choreographer.FrameCallback {
        // 上一帧 VSYNC 时间戳（纳秒），用于计算帧间隔
        private var lastVsyncTimeNanos: Long = 0

        /**
         * VSYNC 信号到达时触发此方法（每帧回调一次）
         * @param frameTimeNanos 当前帧 VSYNC 信号的时间戳（纳秒），对应 VSYNC 信号触发时刻
         */
        override fun doFrame(frameTimeNanos: Long) {
            // 处理 VSYNC 信号（此处可执行与帧同步的任务）
            handleVsyncSignal(frameTimeNanos)

            // 【关键】若需要持续监听 VSYNC 信号，需重新注册回调（单次回调仅触发一次）
            // 取消持续监听：注释此行，或调用 choreographer.removeFrameCallback(this)
            choreographer.postFrameCallback(this)
        }

        /**
         * 处理 VSYNC 信号（解析时间戳、计算帧间隔/帧率）
         */
        private fun handleVsyncSignal(currentVsyncNanos: Long) {
            if (lastVsyncTimeNanos != 0L) {
                // 1. 计算两帧 VSYNC 信号的间隔（毫秒），即帧耗时
                val frameIntervalMs = TimeUnit.NANOSECONDS.toMillis(currentVsyncNanos - lastVsyncTimeNanos)
                
                // 2. 计算当前帧率（理论值，实际场景需平滑处理）
                val frameRate = if (frameIntervalMs > 0) 1000.0 / frameIntervalMs else 0.0
                
                // 3. 打印 VSYNC 相关信息（间接获取到 VSYNC 信号的触发结果）
                println("VSYNC 信号触发：帧间隔 = $frameIntervalMs ms，帧率 = %.2f fps".format(frameRate))
            }

            // 更新上一帧 VSYNC 时间戳
            lastVsyncTimeNanos = currentVsyncNanos
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 2. 获取主线程对应的 Choreographer 实例（UI 渲染的 VSYNC 信号对应主线程实例）
        choreographer = Choreographer.getInstance()
    }

    override fun onResume() {
        super.onResume()
        // 3. 注册 FrameCallback，开始监听 VSYNC 信号（页面可见时开启）
        choreographer.postFrameCallback(frameCallback)
    }

    override fun onPause() {
        super.onPause()
        // 4. 取消 FrameCallback，停止监听 VSYNC 信号（页面不可见时关闭，避免资源浪费）
        choreographer.removeFrameCallback(frameCallback)
    }
}

// 在 Activity/Fragment 或自定义 View 中调用
private fun postTaskWithVsync() {
    val choreographer = Choreographer.getInstance()
    
    // 提交任务到 ANIMATION 队列（与动画任务同步，优先级仅次于输入事件）
    choreographer.postCallback(
        Choreographer.CALLBACK_ANIMATION, // 任务队列类型（对应 VSYNC 调度的任务优先级）
        Runnable {
            // 自定义任务：与 VSYNC 信号同步执行，保证任务与帧渲染时序对齐
            println("自定义任务与 VSYNC 信号同步执行")
        },
        null // 额外参数，可传递任务相关数据（无需时传 null）
    )
}

import android.view.Choreographer
import java.util.concurrent.TimeUnit

class VSyncMonitor private constructor() {
    private lateinit var choreographer: Choreographer
    private var lastVsyncTimeNanos: Long = 0
    private var onVsyncListener: OnVsyncListener? = null
    private val frameCallback = Choreographer.FrameCallback { currentNanos ->
        onVsyncListener?.let { listener ->
            if (lastVsyncTimeNanos != 0L) {
                val frameIntervalMs = TimeUnit.NANOSECONDS.toMillis(currentNanos - lastVsyncTimeNanos)
                val frameRate = 1000.0 / frameIntervalMs
                // 分发 VSYNC 回调结果
                listener.onVsyncTriggered(frameIntervalMs, frameRate)
            }
            lastVsyncTimeNanos = currentNanos
        }
        // 持续监听
        if (onVsyncListener != null) {
            choreographer.postFrameCallback(frameCallback)
        }
    }

    /**
     * 开启 VSYNC 监听
     */
    fun startListening(listener: OnVsyncListener) {
        choreographer = Choreographer.getInstance()
        onVsyncListener = listener
        choreographer.postFrameCallback(frameCallback)
    }

    /**
     * 停止 VSYNC 监听
     */
    fun stopListening() {
        choreographer.removeFrameCallback(frameCallback)
        onVsyncListener = null
        lastVsyncTimeNanos = 0
    }

    /**
     * VSYNC 监听回调接口
     */
    interface OnVsyncListener {
        /**
         * VSYNC 信号触发回调
         * @param frameIntervalMs 帧间隔时间（毫秒）
         * @param frameRate 当前帧率（fps）
         */
        fun onVsyncTriggered(frameIntervalMs: Long, frameRate: Double)
    }

    companion object {
        val instance: VSyncMonitor by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            VSyncMonitor()
        }
    }
}

// 开启 VSYNC 监听
VSyncMonitor.instance.startListening(object : VSyncMonitor.OnVsyncListener {
    override fun onVsyncTriggered(frameIntervalMs: Long, frameRate: Double) {
        println("VSYNC 回调：帧间隔 = $frameIntervalMs ms，帧率 = %.2f fps".format(frameRate))
    }
})

// 停止 VSYNC 监听（如页面销毁时）
VSyncMonitor.instance.stopListening()

// 获取当前线程对应的 Choreographer 实例（主线程调用即为 UI 渲染核心实例）
val choreographer = Choreographer.getInstance()

import android.os.Bundle
import android.view.Choreographer
import androidx.appcompat.app.AppCompatActivity
import java.util.concurrent.TimeUnit

class ChoreographerFrameMonitorActivity : AppCompatActivity() {
    // 1. 声明 Choreographer 与 FrameCallback 实例（便于后续取消监听）
    private lateinit var choreographer: Choreographer
    private var lastFrameTimeNanos: Long = 0 // 上一帧 VSYNC 时间戳（纳秒）
    private val frameCallback = object : Choreographer.FrameCallback {
        override fun doFrame(currentFrameTimeNanos: Long) {
            // 此方法在 VSYNC 信号触发时调用，对应每帧渲染的开始
            analyzeFramePerformance(currentFrameTimeNanos)

            // 【关键】持续监听：重新注册回调（单次回调可注释此行）
            choreographer.postFrameCallback(this)
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 2. 获取主线程 Choreographer 实例
        choreographer = Choreographer.getInstance()
    }

    override fun onResume() {
        super.onResume()
        // 3. 开启帧监听（页面可见时启动）
        startFrameMonitor()
    }

    override fun onPause() {
        super.onPause()
        // 4. 停止帧监听（页面不可见时关闭，避免资源浪费）
        stopFrameMonitor()
    }

    /**
     * 开启帧性能监控
     */
    private fun startFrameMonitor() {
        lastFrameTimeNanos = 0
        // 注册帧回调，下次 VSYNC 信号触发时执行 doFrame()
        choreographer.postFrameCallback(frameCallback)
    }

    /**
     * 停止帧性能监控
     */
    private fun stopFrameMonitor() {
        // 移除帧回调，终止监听
        choreographer.removeFrameCallback(frameCallback)
    }

    /**
     * 分析帧性能：计算帧间隔、帧率，判定卡顿
     */
    private fun analyzeFramePerformance(currentFrameTimeNanos: Long) {
        if (lastFrameTimeNanos == 0L) {
            // 第一帧仅初始化时间戳，不做计算
            lastFrameTimeNanos = currentFrameTimeNanos
            return
        }

        // 1. 计算帧间隔（两帧 VSYNC 信号的时间差，单位：毫秒）
        val frameIntervalMs = TimeUnit.NANOSECONDS.toMillis(currentFrameTimeNanos - lastFrameTimeNanos)

        // 2. 计算当前帧率（fps，每秒渲染帧数）
        val frameRate = if (frameIntervalMs > 0) 1000.0 / frameIntervalMs else 0.0

        // 3. 判定卡顿：60Hz 屏幕帧间隔 > 16.67ms，120Hz 屏幕 > 8.33ms
        val isJank = frameIntervalMs > 16.67 // 兼容主流 60Hz 屏幕，高刷可调整阈值

        // 4. 打印性能日志
        val logMsg = "帧间隔：%.2f ms | 帧率：%.1f fps | 卡顿：%b".format(
            frameIntervalMs, frameRate, isJank
        )
        if (isJank) {
            android.util.Log.w("ChoreographerDemo", "【卡顿预警】$logMsg")
        } else {
            android.util.Log.d("ChoreographerDemo", logMsg)
        }

        // 更新上一帧时间戳
        lastFrameTimeNanos = currentFrameTimeNanos
    }
}

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

class ChoreographerTaskSubmitActivity : AppCompatActivity() {
    private lateinit var choreographer: Choreographer

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        choreographer = Choreographer.getInstance()

        // 提交自定义任务到不同队列
        submitTaskToAnimationQueue()
        submitTaskToTraversalQueue()
    }

    /**
     * 提交任务到 ANIMATION 队列（与动画同步执行）
     */
    private fun submitTaskToAnimationQueue() {
        choreographer.postCallback(
            Choreographer.CALLBACK_ANIMATION, // 队列类型
            Runnable {
                // 自定义动画相关任务：如更新动画参数、刷新自定义 View 动画状态
                android.util.Log.d("ChoreographerDemo", "执行动画队列任务：与 VSYNC 同步执行")
            },
            null // 额外参数（无需时传 null，可通过 `Choreographer.removeCallbacks()` 移除）
        )
    }

    /**
     * 提交任务到 TRAVERSAL 队列（与 View 渲染同步执行）
     */
    private fun submitTaskToTraversalQueue() {
        choreographer.postCallback(
            Choreographer.CALLBACK_TRAVERSAL,
            Runnable {
                // 自定义 UI 相关任务：如更新 View 数据、触发轻量刷新
                android.util.Log.d("ChoreographerDemo", "执行遍历队列任务：与 View measure/layout/draw 同步")
            },
            null
        )
    }

    /**
     * 可选：提交延迟执行的任务（与 VSYNC 信号对齐，延迟指定时间）
     */
    private fun submitDelayedTask() {
        choreographer.postCallbackDelayed(
            Choreographer.CALLBACK_COMMIT,
            Runnable {
                android.util.Log.d("ChoreographerDemo", "执行延迟任务：延迟 1000ms 且与 VSYNC 同步")
            },
            null,
            1000 // 延迟时间（毫秒）
        )
    }
}

import android.content.Context
import android.graphics.Canvas
import android.view.Choreographer
import android.view.View

class OptimizedCustomView(context: Context) : View(context), Choreographer.FrameCallback {
    private val choreographer = Choreographer.getInstance()
    private var progress: Float = 0f // 自定义渲染进度

    /**
     * 触发自定义 View 刷新（替代直接调用 invalidate()）
     */
    fun refreshView() {
        // 注册帧回调，下一次 VSYNC 信号触发时执行 doFrame()，再触发绘制
        choreographer.postFrameCallback(this)
    }

    override fun doFrame(frameTimeNanos: Long) {
        // 1. 更新渲染数据
        progress += 0.01f
        if (progress > 1f) progress = 0f

        // 2. 触发 View 绘制（仅执行一次绘制，避免频繁刷新）
        invalidate()

        // 3. 如需持续刷新（如动画），重新注册回调；否则注释此行
        choreographer.postFrameCallback(this)
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        // 4. 执行自定义绘制逻辑（使用 progress 变量）
        canvas.drawText("渲染进度：%.2f".format(progress), 50f, 100f, paint)
    }

    // 简化：初始化画笔
    private val paint by lazy {
        android.graphics.Paint().apply {
            textSize = 30f
            color = android.graphics.Color.BLACK
        }
    }

    /**
     * 销毁 View 时释放资源
     */
    fun onViewDestroy() {
        choreographer.removeFrameCallback(this)
    }
}