@tryvital/vital-devices-react-native 0.2.5

package/LICENSE

@@ -0,0 +1 @@
+MIT

package/README.md

@@ -0,0 +1,14 @@
+# vital-devices-react-native
+
+This library provides helper methods to BLE Devices for Vital. This allows developers to easily make requests and interact with Vital's API.
+
+## Installation
+
+```sh
+npm install vital-devices-react-native
+cd ios && pod install
+
+```
+## Getting Started
+
+Please refer to our guide to get started - https://docs.tryvital.io/wearables/sdks/react_native 

package/android/build.gradle

@@ -0,0 +1,150 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['VitalDevicesReactNative_kotlinVersion']
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath 'com.android.tools.build:gradle:3.5.3'
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['VitalDevicesReactNative_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['VitalDevicesReactNative_' + name]).toInteger()
+}
+
+android {
+  compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+    targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+  }
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable 'GradleCompatible'
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+}
+
+repositories {
+  mavenCentral()
+  google()
+  maven { url 'https://jitpack.io' }
+
+  def found = false
+  def defaultDir = null
+  def androidSourcesName = 'React Native sources'
+
+  if (rootProject.ext.has('reactNativeAndroidRoot')) {
+    defaultDir = rootProject.ext.get('reactNativeAndroidRoot')
+  } else {
+    defaultDir = new File(
+      projectDir,
+      '/../../../node_modules/react-native/android'
+    )
+  }
+
+  if (defaultDir.exists()) {
+    maven {
+      url defaultDir.toString()
+      name androidSourcesName
+    }
+
+    logger.info(":${project.name}:reactNativeAndroidRoot ${defaultDir.canonicalPath}")
+    found = true
+  } else {
+    def parentDir = rootProject.projectDir
+
+    1.upto(5, {
+      if (found) return true
+      parentDir = parentDir.parentFile
+
+      def androidSourcesDir = new File(
+        parentDir,
+        'node_modules/react-native'
+      )
+
+      def androidPrebuiltBinaryDir = new File(
+        parentDir,
+        'node_modules/react-native/android'
+      )
+
+      if (androidPrebuiltBinaryDir.exists()) {
+        maven {
+          url androidPrebuiltBinaryDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidPrebuiltBinaryDir.canonicalPath}")
+        found = true
+      } else if (androidSourcesDir.exists()) {
+        maven {
+          url androidSourcesDir.toString()
+          name androidSourcesName
+        }
+
+        logger.info(":${project.name}:reactNativeAndroidRoot ${androidSourcesDir.canonicalPath}")
+        found = true
+      }
+    })
+  }
+
+  if (!found) {
+    throw new GradleException(
+      "${project.name}: unable to locate React Native android sources. " +
+        "Ensure you have you installed React Native as a dependency in your project and try again."
+    )
+  }
+}
+
+def kotlin_version = getExtOrDefault('kotlinVersion')
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
+  implementation 'com.github.tryVital.vital-android:VitalClient:v1.0.0-alpha.7'
+  implementation 'com.github.tryVital.vital-android:VitalDevices:v1.0.0-alpha.7'
+// From node_modules
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "VitalDevicesReactNative"
+    codegenJavaPackageName = "com.vitaldevicesreactnative"
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+VitalDevicesReactNative_kotlinVersion=1.7.0
+VitalDevicesReactNative_minSdkVersion=26
+VitalDevicesReactNative_targetSdkVersion=33
+VitalDevicesReactNative_compileSdkVersion=33
+VitalDevicesReactNative_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.vitaldevicesreactnative">
+
+</manifest>

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

@@ -0,0 +1,24 @@
+package com.vitaldevicesreactnative
+
+sealed class VitalDevicesEvent(val value: String) {
+  object ScanEvent : VitalDevicesEvent("ScanEvent")
+  object PairEvent : VitalDevicesEvent("PairEvent")
+  object GlucoseMeterReadEvent : VitalDevicesEvent("GlucoseMeterReadEvent")
+  object BloodPressureReadEvent : VitalDevicesEvent("BloodPressureReadEvent")
+
+  companion object {
+    fun values(): Array<VitalDevicesEvent> {
+      return arrayOf(ScanEvent, PairEvent, GlucoseMeterReadEvent, BloodPressureReadEvent)
+    }
+
+    fun valueOf(value: String): VitalDevicesEvent {
+      return when (value) {
+        "ScanEvent" -> ScanEvent
+        "PairEvent" -> PairEvent
+        "GlucoseMeterReadEvent" -> GlucoseMeterReadEvent
+        "BloodPressureReadEvent" -> BloodPressureReadEvent
+        else -> throw IllegalArgumentException("Invalid VitalDevicesEvent value: $value")
+      }
+    }
+  }
+}

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

