#

Author: czy1121

README.md

@@ -3,32 +3,36 @@
 事件总线(基于SharedFlow)
 
 - 支持生命周期感知
-- 支持自动清除空闲事件 
+- 支持自动清除空闲事件
 
 
 ## 观察
 
 ```kotlin
 
 /**
- * 观察流，进入 [minState] 时开始，脱离 [minState] 时停止
+ * 订阅事件(EventFlow)或状态(StateFlow)
  *
- * - 对于 [StateFlow]，每次进入 [minState] 都会观察一次当前值
- * - 对于 [EventFlow]，只能收到进入 [minState] 后发射的值
- * */
+ * - 对于 [EventFlow]，进入 [minState] 开始订阅，脱离 [minState] 取消订阅
+ * - 对于 [StateFlow]，满足 [minState] 时立刻消费，不足 [minState] 时缓存最近的事件待再次进入时消费
+ *
+ */
 fun <T> Flow<T>.observe(owner: LifecycleOwner, minState: Lifecycle.State = Lifecycle.State.STARTED, action: suspend (T) -> Unit)
 
+
 /**
- * 观察流，脱离 [minState] 后会保存最近产生的值，再次进入 [minState] 时消费
+ * 订阅事件，满足 [minState] 时立刻消费，不足 [minState] 时缓存最近的事件待再次进入时消费
  *
- * - 对于 [StateFlow]，没啥用，效果与 [observe] 没区别
- * - 对于 [EventFlow]，每次进入 [minState] 时能收到并消费最近产生的值(如果有)
- * 
- * [EventFlow] 场景：在A页订阅事件，然后进入B页发送了事件，但想回到A页时再处理，可用此方法
- * */
+ * 示例：在A页观察流，然后进入B页发送了事件，回到A页消费事件
+ */
 fun <T> Flow<T>.observeLatest(owner: LifecycleOwner, minState: Lifecycle.State = Lifecycle.State.STARTED, action: suspend (T) -> Unit)
+
+
+/**
+ * 进入 [minState] 开始订阅，脱离 [minState] 取消订阅
+ * */
+fun <T> Flow<T>.observeRepeat(owner: LifecycleOwner, minState: Lifecycle.State = Lifecycle.State.STARTED, action: suspend (T) -> Unit)
 ```
- 
 
 ## EventBus 使用
 
@@ -68,7 +72,7 @@ repositories {
     maven { url "https://gitee.com/ezy/repo/raw/cosmo/"}
 }
 dependencies {
-    implementation "me.reezy.cosmo:flowbus:0.8.0"
+    implementation "me.reezy.cosmo:flowbus:0.9.0"
 }
 ```
 

flowbus/src/main/java/me/reezy/cosmo/flowbus/EventBus.kt

@@ -78,7 +78,7 @@ class EventBus : ViewModel() {
 
 
     fun <T> observe(eventClazz: Class<T>, owner: LifecycleOwner, eventName: String, minState: Lifecycle.State = Lifecycle.State.STARTED, action: (T) -> Unit) {
-        get<T>("$eventClazz:$eventName", owner).observe(owner, minState, action)
+        get<T>("$eventClazz:$eventName", owner).observeRepeat(owner, minState, action)
     }
 
     fun <T> observeLatest(eventClazz: Class<T>, owner: LifecycleOwner, eventName: String, minState: Lifecycle.State = Lifecycle.State.STARTED, action: (T) -> Unit) {

flowbus/src/main/java/me/reezy/cosmo/flowbus/utility.kt

@@ -2,40 +2,43 @@ package me.reezy.cosmo.flowbus
 
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.flowWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
 
 
 @Suppress("NOTHING_TO_INLINE", "FunctionName")
 inline fun <T> EventFlow() = MutableSharedFlow<T>(0, 1, BufferOverflow.DROP_OLDEST)
 
+
 /**
- * 观察流，进入 [minState] 时开始，脱离 [minState] 时停止
+ * 订阅事件(EventFlow)或状态(StateFlow)
  *
- * - 对于 [StateFlow]，每次进入 [minState] 都会观察一次当前值
- * - 对于 [EventFlow]，只能收到进入 [minState] 后发射的值
- * */
+ * - 对于 [EventFlow]，进入 [minState] 开始订阅，脱离 [minState] 取消订阅
+ * - 对于 [StateFlow]，满足 [minState] 时立刻消费，不足 [minState] 时缓存最近的事件待再次进入时消费
+ *
+ */
 fun <T> Flow<T>.observe(owner: LifecycleOwner, minState: Lifecycle.State = Lifecycle.State.STARTED, action: suspend (T) -> Unit) {
-    owner.lifecycleScope.launch {
-        owner.lifecycle.repeatOnLifecycle(minState) {
-            collect(action)
-        }
+    if (this is StateFlow) {
+        observeLatest(owner, minState, action)
+    } else {
+        observeRepeat(owner, minState, action)
     }
 }
 
 /**
- * 观察流，脱离 [minState] 后会保存最近产生的值，再次进入 [minState] 时消费
- *
- * - 对于 [StateFlow]，没啥用，效果与 [observe] 没区别
- * - 对于 [EventFlow]，每次进入 [minState] 时能收到并消费最近产生的值(如果有)
+ * 订阅事件，满足 [minState] 时立刻消费，不足 [minState] 时缓存最近的事件待再次进入时消费
  *
- * [EventFlow] 场景：在A页观察流，然后进入B页发送了事件，但想回到A页时再处理，可用此方法
- * */
+ * 示例：在A页观察流，然后进入B页发送了事件，回到A页消费事件
+ */
 fun <T> Flow<T>.observeLatest(owner: LifecycleOwner, minState: Lifecycle.State = Lifecycle.State.STARTED, action: suspend (T) -> Unit) {
     var data: T? = null
     owner.lifecycleScope.launch {
@@ -59,3 +62,15 @@ fun <T> Flow<T>.observeLatest(owner: LifecycleOwner, minState: Lifecycle.State =
 }
 
 
+/**
+ * 进入 [minState] 开始订阅，脱离 [minState] 取消订阅
+ * */
+fun <T> Flow<T>.observeRepeat(owner: LifecycleOwner, minState: Lifecycle.State = Lifecycle.State.STARTED, action: suspend (T) -> Unit) {
+    owner.lifecycleScope.launch {
+        owner.lifecycle.repeatOnLifecycle(minState) {
+            collect(action)
+        }
+    }
+}
+
+

gradle.properties

@@ -28,4 +28,4 @@ cosmoRepoPath=https://gitee.com/ezy/repo/raw/cosmo
 buildGradlePath=https://gitee.com/ezy/gradle/raw/cosmo
 
 LIBRARY_GROUP=me.reezy.cosmo
-LIBRARY_VERSION=0.8.0
+LIBRARY_VERSION=0.9.0