react-native-gizwits-sdk-v5 1.7.8-beta → 1.7.10-beta

package/android/build.gradle

@@ -82,4 +82,7 @@ dependencies {
     //ktor
     implementation "io.ktor:ktor-network:$ktor_network_version"
 
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$kotlin_coroutine_version"
+
 }

package/android/src/main/java/com/gizwits/reactnativegizwitssdkv5/DeviceListEventCoordinator.kt

@@ -0,0 +1,72 @@
+package com.gizwits.reactnativegizwitssdkv5
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+internal class ConflatedEventDispatcher(
+  scope: CoroutineScope,
+  private val windowMillis: Long,
+  private val dispatch: suspend () -> Unit,
+) {
+  private val requests = Channel<Unit>(Channel.CONFLATED)
+  private val worker = scope.launch {
+    for (request in requests) {
+      if (windowMillis > 0) {
+        delay(windowMillis)
+      }
+      while (requests.tryReceive().isSuccess) {
+        // Keep only the latest-state notification for this window.
+      }
+      dispatch()
+    }
+  }
+
+  init {
+    require(windowMillis >= 0) { "windowMillis must not be negative" }
+  }
+
+  internal fun request(): Boolean = requests.trySend(Unit).isSuccess
+
+  internal fun cancel() {
+    requests.close()
+    worker.cancel()
+  }
+}
+
+internal class KeyedSubscriptionRegistry<K, V>(
+  private val keySelector: (V) -> K,
+  private val subscribe: (V) -> Job,
+) {
+  private data class Subscription<V>(val value: V, val job: Job)
+
+  private val subscriptions = linkedMapOf<K, Subscription<V>>()
+
+  @Synchronized
+  internal fun update(values: Collection<V>) {
+    val valuesByKey = values.associateBy(keySelector)
+
+    (subscriptions.keys - valuesByKey.keys).forEach { key ->
+      subscriptions.remove(key)?.job?.cancel()
+    }
+
+    valuesByKey.forEach { (key, value) ->
+      val existing = subscriptions[key]
+      if (existing == null || !existing.job.isActive || existing.value !== value) {
+        existing?.job?.cancel()
+        subscriptions[key] = Subscription(value, subscribe(value))
+      }
+    }
+  }
+
+  @Synchronized
+  internal fun cancelAll() {
+    subscriptions.values.forEach { it.job.cancel() }
+    subscriptions.clear()
+  }
+
+  @Synchronized
+  internal fun keys(): Set<K> = subscriptions.keys.toSet()
+}

package/android/src/main/java/com/gizwits/reactnativegizwitssdkv5/RNGizDeviceManagerModule.kt

@@ -188,6 +188,17 @@ class RNGizDeviceManagerModule(reactContext: ReactApplicationContext) : ReactCon
 
   override fun getName() = "RNGizDeviceManagerModule"
 
