object LiveDataBus {
    // 存儲(chǔ)不同事件通道的Map
    private val bus = mutableMapOf<String, BusMutableLiveData<Any>>()
    // 根據(jù)事件名稱獲取LiveData通道
    @Synchronized
    fun <T> with(eventName: String, type: Class<T>): BusMutableLiveData<T> {
        if (!bus.containsKey(eventName)) {
            bus[eventName] = BusMutableLiveData()
        }
        return bus[eventName] as BusMutableLiveData<T>
    }
    // 自定義LiveData，支持粘性開關(guān)
    class BusMutableLiveData<T> : MutableLiveData<T>() {
        var isSticky = false // 是否為粘性事件
        override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
            super.observe(owner, observer)
            // 非粘性事件需要移除歷史數(shù)據(jù)
            if (!isSticky) {
                hook(observer)
            }
        }
        // 反射移除粘性數(shù)據(jù)
        private fun hook(observer: Observer<in T>) {
            try {
                val liveDataClass = LiveData::class.java
                val mObserversField = liveDataClass.getDeclaredField("mObservers")
                mObserversField.isAccessible = true
                val mObservers = mObserversField[this] as Map<*, *>
                val observerWrapper = mObservers.entries.find {
                    it.value?.javaClass?.superclass?.name == "androidx.lifecycle.ObserverWrapper"
                }?.value
                if (observerWrapper != null) {
                    val observerWrapperClass = observerWrapper.javaClass.superclass
                    val mLastVersionField = observerWrapperClass?.getDeclaredField("mLastVersion")
                    mLastVersionField?.isAccessible = true
                    val mVersionField = liveDataClass.getDeclaredField("mVersion")
                    mVersionField.isAccessible = true
                    val mVersion = mVersionField[this]
                    mLastVersionField?.set(observerWrapper, mVersion)
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
}

// 發(fā)送普通事件
fun <T> String.postEvent(value: T) {
    LiveDataBus.with(this, value!!::class.java).postValue(value)
}
// 發(fā)送粘性事件
fun <T> String.postStickyEvent(value: T) {
    val liveData = LiveDataBus.with(this, value!!::class.java)
    liveData.isSticky = true
    liveData.postValue(value)
}
// 觀察事件
inline fun <reified T> String.observeEvent(owner: LifecycleOwner, crossinline observer: (T) -> Unit) {
    LiveDataBus.with(this, T::class.java).observe(owner) {
        it?.let(observer)
    }
}

// 普通事件
"login_success".postEvent("用戶ID:123456")
// 粘性事件
"app_start".postStickyEvent("應(yīng)用啟動(dòng)參數(shù)")
// 復(fù)雜對象
data class UserEvent(val id: Int, val name: String)
"user_update".postEvent(UserEvent(1, "張三"))

// 在Activity/Fragment中
"login_success".observeEvent<String>(this) { userId ->
    Log.d("LiveDataBus", "登錄成功：$userId")
}
// 觀察復(fù)雜對象
"user_update".observeEvent<UserEvent>(this) { event ->
    tvName.text = event.name
}

// 接收粘性事件（即使事件發(fā)送在注冊之前也能收到）
"app_start".observeEvent<String>(this) { params ->
    // 處理應(yīng)用啟動(dòng)參數(shù)
}

// 在ViewModel中觀察（生命周期與ViewModel綁定）
viewModelScope.launch {
    "data_refresh".observeEvent<String>(viewModelOwner) {
        // 更新數(shù)據(jù)
    }
}

// 模塊A發(fā)送
"module_message".postEvent("來自模塊A的消息")
// 模塊B接收
"module_message".observeEvent<String>(this) { message ->
    // 跨模塊通信
}

// 保存觀察者引用
val observer = Observer<String> { /* 處理 */ }
LiveDataBus.with("test", String::class.java).observe(this, observer)
// 取消觀察
LiveDataBus.with("test", String::class.java).removeObserver(observer)