react-native-gizwits-sdk-v5 1.2.3 → 1.2.5

package/android/build.gradle

@@ -7,6 +7,7 @@ buildscript {
         kotlin_coroutine_version = '1.6.4'
         retrofit_version = '2.9.0'
         room_version = '2.5.0'
+        mqtt_version = '1.2.5'
     }
 
     repositories {
@@ -58,6 +59,8 @@ dependencies {
     implementation 'io.sentry:sentry-android-timber:6.29.0'
     implementation 'com.jakewharton.timber:timber:5.0.1'
     implementation 'io.sentry:sentry-android:6.29.0'
+    implementation "org.eclipse.paho:org.eclipse.paho.client.mqttv3:$mqtt_version"
+
 
     implementation files('libs/sdk-debug.aar', 'libs/sdk-bluetooth-debug.aar', 'libs/sdk-lan-debug.aar', 'libs/sdk-mqtt-debug.aar')
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlin_coroutine_version")

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

@@ -6,15 +6,20 @@ import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.gizwits.smart.sdk.exception.GizException
 import com.google.gson.Gson
+import com.google.gson.annotations.SerializedName
 import com.google.gson.reflect.TypeToken
 import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
 
 class GizResult<T> {
+    @SerializedName("success")
     var success = false;
+    @SerializedName("data")
     var data: T? = null
+    @SerializedName("error")
     var error: Number? = null
+    @SerializedName("message")
     var message: String = ""
 }
 

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

@@ -0,0 +1,107 @@
+package com.gizwits.reactnativegizwitssdkv5
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.gizwits.smart.sdk.GizDevice
+import com.gizwits.smart.sdk.GizSDKManager
+import com.gizwits.smart.sdk.bluetooth.bleCapacity
+import com.gizwits.smart.sdk.common.GizConfiguration
+import com.gizwits.smart.sdk.core.capacity.CapacityTypes
+import com.gizwits.smart.sdk.exception.GizException
+import com.gizwits.smart.sdk.lan.lanCapacity
+import com.gizwits.smart.sdk.mqtt.mqttCapacity
+import com.gizwits.smart.sdk.mqtt.queryBoundDevices
+import com.google.gson.annotations.SerializedName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+data class GizBindParams(
+    @SerializedName("id")
+    override val id: Int,
+    @SerializedName("alias")
+    val alias: String,
+    @SerializedName("remark")
+    val remark: String,
+) : DeviceParams
+
+data class GizUnBindParams(
+    @SerializedName("id")
+    override val id: Int,
+): DeviceParams
+
+data class GizConnectParams(
+    @SerializedName("id")
+    override val id: Int,
+    @SerializedName("type")
+    val type: CapacityTypes
+): DeviceParams
+
+
+class RNGizDeviceManagerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    enum class EventName(val value: String) {
+        GizOTAProgressEvent("GizOTAProgressEvent"),
+    }
+
+    override fun getName() = "RNGizDeviceManagerModule"
+    @ReactMethod
+    fun sendDp(options: ReadableMap, result: Callback) {}
+    @ReactMethod
+    fun getDp(options: ReadableMap, result: Callback) {}
+    @ReactMethod
+    fun getDeviceInfo(options: ReadableMap, result: Callback) {}
+
+    @ReactMethod
+    fun bind(options: ReadableMap, result: Callback) {
+        val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizBindParams::class.java)
+        if (config !=null && device !=null) {
+            CoroutineScope(Dispatchers.Main).launch {
+                val res = device.bindDevice(config.alias, config.remark)
+                GizRNCallbackManager.callbackWithResult(callback = result, result = res)
+                if (res.isSuccess) {
+                    GizSDKManager.queryBoundDevices()
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun unBind(options: ReadableMap, result: Callback) {
+        val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizUnBindParams::class.java)
+        if (config !=null && device !=null) {
+            CoroutineScope(Dispatchers.Main).launch {
+                val res = device.unbindDevice()
+                GizRNCallbackManager.callbackWithResult(callback = result, result = res)
+                if (res.isSuccess) {
+                    GizSDKManager.queryBoundDevices()
+                }
+            }
+        }
+    }
+    @ReactMethod
+    fun checkUpdate(options: ReadableMap, result: Callback) {}
+    @ReactMethod
+    fun startUpgrade(options: ReadableMap, result: Callback) {}
+    @ReactMethod
+    fun register(options: ReadableMap, result: Callback) {}
+
+    @ReactMethod
+    fun connect(options: ReadableMap, result: Callback) {
+        val (config, device) = RNGizParamsChecker.checkDeviceAndParams(options, result, GizConnectParams::class.java)
+        if (config !=null && device !=null) {
+            CoroutineScope(Dispatchers.Main).launch {
+                val res = when(config.type) {
+                    CapacityTypes.BLE -> device.bleCapacity.connect()
+                    CapacityTypes.LAN -> device.lanCapacity.connect()
+                    CapacityTypes.MQTT -> device.mqttCapacity.connect()
+                }
+//                GizRNCallbackManager.callbackWithResult(callback = result, result = res)
+            }
+        }
+    }
+    @ReactMethod
+    fun disConnect(options: ReadableMap, result: Callback) {}
+}

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

@@ -1,11 +1,17 @@
 package com.gizwits.reactnativegizwitssdkv5
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.ReadableMap
+import com.gizwits.smart.sdk.GizDevice
+import com.gizwits.smart.sdk.GizSDKManager
 import com.gizwits.smart.sdk.exception.GizException
 import com.gizwits.smart.sdk.exception.GizParseException
 import com.google.gson.Gson
 import com.google.gson.JsonSyntaxException
+import com.google.gson.annotations.SerializedName
 
+interface DeviceParams{
+    val id: Int
+}
 class RNGizParamsChecker {
     companion object {
         fun <T : Any> check(options: ReadableMap, result: Callback, paramsType: Class<T>): T? {
@@ -22,5 +28,22 @@ class RNGizParamsChecker {
                 return null
             }
         }
+
+        fun <T : DeviceParams> checkDeviceAndParams(options: ReadableMap, result: Callback, paramsType: Class<T>): Pair<T?, GizDevice?> {
+            val config = check(options, result, paramsType)
+            var dev: GizDevice? = null
+            config?.let {
+                dev = GizSDKManager.getRegisteredDevice(config.id)
+                if (dev == null) {
+                    GizRNCallbackManager.callbackWithResult(
+                        callback = result,
+                        result = Result.failure<Number>(GizException.GIZ_OPENAPI_DEVICE_NOT_FOUND)
+                    )
+                }
+            }
+            return Pair(config, dev)
+        }
+
+
     }
 }

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

@@ -1,5 +1,6 @@
 package com.gizwits.reactnativegizwitssdkv5
 
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -10,22 +11,36 @@ import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.gizwits.smart.sdk.GizDevice
 import com.gizwits.smart.sdk.GizSDKManager
+import com.gizwits.smart.sdk.GizUserManager
+import com.gizwits.smart.sdk.bluetooth.bleCapacity
 import com.gizwits.smart.sdk.bluetooth.startScan
 import com.gizwits.smart.sdk.bluetooth.stopScan
 import com.gizwits.smart.sdk.bluetooth.subscribeBluetoothDeviceList
 import com.gizwits.smart.sdk.common.GizConfiguration
 import com.gizwits.smart.sdk.common.combineLatest
 import com.gizwits.smart.sdk.exception.GizException
+import com.gizwits.smart.sdk.lan.lanCapacity
 import com.gizwits.smart.sdk.lan.subscribeLanDeviceList
+import com.gizwits.smart.sdk.mqtt.mqttCapacity
+import com.gizwits.smart.sdk.mqtt.queryBoundDevices
 import com.gizwits.smart.sdk.mqtt.subscribeBoundDeviceList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.last
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.toList
 import kotlinx.coroutines.launch
 import org.json.JSONArray
+import org.json.JSONObject
 
 class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
+    companion object {
+        internal var devices = listOf<GizDevice>()
+    }
     enum class EventName(val value: String) {
         DeviceDataListener("DeviceDataListener"),
         DeviceListListener("DeviceListListener"),
@@ -48,11 +63,45 @@ class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContex
         super.initialize()
         CoroutineScope(Dispatchers.Main).launch {
             deviceListState.collect { deviceList ->
+                // 保存一份缓存
+                val newDevices = deviceList - devices
+                newDevices.forEach{dev ->
+                    val devJob = dev.getDeviceJob()
+                    val scope = CoroutineScope(devJob)
+                    scope.launch {
+                        dev.bleCapacity.subscribeStatus().collect{
+                            val data = JSONObject()
+                            data.put("state", it.toInt())
+                            data.put("type", "BLE")
+                            data.put("device", dev.toJsonObject())
+                            sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+                        }
+                    }
+                    scope.launch {
+                        dev.lanCapacity.subscribeStatus().collect{
+                            val data = JSONObject()
+                            data.put("state", it.toInt())
+                            data.put("type", "LAN")
+                            data.put("device", dev.toJsonObject())
+                            sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+                        }
+                    }
+                    scope.launch {
+                        dev.mqttCapacity.subscribeStatus().collect{
+                            val data = JSONObject()
+                            data.put("state", it.toInt())
+                            data.put("type", "MQTT")
+                            data.put("device", dev.toJsonObject())
+                            sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonObject2WriteableMap(data))
+                        }
+                    }
+                }
+                devices = deviceList
                 val deviceListJson = JSONArray()
                 deviceList.forEach{ item ->
                     deviceListJson.put(item.toJsonObject())
                 }
-                sendEvent(EventName.DeviceStateListener.name, GizRNCallbackManager.jsonArray2WriteableArray(deviceListJson))
+                sendEvent(EventName.DeviceListListener.name, GizRNCallbackManager.jsonArray2WriteableArray(deviceListJson))
             }
         }
     }
@@ -82,7 +131,23 @@ class RNGizSDKManagerModule(reactContext: ReactApplicationContext) : ReactContex
     }
     @ReactMethod
     fun getDevices(options: ReadableMap, result: Callback) {
-        // 查询 绑定设备  返回设备列表
+        CoroutineScope(Dispatchers.Main).launch {
+            // 查询 绑定设备  返回设备列表
+            GizSDKManager.queryBoundDevices()
+            deviceListState.take(1).collect {
+                val jsonData = JSONArray()
+                it.forEach{device ->
+                    jsonData.put(device.toJsonObject())
+                }
+                // 设备列表比较特殊，手动回调
+                val writableMap = Arguments.createMap()
+                writableMap.putArray("data", GizRNCallbackManager.jsonArray2WriteableArray(jsonData))
+                writableMap.putBoolean("success", true)
+                writableMap.putInt("error", 0)
+                writableMap.putString("message", "")
+                result.invoke(null, writableMap)
+            }
+        }
     }
 
     @ReactMethod

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

@@ -17,7 +17,8 @@ class RNGizSDKManagerPackage : ReactPackage {
             MutableList<NativeModule> {
         return mutableListOf(
             RNGizSDKManagerModule(reactContext),
-            RNGizUserManagerModule(reactContext)
+            RNGizUserManagerModule(reactContext),
+            RNGizDeviceManagerModule(reactContext)
         )
     }
 }

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

@@ -5,17 +5,53 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
-import com.gizwits.smart.sdk.GizSDKManager
-import com.gizwits.smart.sdk.GizUserManager
-import com.gizwits.smart.sdk.exception.GizException
+import com.gizwits.smart.sdk.GizUserManagerImpl
+import com.gizwits.smart.sdk.common.GizConfiguration
+import com.gizwits.smart.sdk.core.data.model.UserToken
+import com.google.gson.annotations.SerializedName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.util.Date
+
+data class UpdateAuthorizeDataParams(
+    @SerializedName("token")
+    val token: String,
+    @SerializedName("uid")
+    val uid: String
+)
 
 class RNGizUserManagerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
     override fun getName() = "RNGizUserManagerModule"
-    private val userManager: GizUserManager = GizSDKManager.getUserManager()
 
     @ReactMethod
     fun getAuthorizeData(options: ReadableMap, result: Callback) {
-        GizRNCallbackManager.callbackWithResult(callback = result, result = Result.failure<Number>(
-            GizException.GIZ_SDK_PARAM_INVALID))
+        val tokenInfo = GizUserManagerImpl.getUserTokenStream().value
+        val authData = UpdateAuthorizeDataParams(tokenInfo?.token ?: "", tokenInfo?.userId ?: "")
+        GizRNCallbackManager.callbackWithResult(callback = result, result = Result.success(authData))
+    }
+    @ReactMethod
+    fun updateAuthorizeData(options: ReadableMap, result: Callback) {
+        var config = RNGizParamsChecker.check(options, result, UpdateAuthorizeDataParams::class.java)
+        config?.let {
+            // Date 暂时没有用到
+            GizUserManagerImpl.updateAuthorizeData(UserToken(config.token, config.uid, Date()))
+            GizRNCallbackManager.callbackWithResult(callback = result, result = Result.success(0))
+        }
+
+    }
+    @ReactMethod
+    fun loginByAnonymous(options: ReadableMap, result: Callback) {
+        CoroutineScope(Dispatchers.Main).launch {
+            val res = GizUserManagerImpl.loginByAnonymous()
+            GizRNCallbackManager.callbackWithResult(callback = result, result = res)
+        }
+    }
+    @ReactMethod
+    fun logout(options: ReadableMap, result: Callback) {
+        CoroutineScope(Dispatchers.Main).launch {
+            val res = GizUserManagerImpl.logout()
+            GizRNCallbackManager.callbackWithResult(callback = result, result = res)
+        }
     }
 }

