@tryvital/vital-devices-react-native 1.1.0 → 1.3.1

package/android/src/main/java/com/vitaldevicesreactnative/VitalDevicesReactNativeModule.kt

@@ -3,10 +3,10 @@ package com.vitaldevicesreactnative
 import android.util.Log
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import io.tryvital.client.services.data.QuantitySample
+import io.tryvital.client.services.data.QuantitySamplePayload
 import io.tryvital.vitaldevices.*
 import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.*
 
 
 class VitalDevicesReactNativeModule(reactContext: ReactApplicationContext) :
@@ -14,7 +14,8 @@ class VitalDevicesReactNativeModule(reactContext: ReactApplicationContext) :
 
   private val vitalDeviceManager = VitalDeviceManager(reactContext)
   private val scannedDevices: MutableList<ScannedDevice> = mutableListOf()
-  private var mainScope: CoroutineScope? = null
+  private var mainScope = MainScope()
+  private var activeScan: Job? = null
 
   override fun getName(): String {
     return NAME
@@ -34,40 +35,35 @@ class VitalDevicesReactNativeModule(reactContext: ReactApplicationContext) :
       brand = stringToBrand(brand),
       kind = stringToKind(kind),
     )
-    mainScope?.cancel()
-    mainScope = MainScope()
-    mainScope?.launch {
-      try {
-        vitalDeviceManager.search(deviceModel).flowOn(Dispatchers.IO).collect {
-          withContext(Dispatchers.Main) {
-            scannedDevices.add(it)
-            sendEvent(VitalDevicesEvent.ScanEvent, WritableNativeMap().apply {
-              putString("id", it.address)
-              putString("name", it.name)
-              putString("address", it.address)
-              putMap("deviceModel", WritableNativeMap().apply {
-                putString("name", it.deviceModel.name)
-                putString("brand", brandToString(it.deviceModel.brand))
-                putString("kind", kindToString(it.deviceModel.kind))
-              })
-            }
-            )
-          }
-        }
-      } catch (e: Exception) {
-        withContext(Dispatchers.Main) {
+
+    try {
+      activeScan?.cancel()
+      activeScan = vitalDeviceManager
+        .search(deviceModel)
+        .flowOn(Dispatchers.IO)
+        .onEach {
+          scannedDevices.add(it)
           sendEvent(VitalDevicesEvent.ScanEvent, WritableNativeMap().apply {
-            putString("error", e.message)
+            putString("id", it.address)
+            putString("name", it.name)
+            putString("address", it.address)
+            putMap("deviceModel", WritableNativeMap().apply {
+              putString("name", it.deviceModel.name)
+              putString("brand", brandToString(it.deviceModel.brand))
+              putString("kind", kindToString(it.deviceModel.kind))
+            })
           })
         }
-      }
+        .onStart { promise.resolve(null) }
+        .launchIn(mainScope)
+    } catch (e: Exception) {
+        promise.reject("ScanError", e.message, e)
     }
-    promise.resolve(null)
   }
 
   @ReactMethod
   fun stopScanForDevice(promise: Promise) {
-    mainScope?.cancel()
+    activeScan?.cancel()
     promise.resolve(null)
   }
 
@@ -76,128 +72,95 @@ class VitalDevicesReactNativeModule(reactContext: ReactApplicationContext) :
     val scannedDevice = scannedDevices.firstOrNull { it.address == scannedDeviceId }
 
     if (scannedDevice == null) {
-      sendEvent(VitalDevicesEvent.PairEvent, WritableNativeMap().apply {
-        putString("error", "Device not found")
-      })
-    } else {
-      mainScope?.cancel()
-      mainScope = MainScope()
-      mainScope?.launch {
-        try {
-          withContext(Dispatchers.Default) {
-            vitalDeviceManager.pair(scannedDevice).collect {
-              withContext(Dispatchers.Main) {
-                sendEvent(VitalDevicesEvent.PairEvent, it)
-              }
-            }
-          }
-        } catch (e: Exception) {
-          withContext(Dispatchers.Main) {
-            sendEvent(VitalDevicesEvent.PairEvent, WritableNativeMap().apply {
-              putString("error", e.message)
-            })
-          }
-        }
+      promise.reject("PairError", "Device not found", null)
+      return
+    }
+
+    mainScope.launch {
+      try {
+        vitalDeviceManager
+          .pair(scannedDevice)
+          .flowOn(Dispatchers.IO)
+          .collect()
+
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject("PairError", e.message, e)
       }
-      promise.resolve(null)
     }
   }
 
   @ReactMethod
-  private fun startReadingGlucoseMeter(scannedDeviceId: String, promise: Promise) {
+  private fun readGlucoseMeter(scannedDeviceId: String, promise: Promise) {
     val scannedDevice = scannedDevices.firstOrNull { it.address == scannedDeviceId }
 
     if (scannedDevice == null) {
-      sendEvent(VitalDevicesEvent.GlucoseMeterReadEvent, WritableNativeMap().apply {
-        putString("error", "Device not found")
-      })
-    } else {
-      mainScope?.cancel()
-      mainScope = MainScope()
-      mainScope?.launch {
-        try {
-          withContext(Dispatchers.Default) {
-            vitalDeviceManager.glucoseMeter(reactApplicationContext, scannedDevice)
-              .flowOn(Dispatchers.IO)
-              .collect { samples ->
-                withContext(Dispatchers.Main) {
-                  sendEvent(VitalDevicesEvent.GlucoseMeterReadEvent, WritableNativeMap().apply {
-                    putArray("samples", WritableNativeArray().apply {
-                      samples.forEach {
-                        pushMap(WritableNativeMap().apply {
-                          mapSample(it)
-                        })
-                      }
-                    })
-                  })
-                }
-              }
-          }
-        } catch (e: Exception) {
-          withContext(Dispatchers.Main) {
-            sendEvent(VitalDevicesEvent.GlucoseMeterReadEvent, WritableNativeMap().apply {
-              putString("error", e.message)
-            })
-          }
-        }
+      promise.reject("ReadError", "Device not found", null)
+      return
+    }
+
+    mainScope.launch {
+      try {
+        val samples = vitalDeviceManager
+          .glucoseMeter(reactApplicationContext, scannedDevice)
+          .flowOn(Dispatchers.IO)
+          .first()
+
+        promise.resolve(WritableNativeMap().apply {
+          putArray("samples", WritableNativeArray().apply {
+            samples.forEach {
+              pushMap(WritableNativeMap().apply {
+                mapSample(it)
+              })
+            }
+          })
+        })
+      } catch (e: Exception) {
+        promise.reject("ReadError", e.message, e)
       }
-      promise.resolve(null)
     }
   }
 
   @ReactMethod
-  private fun startReadingBloodPressure(scannedDeviceId: String, promise: Promise) {
+  private fun readBloodPressure(scannedDeviceId: String, promise: Promise) {
     val scannedDevice = scannedDevices.firstOrNull { it.address == scannedDeviceId }
 
     if (scannedDevice == null) {
-      sendEvent(VitalDevicesEvent.BloodPressureReadEvent, WritableNativeMap().apply {
-        putString("error", "Device not found")
-      })
-    } else {
-      mainScope?.cancel()
-      mainScope = MainScope()
-      mainScope?.launch {
-        try {
-          withContext(Dispatchers.Default) {
-            vitalDeviceManager.bloodPressure(reactApplicationContext, scannedDevice)
-              .flowOn(Dispatchers.IO)
-              .collect { samples ->
-                withContext(Dispatchers.Main) {
-                  sendEvent(VitalDevicesEvent.BloodPressureReadEvent, WritableNativeMap().apply {
-                    putArray("samples", WritableNativeArray().apply {
-                      samples.forEach {
-                        pushMap(WritableNativeMap().apply {
-                          putMap("systolic", WritableNativeMap().apply {
-                            mapSample(it.systolic)
-                          })
-                          putMap("diastolic", WritableNativeMap().apply {
-                            mapSample(it.diastolic)
-                          })
-                          putMap("pulse", WritableNativeMap().apply {
-                            mapSample(it.pulse)
-                          })
-                        })
-                      }
-                    })
-                  })
-                }
-              }
-          }
-        } catch (e: Exception) {
-          withContext(Dispatchers.Main) {
-            sendEvent(VitalDevicesEvent.BloodPressureReadEvent, WritableNativeMap().apply {
-              putString("error", e.message)
-            })
-          }
+      promise.reject("ReadError", "Device not found", null)
+      return
+    }
 
-        }
+    mainScope.launch {
+      try {
+        val samples = vitalDeviceManager
+          .bloodPressure(reactApplicationContext, scannedDevice)
+          .flowOn(Dispatchers.IO)
+          .first()
+
+        promise.resolve(WritableNativeMap().apply {
+          putArray("samples", WritableNativeArray().apply {
+            samples.forEach {
+              pushMap(WritableNativeMap().apply {
+                putMap("systolic", WritableNativeMap().apply {
+                  mapSample(it.systolic)
+                })
+                putMap("diastolic", WritableNativeMap().apply {
+                  mapSample(it.diastolic)
+                })
+                putMap("pulse", WritableNativeMap().apply {
+                  mapSample(it.pulse)
+                })
+              })
+            }
+          })
+        })
+      } catch (e: Exception) {
+        promise.reject("ReadError", e.message, e)
       }
-
-      promise.resolve(null)
     }
   }
 
-  private fun WritableNativeMap.mapSample(it: QuantitySample) {
+  private fun WritableNativeMap.mapSample(it: QuantitySamplePayload) {
     putString("id", it.id)
     putString("value", it.value)
     putString("unit", it.unit)

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+};

package/ios/VitalDevicesReactNative.m

@@ -17,11 +17,11 @@ RCT_EXTERN_METHOD(pair:(NSString *)scannedDeviceId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(startReadingBloodPressure:(NSString *)scannedDeviceId
+RCT_EXTERN_METHOD(readBloodPressure:(NSString *)scannedDeviceId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(startReadingGlucoseMeter:(NSString *)scannedDeviceId
+RCT_EXTERN_METHOD(readGlucoseMeter:(NSString *)scannedDeviceId
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 

package/ios/VitalDevicesReactNative.swift

@@ -26,12 +26,14 @@ class VitalDevicesReactNative: RCTEventEmitter {
     }
 
     @objc(startScanForDevice:name:brand:kind:resolver:rejecter:)
-    func startScanForDevice(_ id:String,
-                            name: String,
-                            brand: String,
-                            kind: String,
-                            resolve: @escaping RCTPromiseResolveBlock,
-                            reject:RCTPromiseRejectBlock) -> Void {
+    func startScanForDevice(
+        _ id:String,
+        name: String,
+        brand: String,
+        kind: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
         do {
             let deviceModel = DeviceModel(
                 id: id,
@@ -41,184 +43,171 @@ class VitalDevicesReactNative: RCTEventEmitter {
             )
 
             scannerResultCancellable?.cancel()
-            scannerResultCancellable =  deviceManager.search(for:deviceModel)
-                .sink {[weak self] value in
+            scannerResultCancellable =  deviceManager
+                .search(for: deviceModel)
+                .receive(on: DispatchQueue.main)
+                .sink { [weak self] value in
                     self?.scannedDevices.append(value)
-                    self?.sendEvent(withName: "ScanEvent", body:
-                                        [
-                                            "id": value.id.uuidString,
-                                            "name": value.name,
-                                            "deviceModel": [
-                                                "id": value.deviceModel.id,
-                                                "name": value.deviceModel.name,
-                                                "brand": value.deviceModel.brand.rawValue,
-                                                "kind": value.deviceModel.kind.rawValue
-                                            ]
-                                        ])
+                    self?.sendEvent(
+                        withName: "ScanEvent",
+                        body: [
+                            "id": value.id.uuidString,
+                            "name": value.name,
+                            "deviceModel": [
+                                "id": value.deviceModel.id,
+                                "name": value.deviceModel.name,
+                                "brand": value.deviceModel.brand.rawValue,
+                                "kind": value.deviceModel.kind.rawValue
+                            ]
+                        ]
+                    )
                 }
 
             resolve(())
         } catch VitalError.UnsupportedBrand(let errorMessage) {
-            resolve(["error": "UnsupportedBrand", "message": errorMessage])
+            reject("UnsupportedBrand", errorMessage, nil)
         } catch VitalError.UnsupportedKind(let errorMessage) {
-            resolve(["error": "UnsupportedKind", "message": errorMessage])
-        } catch {
-            resolve(["error": "Unknown", "message": error.localizedDescription])
+            reject("UnsupportedKind", errorMessage, nil)
+        } catch let error {
+            reject("Unknown", error.localizedDescription, error)
         }
     }
 
     @objc(stopScanForDevice:rejecter:)
     func stopScanForDevice(_ resolve: @escaping RCTPromiseResolveBlock,
-                           reject:RCTPromiseRejectBlock) -> Void {
+                           reject:RCTPromiseRejectBlock) {
         scannerResultCancellable?.cancel()
         resolve(())
     }
 
     @objc(pair:resolver:rejecter:)
-    func pair(_ scannedDeviceId:String,
-              resolve: @escaping RCTPromiseResolveBlock,
-              reject:RCTPromiseRejectBlock) -> Void {
-        let scannedDevice = scannedDevices.first(where: { $0.id == UUID(uuidString:scannedDeviceId) })
-
-        guard scannedDevice != nil else {
-            resolve([
-                "error": "DeviceNotFound",
-                "message": "Device not found with id \(scannedDeviceId)"
-            ])
+    func pair(
+        _ scannedDeviceId: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        guard
+            let scannedDeviceUUID = UUID(uuidString: scannedDeviceId),
+            let scannedDevice = scannedDevices.first(where: { $0.id == scannedDeviceUUID })
+        else {
+            reject("DeviceNotFound", "Device not found with id \(scannedDeviceId)", nil)
             return
         }
 
-        pairCancellable?.cancel()
-        switch scannedDevice!.deviceModel.kind{
+        let pairable: DevicePairable
+
+        switch scannedDevice.deviceModel.kind{
         case .glucoseMeter:
-            pairCancellable = deviceManager
-                .glucoseMeter(for: scannedDevice!)
-                .pair(device: scannedDevice!)
-                .sink(receiveCompletion: {[weak self] value in
-                    self?.handlePairCompletion(value: value )
-                },
-                      receiveValue:{[weak self] value in
-                    self?.handlePairValue()
-                })
+            pairable = deviceManager.glucoseMeter(for: scannedDevice)
         case .bloodPressure:
-            pairCancellable = deviceManager
-                .bloodPressureReader(for: scannedDevice!)
-                .pair(device: scannedDevice!)
-                .sink(receiveCompletion: {[weak self] value in
-                    self?.handlePairCompletion(value: value )
-                },
-                      receiveValue:{[weak self] value in
-                    self?.handlePairValue()
-                })
-        }
-        resolve(())
-    }
-
-    private func handlePairCompletion(value: Subscribers.Completion<any Error>){
-        switch value {
-        case .failure(let error):  self.sendEvent(withName: "PairEvent", body: ["error": "PairError", "message": error.localizedDescription])
-        case .finished:  self.sendEvent(withName: "PairEvent", body: true)
+            pairable = deviceManager.bloodPressureReader(for: scannedDevice)
         }
-    }
 
-    private func handlePairValue() {
-        self.sendEvent(withName: "PairEvent", body: true)
+        pairCancellable = pairable
+            .pair(device: scannedDevice)
+            .sink { completion in
+                switch completion {
+                case .finished:
+                    resolve(())
+                case let .failure(error):
+                    reject("PairError", error.localizedDescription, error)
+                }
+            } receiveValue: { _ in }
     }
 
-    @objc(startReadingGlucoseMeter:resolver:rejecter:)
-    func startReadingGlucoseMeter(_ scannedDeviceId:String,
-                                  resolve: @escaping RCTPromiseResolveBlock,
-                                  reject:RCTPromiseRejectBlock) -> Void {
-
-        let scannedDeviceId = UUID(uuidString: scannedDeviceId)!
-        let scannedDevice = scannedDevices.first(where: { $0.id == scannedDeviceId })
-
-
-        guard scannedDevice != nil else {
-            resolve([
-                "error": "DeviceNotFound",
-                "message": "Device not found with id \(scannedDeviceId)"
-            ])
+    @objc(readGlucoseMeter:resolver:rejecter:)
+    func readGlucoseMeter(
+        _ scannedDeviceId:String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {    
+        guard
+            let scannedDeviceId = UUID(uuidString: scannedDeviceId),
+            let scannedDevice = scannedDevices.first(where: { $0.id == scannedDeviceId })
+        else {
+            reject("DeviceNotFound", "Device not found with id \(scannedDeviceId)", nil)
             return
         }
 
         glucoseMeterCancellable?.cancel()
-        glucoseMeterCancellable =  deviceManager.glucoseMeter(for :scannedDevice!)
-            .read(device: scannedDevice!)
-            .sink (receiveCompletion: {[weak self] value in
-                self?.sendEvent(withName: "GlucoseMeterReadEvent", body: ["error": "ReadError", "message": "error reading data from device \(value)"])
-            }, receiveValue:{[weak self] value in
-            self?.sendEvent(withName: "GlucoseMeterReadEvent", body: [
-                                "samples": value.map({[
-                                        "id": $0.id,
-                                        "value": $0.value,
-                                        "unit": $0.unit,
-                                        "startDate": $0.startDate.timeIntervalSince1970,
-                                        "endDate": $0.endDate.timeIntervalSince1970,
-                                        "type": $0.type
-                                ]})
-                            ] )
-            })
-
-        resolve(())
+        glucoseMeterCancellable = deviceManager
+            .glucoseMeter(for: scannedDevice)
+            .read(device: scannedDevice)
+            .sink { completion in
+                if case let .failure(error) = completion {
+                    reject("ReadError", "error reading data from device \(error)", error)
+                }
+            } receiveValue: { samples in
+                let mappedSamples = samples.map { sample in
+                    [
+                        "id": sample.id,
+                        "value": sample.value,
+                        "unit": sample.unit,
+                        "startDate": sample.startDate.timeIntervalSince1970,
+                        "endDate": sample.endDate.timeIntervalSince1970,
+                        "type": sample.type
+                    ] as [String: Any?]
+                }
+                resolve(["samples": mappedSamples])
+            }
     }
 
-    @objc(startReadingBloodPressure:resolver:rejecter:)
-    func startReadingBloodPressure(_ scannedDeviceId:String,
-                                   resolve: @escaping RCTPromiseResolveBlock,
-                                   reject:RCTPromiseRejectBlock) -> Void {
-        let scannedDeviceId = UUID(uuidString: scannedDeviceId)!
-        let scannedDevice = scannedDevices.first(where: { $0.id == scannedDeviceId })
-
-        guard scannedDevice != nil else {
-            resolve([
-                "error": "DeviceNotFound",
-                "message": "Device not found with id \(scannedDeviceId)"
-            ])
+    @objc(readBloodPressure:resolver:rejecter:)
+    func readBloodPressure(
+        _ scannedDeviceId: String,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        guard
+            let scannedDeviceId = UUID(uuidString: scannedDeviceId),
+            let scannedDevice = scannedDevices.first(where: { $0.id == scannedDeviceId })
+        else {
+            reject("DeviceNotFound", "Device not found with id \(scannedDeviceId)", nil)
             return
         }
 
         bloodPressureCancellable?.cancel()
-        bloodPressureCancellable = deviceManager.bloodPressureReader(for :scannedDevice!)
-            .read(device: scannedDevice!)
-            .sink (receiveCompletion: {[weak self] value in
-                self?.sendEvent(withName: "BloodPressureReadEvent", body: ["error": "ReadError", "message": "error reading data from device \(value)"])
-            }, receiveValue:{[weak self] value in
-                self?.sendEvent(withName: "BloodPressureReadEvent", body:[
-                    "samples": value.map({[
+        bloodPressureCancellable = deviceManager.bloodPressureReader(for: scannedDevice)
+            .read(device: scannedDevice)
+            .sink { completion in
+                if case let .failure(error) = completion {
+                    reject("ReadError", "error reading data from device \(error)", error)
+                }
+            } receiveValue: { samples in
+                let mappedSamples = samples.map { sample in
+                    [
                         "systolic": [
-                            "id": $0.systolic.id,
-                            "value": $0.systolic.value,
-                            "unit": $0.systolic.unit,
-                            "startDate": $0.systolic.startDate.timeIntervalSince1970,
-                            "endDate": $0.systolic.endDate.timeIntervalSince1970,
-                            "type": $0.systolic.type
-                        ],
+                            "id": sample.systolic.id,
+                            "value": sample.systolic.value,
+                            "unit": sample.systolic.unit,
+                            "startDate": sample.systolic.startDate.timeIntervalSince1970,
+                            "endDate": sample.systolic.endDate.timeIntervalSince1970,
+                            "type": sample.systolic.type
+                        ] as [String: Any?],
                         "diastolic": [
-                            "id": $0.diastolic.id,
-                            "value": $0.diastolic.value,
-                            "unit": $0.diastolic.unit,
-                            "startDate": $0.diastolic.startDate.timeIntervalSince1970,
-                            "endDate": $0.diastolic.endDate.timeIntervalSince1970,
-                            "type": $0.diastolic.type
-                        ],
+                            "id": sample.diastolic.id,
+                            "value": sample.diastolic.value,
+                            "unit": sample.diastolic.unit,
+                            "startDate": sample.diastolic.startDate.timeIntervalSince1970,
+                            "endDate": sample.diastolic.endDate.timeIntervalSince1970,
+                            "type": sample.diastolic.type
+                        ] as [String: Any?],
                         "pulse": [
-                            "id": $0.pulse?.id,
-                            "value": $0.pulse?.value,
-                            "unit": $0.pulse?.unit,
-                            "startDate": $0.pulse?.startDate.timeIntervalSince1970,
-                            "endDate": $0.pulse?.endDate.timeIntervalSince1970,
-                            "type": $0.pulse?.type
-                        ]
-                    ]})
-                ] )
-            })
-
-        resolve(())
+                            "id": sample.pulse?.id,
+                            "value": sample.pulse?.value,
+                            "unit": sample.pulse?.unit,
+                            "startDate": sample.pulse?.startDate.timeIntervalSince1970,
+                            "endDate": sample.pulse?.endDate.timeIntervalSince1970,
+                            "type": sample.pulse?.type
+                        ] as [String: Any?]
+                    ]
+                }
+                resolve(["samples": mappedSamples])
+            }
     }
 
     override func supportedEvents() -> [String]! {
-        return ["ScanEvent","PairEvent","GlucoseMeterReadEvent","BloodPressureReadEvent"]
+        return ["ScanEvent"]
     }
 }