react-native-rook-sdk 0.2.0

package/android/src/main/java/com/rooksdk/RookSdkModule.kt

@@ -0,0 +1,575 @@
+package com.rooksdk
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+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.facebook.react.modules.core.DeviceEventManagerModule
+import com.rookmotion.rook.sdk.RookConfigurationManager
+import com.rookmotion.rook.sdk.RookEventManager
+import com.rookmotion.rook.sdk.RookHealthPermissionsManager
+import com.rookmotion.rook.sdk.RookHelpers
+import com.rookmotion.rook.sdk.RookSummaryManager
+import com.rookmotion.rook.sdk.domain.enums.HealthPermission
+import com.rookmotion.rook.sdk.domain.environment.RookAndroidClass
+import com.rookmotion.rook.sdk.domain.environment.RookEnvironment
+import com.rookmotion.rook.sdk.domain.model.RookConfiguration
+import com.rookmotion.rook.sdk.RookStepsTracker
+import com.rookmotion.rook.sdk.domain.enums.HealthDataType
+import com.rookmotion.rook.sdk.domain.model.SyncStatus
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+class RookSdkModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private val rookConfigurationManager = RookConfigurationManager(reactApplicationContext)
+  private val rookHealthPermissionsManager = RookHealthPermissionsManager(rookConfigurationManager)
+  private val rookSummaryManager = RookSummaryManager(rookConfigurationManager)
+  private val rookEventManager = RookEventManager(rookConfigurationManager)
+  private var scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+  private var stepsScope: CoroutineScope? = null
+  private var listenerCount = 0
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    listenerCount += 1
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    listenerCount -= count
+    if (listenerCount == 0) {
+      stepsScope?.cancel()
+    }
+  }
+
+  private fun determinePermissionValue(permissionString: String): HealthPermission {
+    return when (permissionString) {
+      "SLEEP" -> HealthPermission.SLEEP
+      "PHYSICAL" -> HealthPermission.PHYSICAL
+      "BODY" -> HealthPermission.BODY
+      "ALL" -> HealthPermission.ALL
+      else -> HealthPermission.ALL
+    }
+  }
+  private fun determineSummaryValue(summaryString: String): HealthDataType {
+    return when (summaryString) {
+      "SLEEP" -> HealthDataType.SLEEP_SUMMARY
+      "PHYSICAL" -> HealthDataType.PHYSICAL_SUMMARY
+      "BODY" -> HealthDataType.BODY_SUMMARY
+      "BLOOD_GLUCOSE_EVENT" -> HealthDataType.BLOOD_GLUCOSE_BODY_EVENT
+      "BLOOD_PRESSURE_EVENT" -> HealthDataType.BLOOD_PRESSURE_BODY_EVENT
+      "BODY_METRICS_EVENT" -> HealthDataType.BODY_METRICS_EVENT
+      "HEART_RATE_EVENT" -> HealthDataType.HEART_RATE_BODY_EVENT
+      "HYDRATION_EVENT" -> HealthDataType.HYDRATION_BODY_EVENT
+      "NUTRITION_EVENT" -> HealthDataType.NUTRITION_BODY_EVENT
+      "OXYGENATION_EVENT" -> HealthDataType.OXYGENATION_BODY_EVENT
+      "PHYSICAL_EVENT" -> HealthDataType.PHYSICAL_EVENT
+      "TEMPERATURE_EVENT" -> HealthDataType.TEMPERATURE_BODY_EVENT
+      else -> HealthDataType.SLEEP_SUMMARY
+    }
+  }
+
+  @ReactMethod
+  fun getUserID(promise: Promise) {
+    try {
+      promise.resolve(rookConfigurationManager.getUserID())
+    }
+    catch (e: Exception) {
+      promise.reject(e)
+    }
+  }
+
+  @ReactMethod
+  fun updateUserID(userID: String, promise: Promise) {
+    scope.launch {
+      try {
+        rookConfigurationManager.updateUserID(userID)
+        promise.resolve(true)
+      }
+      catch (e: Exception) {
+        promise.reject(e)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun clearUserID(promise: Promise) {
+    try {
+      rookConfigurationManager.clearUserID()
+      promise.resolve(true)
+    }
+    catch (e: Exception) {
+      promise.reject(e)
+    }
+
+  }
+
+  @ReactMethod
+  fun removeUserFromRook(promise: Promise) {
+    scope.launch {
+      val result = rookConfigurationManager.deleteUserFromRook()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncUserTimeZone(promise: Promise) {
+    scope.launch {
+      val result = rookConfigurationManager.syncUserTimeZone()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+
+
+  @ReactMethod
+  fun initRook(config: ReadableMap,promise: Promise) {
+    try {
+
+      var environment = RookEnvironment.SANDBOX
+
+      if (config.getString("environment") == "production")
+        environment = RookEnvironment.PRODUCTION
+
+      if (config.getString("environment") == "development") RookAndroidClass.test()
+      else RookAndroidClass.disableTest()
+
+      val rookConfiguration = RookConfiguration(
+        environment = environment,
+        clientUUID = config.getString("clientUUID") ?: "",
+        secretKey = config.getString("password") ?: ""
+      )
+
+      rookConfigurationManager.enableLocalLogs()
+      rookConfigurationManager.setConfiguration(rookConfiguration)
+
+      scope.launch {
+        val result = rookConfigurationManager.initRook()
+
+        result.fold(
+          {
+            promise.resolve(true)
+          },
+          {
+            promise.reject(it)
+          }
+        )
+      }
+    }
+    catch (e: Exception) {
+      promise.reject(e)
+    }
+
+  }
+
+  // MARK: - Permissions
+  @ReactMethod
+  fun checkAvailability(promise: Promise) {
+
+    promise.resolve(RookHealthPermissionsManager.checkAvailability(reactApplicationContext).toString())
+
+  }
+
+  @ReactMethod
+  fun openHealthConnectSettings(promise: Promise) {
+    scope.launch {
+
+      val result = rookHealthPermissionsManager.openHealthConnectSettings()
+
+      result.fold({
+        promise.resolve(true)
+      },{
+        promise.reject(it)
+      })
+
+    }
+  }
+
+  @ReactMethod
+  fun checkPermissions(permission: String, promise: Promise) {
+    scope.launch {
+      val result = rookHealthPermissionsManager.checkPermissions(determinePermissionValue(permission));
+
+      result.fold({
+        promise.resolve(it)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun requestPermissions(permission: String, promise: Promise) {
+    val activity = reactApplicationContext.currentActivity
+
+    if (activity == null) {
+      promise.reject(Exception("Error trying to request permissions"))
+      return
+    }
+
+    try {
+
+      HealthConnectPermissionsActivity.launch(activity, determinePermissionValue(permission))
+      promise.resolve(true)
+
+    }
+    catch (e: Exception) {
+      promise.reject(e)
+    }
+
+  }
+
+
+  // MARK: - Sync Summaries
+  @ReactMethod
+  fun shouldSyncFor(summaryString: String, date: String,promise: Promise) {
+    scope.launch {
+      RookHelpers.shouldSyncFor(
+        healthDataType = determineSummaryValue(summaryString),
+        localDate = RookDateTime.stringToLocalDate(date)
+      ).fold({
+        promise.resolve(it)
+      },{
+        promise.reject(it)
+      })
+    }
+  }
+
+  // Sleep
+  @ReactMethod
+  fun syncYesterdaySummaries(promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncYesterdaySummaries();
+
+      promise.resolve(true);
+    }
+  }
+
+  @ReactMethod
+  fun syncSleepSummary(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncSleepSummary(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  // Body
+  @ReactMethod
+  fun syncBodySummary(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncBodySummary(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  // Physical
+  @ReactMethod
+  fun syncPhysicalSummary(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncPhysicalSummary(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncPendingSummaries(promise: Promise) {
+    scope.launch {
+      val result = rookSummaryManager.syncPendingSummaries()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  // MARK: - Events
+
+  @ReactMethod
+  fun syncYesterdayEvents(promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncYesterdayEvents();
+
+      promise.resolve(true);
+    }
+  }
+  @ReactMethod
+  fun syncPhysicalEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPhysicalEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncBloodGlucoseEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBloodGlucoseEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncBloodPressureEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBloodPressureEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncBodyMetricsEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBodyMetricsEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncBodyHeartRateEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBodyHeartRateEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncPhysicalHeartRateEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPhysicalHeartRateEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncNutritionEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncNutritionEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncHydrationEvents(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncHydrationEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+  @ReactMethod
+  fun syncPhysicalOxygenationEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPhysicalOxygenationEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncBodyOxygenationEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncBodyOxygenationEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncTemperatureEvent(date: String, promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncTemperatureEvents(RookDateTime.stringToLocalDate(date))
+
+      result.fold({
+        if (it == SyncStatus.SYNCED) promise.resolve(true)
+        else promise.resolve(false)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun syncPendingEvents(promise: Promise) {
+    scope.launch {
+      val result = rookEventManager.syncPendingEvents()
+
+      result.fold({
+        promise.resolve(true)
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  // MARK: - Steps
+  @ReactMethod
+  fun isStepsAvailable(promise: Promise) {
+    promise.resolve(RookStepsTracker.isAvailable(reactApplicationContext))
+  }
+
+  @ReactMethod
+  fun hasStepsPermissions(promise: Promise) {
+    promise.resolve(RookStepsTracker.hasPermissions(reactApplicationContext))
+  }
+
+  @ReactMethod
+  fun requestStepsPermissions(promise: Promise) {
+    RookStepsTracker.requestPermissions(reactApplicationContext)
+    promise.resolve(true)
+  }
+
+  @ReactMethod
+  fun startSteps(promise: Promise) {
+    RookStepsTracker.start(reactApplicationContext).fold({
+      promise.resolve(true)
+    }, {
+      promise.reject(it)
+    })
+  }
+
+  @ReactMethod
+  fun stopSteps(promise: Promise) {
+    RookStepsTracker.stop(reactApplicationContext).fold({
+      stepsScope?.cancel()
+      promise.resolve(true)
+    }, {
+      promise.reject(it)
+    })
+  }
+
+  @ReactMethod
+  fun isStepsActive(promise: Promise) {
+    scope.launch {
+      val response = RookStepsTracker.isActive()
+      promise.resolve(response)
+    }
+  }
+
+  @ReactMethod
+  fun getTodaySteps(promise: Promise) {
+    scope.launch {
+      RookStepsTracker.getTodaySteps().fold({
+        promise.resolve(it.toString())
+      }, {
+        promise.reject(it)
+      })
+    }
+  }
+
+  @ReactMethod
+  fun observeTodaySteps(promise: Promise) {
+    if (stepsScope == null) stepsScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+
+    stepsScope?.launch {
+      RookStepsTracker.observeTodaySteps().collect {
+        reactApplicationContext
+          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+          .emit("RookStepsUpdate", Arguments.createMap().putString("steps", it.toString()))
+      }
+    }
+
+    promise.resolve(true)
+  }
+
+  companion object {
+    const val NAME = "RookSdk"
+  }
+}

package/android/src/main/java/com/rooksdk/RookSdkPackage.kt

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

package/android/src/main/res/drawable/ic_health_connect.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+  android:width="200dp"
+  android:height="200dp"
+  android:viewportWidth="512"
+  android:viewportHeight="512">
+  <path
+    android:fillColor="#4285F4"
+    android:pathData="M258.3,431.3c-35.1,0 -68.1,-13.3 -92.9,-37.6l44.2,-45.4c26.9,26.2 70.6,26.2 97.6,0l94.4,-92c12.7,-12.4 19.8,-28.9 19.8,-46.3s-7,-33.9 -19.8,-46.3c-26.9,-26.2 -70.6,-26.2 -97.6,0l-17.1,16.7L242.6,135l17.1,-16.7c25,-24.3 58,-37.6 93,-37.6c35.1,0 68.1,13.3 92.9,37.6c25.1,24.4 38.9,57 38.9,91.7s-13.8,67.2 -38.9,91.7l-94.4,92.1C326.4,417.9 293.4,431.3 258.3,431.3z" />
+  <path
+    android:fillColor="#3DDB85"
+    android:pathData="M165.6,393.7L66.5,302l-0.3,-0.3c-25.1,-24.4 -38.9,-57 -38.9,-91.7s13.8,-67.2 38.9,-91.7c24.9,-24.2 57.9,-37.6 92.9,-37.6c35.1,0 68.1,13.3 93,37.5l25.2,24.6l-44.2,45.4L208,163.7c-26.9,-26.2 -70.7,-26.2 -97.6,0c-12.7,12.4 -19.8,28.9 -19.8,46.3c0,17.3 6.9,33.7 19.5,46.1l98.5,91.2L165.6,393.7z" />
+  <path
+    android:fillColor="#4285F4"
+    android:pathData="M165.3,393.7c-24.9,-24.2 -38.6,-56.5 -38.8,-90.9c-0.1,-35.1 13.9,-68.4 39.5,-93.7l0.2,-0.2l91.4,-88.5l44.1,45.5l-91.2,88.4c-13.4,13.3 -20.7,30.4 -20.6,48.3c0.1,17.3 7,33.5 19.6,45.8L165.3,393.7z" />
+  <path
+    android:fillColor="#3DDB85"
+    android:pathData="M302.5,211.3a50.7,50.7 0,1 0,101.4 0a50.7,50.7 0,1 0,-101.4 0z" />
+</vector>

package/android/src/main/res/layout/activity_health_connect_permissions.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent"
+  tools:context=".HealthConnectPermissionsActivity">
+
+  <ImageView
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_centerInParent="true"
+    android:contentDescription="@null"
+    android:importantForAccessibility="2"
+    android:src="@drawable/ic_health_connect" />
+</RelativeLayout>

package/android/src/main/res/values/themes.xml

@@ -0,0 +1,3 @@
+<resources>
+  <style name="HealthConnectTheme" parent="Theme.AppCompat.DayNight.NoActionBar"/>
+</resources>

package/ios/RookSdk.h

@@ -0,0 +1,13 @@
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNRookSdkSpec.h"
+
+@interface RookSdk : RCTEventEmitter <NativeRookSdkSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface RookSdk : RCTEventEmitter <RCTBridgeModule>
+#endif
+
+@end