[Android 从零到一] Handler 与 Looper 消息机制

class MainActivity : AppCompatActivity() {

    // ① 声明 Handler —— 绑定当前线程的 Looper
    //    在主线程 new → 收到来自主线程的消息
    private val handler = Handler(Looper.getMainLooper())

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

        findViewById<Button>(R.id.btnDelay).setOnClickListener {
            // ② 发一条延时消息到主线程
            handler.postDelayed({
                // 这段代码会在 2000ms 后回到主线程执行
                Toast.makeText(this, "延时完成！", Toast.LENGTH_SHORT).show()
            }, 2000)
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        // ③ 销毁前清理，防止内存泄漏
        handler.removeCallbacksAndMessages(null)
    }
}

// WorkerThread —— 自带 Looper 的后台线程
class WorkerThread : Thread() {

    private lateinit var looper: Looper
    lateinit var handler: Handler

    override fun run() {
        // ④ 为当前线程准备 Looper
        Looper.prepare()
        looper = Looper.myLooper()!!
        handler = Handler(looper) { msg ->
            // ⑤ 在这里处理消息
            when (msg.what) {
                1 -> println("收到任务: ${msg.obj}")
                2 -> println("下载进度: ${msg.arg1}%")
            }
            true // 表示已处理
        }
        // ⑥ 开启消息循环 —— 这是一个死循环！
        Looper.loop()
    }

    fun quit() {
        looper.quit() // 优雅退出循环
    }
}

// 使用方式
val worker = WorkerThread().apply { start() }

// 从任意线程发消息给工作线程
worker.handler.sendMessage(Message.obtain().apply {
    what = 1
    obj = "拉取数据"
})

// 用完记得关掉
worker.quit()

import kotlinx.coroutines.*

btnDownload.setOnClickListener {
    lifecycleScope.launch { // 自动绑定生命周期
        launch(Dispatchers.IO) {
            // 模拟耗时操作
            delay(2000)
            val result = downloadData()
            // 切回主线程更新 UI
            withContext(Dispatchers.Main) {
                textView.text = result
            }
        }
    }
}

MessageQueue → Message → Message.target (Handler) → Handler.this$0 (Activity)

// ❌ 匿名内部类 —— 隐式持有外部类引用
private val leakyHandler = object : Handler() {
    override fun handleMessage(msg: Message) { ... }
}

// ✅ 方法 1：静态类 + WeakReference
class SafeHandler(activity: Activity) : Handler(
    WeakReference(activity).get()?.application?.mainExecutor
) {
    companion object {
        private class Ref(val activity: MainActivity) : WeakReference<MainActivity>(activity)
    }
    
    override fun handleMessage(msg: Message) {
        // 先检查 Activity 是否存活
    }
}

// ✅ 方法 2：用 removeCallbacksAndMessages 清理
override fun onDestroy() {
    handler.removeCallbacksAndMessages(null) // null = 移除所有消息和回调
}

// ❌ 在非主线程多次调用 prepare() —— 抛异常！
Looper.prepare()
Looper.prepare() // RuntimeException: Only one Looper may be created per thread

// ❌ Looper.loop() 是死循环，在它之后写的代码永远不会执行
Looper.loop()
Toast.makeText(this, "永远不会弹", Toast.SHORT).show()

// ✅ 如果要等某个操作完成再继续，用同步屏障或 countDownLatch