@@ -0,0 +1,272 @@
+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.vitaldevices.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.flowOn
+
+
+class VitalDevicesReactNativeModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val vitalDeviceManager = VitalDeviceManager(reactContext)
+  private val scannedDevices: MutableList<ScannedDevice> = mutableListOf()
+  private var mainScope: CoroutineScope? = null
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  private fun startScanForDevice(
+    id: String,
+    name: String,
+    brand: String,
+    kind: String,
+    promise: Promise
+  ) {
+    val deviceModel = DeviceModel(
+      id = id,
+      name = name,
+      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("id", 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) {
+          sendEvent(VitalDevicesEvent.ScanEvent, WritableNativeMap().apply {
+            putString("error", e.message)
+          })
+        }
+      }
+    }
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun stopScanForDevice(promise: Promise) {
+    mainScope?.cancel()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun pair(scannedDeviceId: String, promise: Promise) {
+    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.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  private fun startReadingGlucoseMeter(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.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  private fun startReadingBloodPressure(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.resolve(null)
+    }
+  }
+
+  private fun WritableNativeMap.mapSample(it: QuantitySample) {
+    putString("id", it.id)
+    putString("value", it.value)
+    putString("unit", it.unit)
+    putString("startDate", it.startDate.time.toString())
+    putString("endDate", it.endDate.time.toString())
+    putString("type", it.type)
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  private fun sendEvent(event: VitalDevicesEvent, params: Any) {
+    try {
+      reactApplicationContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(event.value, params)
+    } catch (e: Exception) {
+      Log.e("VitalDevices", "sendEvent: $e")
+    }
+  }
+
+  override fun getConstants(): MutableMap<String, Any> {
+    return VitalDevicesEvent.values().associate { it.value to it.value }.toMutableMap()
+  }
+
+  private fun kindToString(kind: Kind): String {
+    return when (kind) {
+      Kind.GlucoseMeter -> "glucoseMeter"
+      Kind.BloodPressure -> "bloodPressure"
+    }
+  }
+
+  private fun brandToString(brand: Brand): String {
+    return when (brand) {
+      Brand.Omron -> "omron"
+      Brand.AccuChek -> "accuChek"
+      Brand.Contour -> "contour"
+      Brand.Beurer -> "beurer"
+      Brand.Libre -> "libre"
+    }
+  }
+
+  private fun stringToBrand(string: String): Brand {
+    return when (string) {
+      "omron" -> Brand.Omron
+      "accuChek" -> Brand.AccuChek
+      "contour" -> Brand.Contour
+      "beurer" -> Brand.Beurer
+      "libre" -> Brand.Libre
+      else -> throw Exception("Unsupported brand $string")
+    }
+  }
+
+  private fun stringToKind(string: String): Kind {
+    return when (string) {
+      "bloodPressure" -> Kind.BloodPressure
+      "glucoseMeter" -> Kind.GlucoseMeter
+      else -> throw Exception("Unsupported kind $string")
+    }
+  }
+
+  companion object {
+    const val NAME = "VitalDevicesReactNative"
+  }
+}

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

@@ -0,0 +1,16 @@
+package com.vitaldevicesreactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class VitalDevicesReactNativePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(VitalDevicesReactNativeModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/ios/VitalDevicesReactNative-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/VitalDevicesReactNative.m

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(VitalDevicesReactNative, NSObject)
+
+RCT_EXTERN_METHOD(multiply:(float)a withB:(float)b
+                 withResolver:(RCTPromiseResolveBlock)resolve
+                 withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/VitalDevicesReactNative.swift

@@ -0,0 +1,8 @@
+@objc(VitalDevicesReactNative)
+class VitalDevicesReactNative: NSObject {
+
+  @objc(multiply:withB:withResolver:withRejecter:)
+  func multiply(a: Float, b: Float, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) -> Void {
+    resolve(a*b)
+  }
+}