package/ios/RNGizSDKManagerModule.swift

@@ -68,6 +68,18 @@ class RNGizSDKManagerModule: RCTEventEmitter, GizSdkEventHandlerDelegate  {
         }
     }
 
+    @objc
+    public func startBleScan(_ options: NSDictionary, result: @escaping RCTResponseSenderBlock) {
+        GizSDKManager.sharedInstance.startBleScan()
+        GizRNCallbackManager.callbackWithResult(callback: result, result: GizResult<Int?, GizAPIException?>(data: nil, success: true))
+    }
+
+    @objc
+    public func stopBleScan(_ options: NSDictionary, result: @escaping RCTResponseSenderBlock) {
+        GizSDKManager.sharedInstance.stopBleScan()
+        GizRNCallbackManager.callbackWithResult(callback: result, result: GizResult<Int?, GizAPIException?>(data: nil, success: true))
+    }
+
     @objc
     override static func requiresMainQueueSetup() -> Bool {
         return true

package/lib/types.d.ts

@@ -1,7 +1,7 @@
 export declare type AuthenticationMethod = 0 | 1;
 export interface GizBaseCapability {
     name: string;
-    isActived: boolean;
+    isActive: boolean;
     netStatus: NetStatus;
     connect: () => Promise<GizResult<any, any>>;
     getDeviceInfo: () => Promise<GizResult<GizDeviceInfoProfile, any>>;
@@ -101,7 +101,7 @@ export interface GizConfigStruct {
     productInfos: ProductInfoStruct[];
     serverInfo?: ServerInfoStruct;
 }
-export declare type GizWifiDeviceNetStatus = 0 | 1 | 2 | 3;
+export declare type GizDeviceNetStatus = 0 | 1 | 2;
 export declare type GizCapability = 'BLE' | 'LAN' | 'MQTT';
 export declare type GizOTAFirmwareType = 'Module' | 'MCU';
 export interface DeviceDataRes {
@@ -111,7 +111,7 @@ export interface DeviceDataRes {
 }
 export interface DeviceStateRes {
     device: IDevice;
-    state: GizWifiDeviceNetStatus;
+    state: GizDeviceNetStatus;
     type: GizCapability;
 }
 export declare type DeviceDataCallback = (data: DeviceDataRes) => void;

package/package.json

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