如何实现Activity与Fragment间的生命周期感知通信？

针对你遇到的Fragment到Activity通信的生命周期安全问题，以下几种方案可以替代共享ViewModel和setFragmentResult，同时避免冗余或结果泄露的问题：

1. 基于Flow/StateFlow的生命周期感知通信 #

利用Kotlin Flow结合Activity的生命周期感知，确保只有Activity处于活跃状态时才处理更新事件：

• 在Activity中定义一个用于接收更新的MutableSharedFlow，并通过repeatOnLifecycle限定只在前台活跃状态（STARTED及以上）收集事件：

  class MainActivity : AppCompatActivity() {
      private val modelUpdateFlow = MutableSharedFlow<YourModel>()
  
      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
              modelUpdateFlow.collect { updatedModel ->
                  // 此时Activity处于活跃状态，可安全更新UI/加载图片
                  loadImageWithSafeContext(updatedModel.imageUrl)
              }
          }
      }
  
      // 提供给Fragment的发送方法
      suspend fun sendUpdatedModel(model: YourModel) {
          modelUpdateFlow.emit(model)
      }
  }
  

• 在Fragment的onDestroyView中，先检查Activity的生命周期状态，再发送更新：

  override fun onDestroyView() {
      super.onDestroyView()
      val activity = activity as? MainActivity ?: return
      if (activity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
          lifecycleScope.launch {
              activity.sendUpdatedModel(yourUpdatedModel)
          }
      }
  }
  

  这种方式只会在Activity活跃时处理事件，完全避免销毁状态下的上下文调用，且通信仅在当前Fragment和对应Activity之间，不会泄露给其他Fragment。

2. 自定义Activity Result Contract #

借助Android原生的Activity Result API，通过自定义Contract实现Fragment到Activity的定向、生命周期安全通信：

• 定义一个自定义Contract，用于传递更新后的模型：

  class UpdateModelContract : ActivityResultContract<YourModel, Unit>() {
      override fun createIntent(context: Context, input: YourModel): Intent {
          return Intent().apply {
              putExtra("KEY_UPDATED_MODEL", input) // 假设YourModel是Parcelable
          }
      }
  
      override fun parseResult(resultCode: Int, intent: Intent?) {
          intent?.getParcelableExtra<YourModel>("KEY_UPDATED_MODEL")?.let {
              // 在Activity中处理模型更新
              loadImageWithSafeContext(it.imageUrl)
          }
      }
  }
  

• 在Activity中注册这个Contract的Launcher：

  class MainActivity : AppCompatActivity() {
      val updateModelLauncher = registerForActivityResult(UpdateModelContract()) {}
  }
  

• 在Fragment的onDestroyView中调用Launcher发送模型：

  override fun onDestroyView() {
      super.onDestroyView()
      (activity as? MainActivity)?.updateModelLauncher?.launch(yourUpdatedModel)
  }
  

  Activity Result API会自动处理Activity的生命周期状态，当Activity销毁时不会触发回调，且通信链路仅在当前Fragment和注册Launcher的Activity之间。

3. 接口+WeakReference+生命周期检查 #

如果你希望保留原有的接口通信模式，可以通过WeakReference避免内存泄漏，并在发送前检查Activity的生命周期：

• 定义通信接口，并在Fragment中用WeakReference持有Activity实例：

  class YourFragment : Fragment() {
      interface OnModelUpdatedListener {
          fun onModelUpdated(model: YourModel)
      }
  
      private var listenerRef: WeakReference<OnModelUpdatedListener>? = null
  
      override fun onAttach(context: Context) {
          super.onAttach(context)
          listenerRef = WeakReference(context as? OnModelUpdatedListener)
      }
  
      override fun onDestroyView() {
          super.onDestroyView()
          listenerRef?.get()?.let { listener ->
              val activity = listener as AppCompatActivity
              // 仅当Activity处于活跃状态时才发送更新
              if (activity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
                  listener.onModelUpdated(yourUpdatedModel)
              }
          }
      }
  }
  

• 让Activity实现该接口，并在实现方法中安全处理UI更新：

  class MainActivity : AppCompatActivity(), YourFragment.OnModelUpdatedListener {
      override fun onModelUpdated(model: YourModel) {
          // 此时Activity处于活跃状态，可安全加载图片
          loadImageWithSafeContext(model.imageUrl)
      }
  }
  

  这种方式改动最小，既兼容原有代码结构，又通过生命周期检查避免了销毁状态下的崩溃问题。

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