非组件类与Android Activity通信：替代静态回调的方案咨询

我希望在非Android组件类中监听Activity的销毁事件（即onDestroy()方法被调用时）。目前用伴生对象设置静态函数回调的方式虽然能工作，但想找更优、规范的实现。试过Activity Result API，发现只适用于Activity间通信；也考虑过把回调传入Intent，但需要序列化非组件类，当前项目不可行。

当前实现代码：

Activity类代码 #

class MyActivity : AppCompatActivity() {

    companion object {
         lateinit var onActivityDestroyedListener: () -> Unit
    }


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // onCreate中的其他代码
    }


    override fun onDestroy() {
        // 触发监听事件
        onActivityDestroyedListener()
        super.onDestroy()
    }
}

非组件类代码 #

class MyNonComponentClass(private val context: Context) {

    fun startMyActivity() {
        MyActivity.onActivityDestroyedListener = {
            // Activity销毁时执行的逻辑
        }

        val intent = Intent(context, MyActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_ANIMATION
        }
        context.startActivity(intent)
    }

}

请问有没有不使用静态回调的更好实现方式？

方案1：LiveData + ViewModel（推荐） #

利用Android架构组件的LiveData传递事件，ViewModel持有LiveData实例，非组件类观察该LiveData。这种方式天然避免内存泄漏，符合Jetpack规范。

ViewModel代码

class MyActivityViewModel : ViewModel() {
    private val _destroyEvent = MutableLiveData<Unit>()
    val destroyEvent: LiveData<Unit> = _destroyEvent

    fun sendDestroyEvent() {
        _destroyEvent.value = Unit
    }
}

Activity代码

class MyActivity : AppCompatActivity() {
    private val viewModel by viewModels<MyActivityViewModel>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 其他初始化代码
    }

    override fun onDestroy() {
        viewModel.sendDestroyEvent()
        super.onDestroy()
    }
}

非组件类代码

class MyNonComponentClass(private val context: Context) {

    fun startMyActivity() {
        val intent = Intent(context, MyActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_ANIMATION
        }
        context.startActivity(intent)

        // 监听Activity销毁事件
        (context as? ViewModelStoreOwner)?.let { owner ->
            val viewModel = ViewModelProvider(owner)[MyActivityViewModel::class.java]
            viewModel.destroyEvent.observe(owner) {
                // Activity销毁时执行的逻辑
            }
        }
    }
}

方案2：LocalBroadcastManager广播 #

通过本地广播发送销毁事件，非组件类注册接收器监听，适合简单场景。

Activity代码

class MyActivity : AppCompatActivity() {
    companion object {
        const val ACTION_ACTIVITY_DESTROYED = "com.example.ACTION_ACTIVITY_DESTROYED"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 其他初始化代码
    }

    override fun onDestroy() {
        val intent = Intent(ACTION_ACTIVITY_DESTROYED)
        LocalBroadcastManager.getInstance(this).sendBroadcast(intent)
        super.onDestroy()
    }
}

非组件类代码

class MyNonComponentClass(private val context: Context) {
    private lateinit var receiver: BroadcastReceiver

    fun startMyActivity() {
        // 注册广播接收器
        receiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent?) {
                if (intent?.action == MyActivity.ACTION_ACTIVITY_DESTROYED) {
                    // Activity销毁时执行的逻辑
                    // 执行后立即注销接收器，避免内存泄漏
                    LocalBroadcastManager.getInstance(context!!).unregisterReceiver(this)
                }
            }
        }
        LocalBroadcastManager.getInstance(context).registerReceiver(
            receiver,
            IntentFilter(MyActivity.ACTION_ACTIVITY_DESTROYED)
        )

        val intent = Intent(context, MyActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_ANIMATION
        }
        context.startActivity(intent)
    }
}

方案3：自定义接口 + 弱引用 #

定义回调接口，Activity持有接口的弱引用实例，避免内存泄漏，适合轻量场景。

自定义回调接口

interface OnActivityDestroyedListener {
    fun onDestroyed()
}

Activity代码

class MyActivity : AppCompatActivity() {
    private var destroyListener: WeakReference<OnActivityDestroyedListener>? = null

    fun setOnDestroyedListener(listener: OnActivityDestroyedListener) {
        destroyListener = WeakReference(listener)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 其他初始化代码
    }

    override fun onDestroy() {
        destroyListener?.get()?.onDestroyed()
        destroyListener = null
        super.onDestroy()
    }
}

非组件类代码

class MyNonComponentClass(private val context: Context) : OnActivityDestroyedListener {

    fun startMyActivity() {
        val intent = Intent(context, MyActivity::class.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_NO_ANIMATION
        }

        // 通过Application生命周期回调获取Activity实例并设置监听
        (context.applicationContext as Application).registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
                if (activity is MyActivity) {
                    activity.setOnDestroyedListener(this@MyNonComponentClass)
                    (context.applicationContext as Application).unregisterActivityLifecycleCallbacks(this)
                }
            }

            override fun onActivityStarted(activity: Activity) {}
            override fun onActivityResumed(activity: Activity) {}
            override fun onActivityPaused(activity: Activity) {}
            override fun onActivityStopped(activity: Activity) {}
            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
            override fun onActivityDestroyed(activity: Activity) {}
        })

        context.startActivity(intent)
    }

    override fun onDestroyed() {
        // Activity销毁时执行的逻辑
    }
}

内容的提问来源于stack exchange，提问作者FP34024