+  /**
+   * NativeEventEmitter requires these lifecycle methods on Android. Device
+   * events are produced by SDK operations, so there is no native listener
+   * resource to allocate or release here.
+   */
+  @ReactMethod
+  fun addListener(eventName: String) = Unit
+
+  @ReactMethod
+  fun removeListeners(count: Int) = Unit
+
   override fun onCatalystInstanceDestroy() {
     super.onCatalystInstanceDestroy()
     moduleScope.cancel() // 取消所有协程

package/android/src/main/java/com/gizwits/reactnativegizwitssdkv5/RNGizSDKManagerModule.kt

@@ -28,20 +28,18 @@ import com.google.gson.annotations.SerializedName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.async
-import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.emptyFlow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapConcat
-import kotlinx.coroutines.flow.last
-import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.supervisorScope
 import org.json.JSONArray
 import org.json.JSONObject
 
@@ -62,15 +60,24 @@ data class GizFeedback(
 
 class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
+  private val moduleJob = SupervisorJob()
+  private val moduleScope = CoroutineScope(moduleJob + Dispatchers.IO)
+  @Volatile
+  private var latestDeviceList = emptyList<GizDevice>()
   private var mReactContext: ReactContext? = null
+  private val deviceListEventDispatcher = ConflatedEventDispatcher(
+    scope = moduleScope,
+    windowMillis = 500,
+    dispatch = ::emitDeviceListChange,
+  )
+  private val deviceSubscriptions = KeyedSubscriptionRegistry<String, GizDevice>(
+    keySelector = GizDevice::id,
+    subscribe = ::subscribeToDevice,
+  )
 
-  private var isSubscriptDevices: List<String> = listOf();
   init {
     mReactContext = reactContext
   }
-  companion object {
-    internal var devices = listOf<GizDevice>()
-  }
   enum class EventName(val value: String) {
     DeviceDataListener("DeviceDataListener"),
     DeviceListListener("DeviceListListener"),
@@ -107,6 +114,18 @@ class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContex
   }
 
   override fun getName() = "RNGizSDKManagerModule"
+
+  /**
+   * NativeEventEmitter requires these lifecycle methods on Android. SDK
+   * subscriptions are owned by this module's lifecycle rather than by each JS
+   * listener, so the methods intentionally do not start or stop subscriptions.
+   */
+  @ReactMethod
+  fun addListener(eventName: String) = Unit
+
+  @ReactMethod
+  fun removeListeners(count: Int) = Unit
+
   private val deviceListState: Flow<List<GizDevice>> =
     combineLatest(
       GizSDKManager.subscribeBoundDeviceList(),
@@ -120,7 +139,7 @@ class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContex
 
   override fun initialize() {
     super.initialize()
-    CoroutineScope(Dispatchers.IO).launch {
+    moduleScope.launch {
       GizSDKManager.subscribeBindEvent().collect {
         val data = JSONObject()
         data.put("did", it.first)
@@ -129,159 +148,141 @@ class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContex
       }
     }
 
-    // 监听设备对象
-    deviceListState
-      .debounce(500)
-      .flatMapConcat { deviceList ->
-        deviceList.map { dev ->
-
-          if (!isSubscriptDevices.contains(dev.mac)) {
-            CoroutineScope(Dispatchers.IO).launch {
-              async {
-                dev.bleCapability.subscribeModuleProfile().debounce(500).collect {
-                  if (it != null) {
-                    emitDeviceListChange()
-                  }
-                }
-              }
-              async {
-                combine(
-                  dev.bleCapability.subscribeStatus(),
-                  dev.bleCapability.subscribeIsLogin(),
-                ) { status, isLogin ->
-                  Pair(status, isLogin)
-                }.collect  {
-                  val data = JSONObject()
-                  data.put("state", it.first.toInt())
-                  data.put("isLogin", it.second)
-                  data.put("type", "BLE")
-                  data.put("device", dev.toJsonObject())
-                  sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
-                }
-              }
-              async {
-                dev.bleCapability.subscribeDp().collect{
-                  val data = JSONObject()
-                  data.put("data", JSONObject(it.toString()))
-                  data.put("type", "BLE")
-                  data.put("device", dev.toJsonObject())
-                  sendEvent(EventName.DeviceDataListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
-                }
-              }
-              async {
-                dev.lanCapability.subscribeModuleProfile().debounce(500).collectLatest{
-                  if (it != null) {
-                    emitDeviceListChange()
-                  }
-                }
-              }
-
-              async {
-                combineLatest(
-                  dev.lanCapability.subscribeStatus(),
-                  dev.lanCapability.subscribeIsLogin(),
-                ) { status, isLogin ->
-                  Pair(status, isLogin)
-                }.collectLatest {
-                  val data = JSONObject()
-                  data.put("state", it.first.toInt())
-                  data.put("isLogin", it.second)
-                  data.put("type", "LAN")
-                  data.put("device", dev.toJsonObject())
-                  sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
-                }
-              }
-
-              async {
-                dev.lanCapability.subscribeDp().collect{
-                  val data = JSONObject()
-                  data.put("data", JSONObject(it.toString()))
-                  data.put("type", "LAN")
-                  data.put("device", dev.toJsonObject())
-                  sendEvent(EventName.DeviceDataListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
-                }
-              }
-
-              async {
-                combineLatest(
-                  dev.mqttCapability.subscribeStatus(),
-                  dev.mqttCapability.subscribeIsLogin(),
-                ) { status, isLogin ->
-                  Pair(status, isLogin)
-                }.collectLatest  {
-                  val data = JSONObject()
-                  data.put("state", it.first.toInt())
-                  data.put("isLogin", it.second)
-                  data.put("type", "MQTT")
-                  data.put("device", dev.toJsonObject())
-                  sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
-                }
-              }
-
-              // 不会主动发生改表
-              //   async {
-              //     dev.mqttCapability.subscribeModuleProfile().debounce(500).collectLatest{
-              //         if (it != null) {
-              //             emitDeviceListChange()
-              //         }
-              //     }
-              //   }
-
-              async {
-                dev.mqttCapability.subscribeDp().collect{
-                  val data = JSONObject()
-                  data.put("data", JSONObject(it.toString()))
-                  data.put("type", "MQTT")
-                  data.put("device", dev.toJsonObject())
-                  sendEvent(EventName.DeviceDataListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
-                }
-              }
-            }
+    moduleScope.launch {
+      deviceListState
+        .distinctUntilChanged { previous, current ->
+          previous.size == current.size && previous.indices.all { index ->
+            previous[index].id == current[index].id && previous[index] === current[index]
           }
         }
-
-        /*
-        更新当前已经订阅的设备
-        如果设备消失，又出现，就可以正常的重新订阅
-         */
-        isSubscriptDevices = deviceList.map{
-            it.mac
+        .collect { deviceList ->
+          latestDeviceList = deviceList
+          deviceSubscriptions.update(deviceList)
+          requestDeviceListChange()
         }
+    }
+  }
 
-        emptyFlow<Unit>()
+  private fun subscribeToDevice(device: GizDevice) = moduleScope.launch {
+    supervisorScope {
+      launch {
+        device.bleCapability.subscribeModuleProfile()
+          .drop(1)
+          .filterNotNull()
+          .collect { requestDeviceListChange() }
       }
-      .launchIn(CoroutineScope(Dispatchers.IO))
-
-    // 推送设备列表变化
-    CoroutineScope(Dispatchers.IO).launch {
-      deviceListState.debounce(500).collectLatest { deviceList ->
-        devices = deviceList
-        emitDeviceListChange()
+      launch {
+        combine(
+          device.bleCapability.subscribeStatus(),
+          device.bleCapability.subscribeIsLogin(),
+        ) { status, isLogin -> Pair(status, isLogin) }
+          .collect { (status, isLogin) ->
+            val data = JSONObject()
+            data.put("state", status.toInt())
+            data.put("isLogin", isLogin)
+            data.put("type", "BLE")
+            data.put("device", device.toJsonObject())
+            sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+          }
+      }
+      launch {
+        device.bleCapability.subscribeDp().collect { payload ->
+          val data = JSONObject()
+          data.put("data", JSONObject(payload.toString()))
+          data.put("type", "BLE")
+          data.put("device", device.toJsonObject())
+          sendEvent(EventName.DeviceDataListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+        }
+      }
+      launch {
+        device.lanCapability.subscribeModuleProfile()
+          .drop(1)
+          .filterNotNull()
+          .collect { requestDeviceListChange() }
+      }
+      launch {
+        combineLatest(
+          device.lanCapability.subscribeStatus(),
+          device.lanCapability.subscribeIsLogin(),
+        ) { status, isLogin -> Pair(status, isLogin) }
+          .collect { (status, isLogin) ->
+            val data = JSONObject()
+            data.put("state", status.toInt())
+            data.put("isLogin", isLogin)
+            data.put("type", "LAN")
+            data.put("device", device.toJsonObject())
+            sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+          }
+      }
+      launch {
+        device.lanCapability.subscribeDp().collect { payload ->
+          val data = JSONObject()
+          data.put("data", JSONObject(payload.toString()))
+          data.put("type", "LAN")
+          data.put("device", device.toJsonObject())
+          sendEvent(EventName.DeviceDataListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+        }
+      }
+      launch {
+        combineLatest(
+          device.mqttCapability.subscribeStatus(),
+          device.mqttCapability.subscribeIsLogin(),
+        ) { status, isLogin -> Pair(status, isLogin) }
+          .collect { (status, isLogin) ->
+            val data = JSONObject()
+            data.put("state", status.toInt())
+            data.put("isLogin", isLogin)
+            data.put("type", "MQTT")
+            data.put("device", device.toJsonObject())
+            sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+          }
+      }
+      launch {
+        device.mqttCapability.subscribeDp().collect { payload ->
+          val data = JSONObject()
+          data.put("data", JSONObject(payload.toString()))
+          data.put("type", "MQTT")
+          data.put("device", device.toJsonObject())
+          sendEvent(EventName.DeviceDataListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+        }
       }
     }
   }
 
+  private fun requestDeviceListChange() {
+    deviceListEventDispatcher.request()
+  }
+
   /**
    * RN的场景下
    * module profile 变更 相当于设备列表变更
    */
-  suspend fun emitDeviceListChange() {
-    val deviceList = deviceListState.first()
+  private suspend fun emitDeviceListChange() {
     // 缓存变更
     val deviceListJson = JSONArray()
-    deviceList.forEach{ item ->
+    latestDeviceList.forEach{ item ->
       deviceListJson.put(item.toJsonObject())
     }
     sendEvent(EventName.DeviceListListener.name, GizRNCallbackManager.jsonArray2WriteableArray(deviceListJson))
   }
 
+  override fun invalidate() {
+    deviceSubscriptions.cancelAll()
+    deviceListEventDispatcher.cancel()
+    moduleScope.cancel()
+    mReactContext = null
+    super.invalidate()
+  }
+
   fun sendEvent(name:String, data: WritableArray?) {
-    mReactContext!!
+    val reactContext = mReactContext ?: return
+    reactContext
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
       .emit(name, data)
   }
   fun sendEvent(name:String, data: WritableMap?) {
-    mReactContext!!
+    val reactContext = mReactContext ?: return
+    reactContext
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
       .emit(name, data)
   }
@@ -326,6 +327,7 @@ class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContex
       // 查询 绑定设备  返回设备列表
       GizSDKManager.queryBoundDevices()
       deviceListState.take(1).collect {
+        latestDeviceList = it
         val jsonData = JSONArray()
         it.forEach{device ->
           jsonData.put(device.toJsonObject())
@@ -337,7 +339,7 @@ class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContex
         writableMap.putInt("error", 0)
         writableMap.putString("message", "")
         result.invoke(null, writableMap)
-        emitDeviceListChange()
+        requestDeviceListChange()
       }
     }
   }

package/android/src/test/java/com/gizwits/reactnativegizwitssdkv5/DeviceListEventCoordinatorTest.kt

@@ -0,0 +1,110 @@
+package com.gizwits.reactnativegizwitssdkv5
+
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class DeviceListEventCoordinatorTest {
+  @Test
+  fun requestBeforeWorkerStartsIsDelivered() = runTest {
+    var dispatchCount = 0
+    val dispatcher = ConflatedEventDispatcher(this, 500) { dispatchCount++ }
+
+    assertTrue(dispatcher.request())
+    advanceTimeBy(500)
+    runCurrent()
+
+    assertEquals(1, dispatchCount)
+    dispatcher.cancel()
+  }
+
+  @Test
+  fun burstRequestsDeliverOnlyTheLatestSnapshot() = runTest {
+    var latestSnapshot = 0
+    val deliveredSnapshots = mutableListOf<Int>()
+    val dispatcher = ConflatedEventDispatcher(this, 500) {
+      deliveredSnapshots += latestSnapshot
+    }
+
+    dispatcher.request()
+    runCurrent()
+    repeat(5) { value ->
+      latestSnapshot = value + 1
+      advanceTimeBy(75)
+      dispatcher.request()
+    }
+    advanceTimeBy(125)
+    runCurrent()
+
+    assertEquals(listOf(5), deliveredSnapshots)
+    dispatcher.cancel()
+  }
+
+  @Test
+  fun continuousRequestsStillDispatchAtEveryWindow() = runTest {
+    var dispatchCount = 0
+    val dispatcher = ConflatedEventDispatcher(this, 500) { dispatchCount++ }
+
+    dispatcher.request()
+    runCurrent()
+    repeat(15) {
+      advanceTimeBy(100)
+      dispatcher.request()
+      runCurrent()
+    }
+
+    assertTrue(dispatchCount >= 2)
+    dispatcher.cancel()
+  }
+
+  @Test
+  fun registryCancelsRemovedDevicesWithoutDuplicatingRetainedSubscriptions() {
+    val createdJobs = mutableMapOf<String, MutableList<Job>>()
+    val registry = KeyedSubscriptionRegistry<String, String>(
+      keySelector = { it },
+      subscribe = { key -> Job().also { createdJobs.getOrPut(key) { mutableListOf() }.add(it) } },
+    )
+
+    registry.update(listOf("a", "b"))
+    val firstAJob = createdJobs.getValue("a").single()
+    val firstBJob = createdJobs.getValue("b").single()
+    registry.update(listOf("b"))
+    registry.update(listOf("a", "b"))
+
+    assertFalse(firstAJob.isActive)
+    assertTrue(firstBJob.isActive)
+    assertEquals(2, createdJobs.getValue("a").size)
+    assertEquals(1, createdJobs.getValue("b").size)
+    assertEquals(setOf("a", "b"), registry.keys())
+
+    registry.cancelAll()
+    assertTrue(createdJobs.values.flatten().none { it.isActive })
+    assertTrue(registry.keys().isEmpty())
+  }
+
+  @Test
+  fun registryReplacesSubscriptionWhenValueInstanceChangesForTheSameKey() {
+    data class Device(val id: String)
+
+    val jobs = mutableListOf<Job>()
+    val registry = KeyedSubscriptionRegistry<String, Device>(
+      keySelector = Device::id,
+      subscribe = { Job().also(jobs::add) },
+    )
+
+    registry.update(listOf(Device("a")))
+    registry.update(listOf(Device("a")))
+
+    assertEquals(2, jobs.size)
+    assertFalse(jobs.first().isActive)
+    assertTrue(jobs.last().isActive)
+    registry.cancelAll()
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-gizwits-sdk-v5",
-  "version": "1.7.8-beta",
+  "version": "1.7.10-beta",
   "description": "Gizwits",
   "homepage": "https://github.com/demchenkoalex/react-native-gizwits-sdk-v5#readme",
   "main": "lib/index.js",