Android中共享ViewModel仅让当前可见Fragment接收事件的实现方案

方案1：在观察者中直接判断Fragment可见性 #

最简单的实现方式，无需修改ViewModel逻辑，直接在Fragment的事件回调里校验自身可见状态，仅当可见时处理事件。

示例代码：

// 目标Fragment内
viewModel.sharedEvent.observe(viewLifecycleOwner) { event ->
    // 同时校验resumed状态与可见性，确保Fragment处于前台交互状态
    if (isResumed && isVisible) {
        // 执行事件处理逻辑
        handleEvent(event)
    }
}

注：isResumed保证Fragment处于可交互的前台状态，isVisible确保Fragment的UI实际可见，两者结合可彻底过滤回退栈中不可见Fragment的事件触发。

方案2：基于Fragment生命周期动态管理订阅 #

在Fragment进入前台（onResume）时订阅事件，退到后台（onPause）时取消订阅，确保只有当前可见的Fragment持有活跃观察者。

示例代码：

// 目标Fragment内
private var eventObserver: Observer<Event>? = null

override fun onResume() {
    super.onResume()
    eventObserver = Observer { event ->
        handleEvent(event)
    }
    viewModel.sharedEvent.observe(viewLifecycleOwner, eventObserver!!)
}

override fun onPause() {
    super.onPause()
    eventObserver?.let {
        viewModel.sharedEvent.removeObserver(it)
    }
    eventObserver = null
}

适合使用非粘性事件（如SingleLiveEvent或自定义一次性事件类）的场景；若使用粘性LiveData，重新订阅时可能收到旧事件，需额外处理事件消费状态。

方案3：自定义可见性感知的LiveData #

从ViewModel层控制事件分发，创建仅向RESUMED状态的LifecycleOwner发送事件的自定义LiveData，无需在Fragment中额外判断。

示例代码：

// 自定义LiveData类
class VisibleOnlyLiveData<T> : MutableLiveData<T>() {
    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
        super.observe(owner) { data ->
            // 仅当宿主处于RESUMED状态时通知观察者
            if (owner.lifecycle.currentState == Lifecycle.State.RESUMED) {
                observer.onChanged(data)
            }
        }
    }
}

// 在Shared ViewModel中使用
val sharedEvent = VisibleOnlyLiveData<Event>()

适合多Fragment共享同一事件流的场景，ViewModel层自动完成过滤，Fragment侧无需额外逻辑。

方案4：结合一次性事件的消费标记 #

给事件添加消费状态标记，确保事件仅被当前可见的Fragment消费一次，避免重复处理。

示例代码：

// 定义一次性事件类
open class OneTimeEvent<out T>(private val content: T) {
    var hasBeenHandled = false
        private set

    // 获取未被处理的事件内容，标记为已处理
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    // 仅查看事件内容，不标记为已处理
    fun peekContent(): T = content
}

// 目标Fragment内处理事件
viewModel.sharedEvent.observe(viewLifecycleOwner) { event ->
    if (isResumed && isVisible) {
        event.getContentIfNotHandled()?.let {
            handleEvent(it)
        }
    }
}

既保证事件仅被消费一次，又通过可见性判断锁定消费方，适合需要严格控制事件触发范围的场景。

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