@tryvital/vital-health-react-native 0.3.2 → 1.1.0

package/android/build.gradle

@@ -134,6 +134,11 @@ dependencies {
     //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
+  implementation 'com.github.tryVital.vital-android:VitalClient:v1.0.0-alpha.16'
+  implementation 'com.github.tryVital.vital-android:VitalHealthConnect:v1.0.0-alpha.16'
+  implementation "androidx.health.connect:connect-client:1.0.0-alpha08"
 // From node_modules
 }
 

package/android/gradle.properties

@@ -1,5 +1,5 @@
 VitalHealthReactNative_kotlinVersion=1.7.0
-VitalHealthReactNative_minSdkVersion=21
+VitalHealthReactNative_minSdkVersion=26
 VitalHealthReactNative_targetSdkVersion=31
 VitalHealthReactNative_compileSdkVersion=31
 VitalHealthReactNative_ndkversion=21.4.7075529

package/android/src/main/java/com/vitalhealthreactnative/VitalHealthEvent.kt

@@ -0,0 +1,19 @@
+package com.vitalhealthreactnative
+
+sealed class VitalHealthEvent(val value: String) {
+  object Status : VitalHealthEvent("Status")
+
+  companion object {
+    fun values(): Array<VitalHealthEvent> {
+      return arrayOf(Status)
+    }
+
+    fun valueOf(value: String): VitalHealthEvent {
+      return when (value) {
+        "Status" -> Status
+        else -> throw IllegalArgumentException("Invalid VitalHealthEvent value: $value")
+      }
+    }
+  }
+
+}

package/android/src/main/java/com/vitalhealthreactnative/VitalHealthReactNativeModule.kt

@@ -1,49 +1,410 @@
 package com.vitalhealthreactnative
 
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
+import android.app.Activity
+import android.content.Intent
+import android.util.Log
+import androidx.health.connect.client.PermissionController
+import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.records.*
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import io.tryvital.client.Environment
+import io.tryvital.client.Region
+import io.tryvital.client.VitalClient
+import io.tryvital.client.utils.VitalLogger
+import io.tryvital.vitalhealthconnect.VitalHealthConnectManager
+import io.tryvital.vitalhealthconnect.model.HealthResource
+import io.tryvital.vitalhealthconnect.model.SyncStatus
+import kotlinx.coroutines.*
+import java.time.Instant
+import kotlin.reflect.KClass
 
 class VitalHealthReactNativeModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+  ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+  private val logger = VitalLogger.create()
+
+  private var vitalClient: VitalClient? = null
+  private var vitalHealthConnectManager: VitalHealthConnectManager? = null
+
+  private var askForResourcesResult: Promise? = null
+  private var askedHealthPermissions: Set<HealthPermission>? = null
+
+  private var mainScope: CoroutineScope? = null
+  private var statusScope: CoroutineScope? = null
+  private var writeScope: CoroutineScope? = null
 
   override fun getName(): String {
     return NAME
   }
 
+  init {
+    reactContext.addActivityEventListener(this)
+  }
+
   @ReactMethod
   fun configure(
-    backgroundDeliveryEnabled: Boolean,
+    syncOnAppStart: Boolean,
     numberOfDaysToBackFill: Int,
     enableLogs: Boolean,
     promise: Promise
   ) {
+    if (vitalClient == null) {
+      promise.reject(
+        "VitalClient is not configured",
+        "VitalClient is not configured",
+      )
+    }
+
+    vitalHealthConnectManager = VitalHealthConnectManager.create(
+      reactApplicationContext,
+      vitalClient!!.apiKey,
+      vitalClient!!.region,
+      vitalClient!!.environment
+    )
+
+    mainScope?.cancel()
+    mainScope = MainScope()
+    mainScope!!.launch {
+      vitalHealthConnectManager!!.configureHealthConnectClient(
+        logsEnabled = enableLogs,
+        syncOnAppStart = syncOnAppStart,
+        numberOfDaysToBackFill = numberOfDaysToBackFill,
+      )
+    }
+
+    startStatusUpdate()
+
     promise.resolve(null)
   }
 
   @ReactMethod
-  fun askForResources(resources: List<String>, promise: Promise) {
+  fun setUserId(userId: String, promise: Promise) {
+    if (vitalHealthConnectManager == null) {
+      promise.reject(
+        "VitalHealthConnect is not configured",
+        "VitalHealthConnect is not configured",
+      )
+      return
+    }
+
+    mainScope?.cancel()
+    mainScope = MainScope()
+    mainScope!!.launch {
+      vitalHealthConnectManager!!.setUserId(userId)
+      promise.resolve(null)
+    }
+  }
+
+  @ReactMethod
+  fun configureClient(
+    apiKey: String,
+    environment: String,
+    region: String,
+    enableLogs: Boolean,
+    promise: Promise
+  ) {
+    logger.enabled = enableLogs
+
+    vitalClient = VitalClient(
+      reactApplicationContext,
+      stringToRegion(region),
+      stringToEnvironment(environment),
+      apiKey
+    )
+
     promise.resolve(null)
   }
 
+  @ReactMethod
+  fun askForResources(
+    resources: ReadableArray,
+    promise: Promise
+  ) {
+    return ask(resources, null, promise)
+  }
+
+  @ReactMethod
+  fun ask(
+    readResources: ReadableArray,
+    writeResources: ReadableArray?,
+    promise: Promise
+  ) {
+    val requestPermissionActivityContract =
+      PermissionController.createRequestPermissionResultContract()
+    val healthPermissions =
+      readResources.toArrayList().toList().map { mapReadResourceToHealthRecord(it as String) }
+        .flatten()
+        .map { HealthPermission.createReadPermission(it) }.toSet().plus(
+          writeResources?.toArrayList()?.toList()
+            ?.map { mapWriteResourceToHealthRecord(it as String) }
+            ?.flatten()
+            ?.map { HealthPermission.createWritePermission(it) }?.toSet() ?: emptySet()
+        )
+
+    askForResourcesResult = promise
+    askedHealthPermissions = healthPermissions
+
+    currentActivity?.startActivityForResult(
+      requestPermissionActivityContract.createIntent(
+        reactApplicationContext,
+        healthPermissions
+      ), 666
+    )
+  }
+
   @ReactMethod
   fun hasAskedForPermission(resource: String, promise: Promise) {
-    promise.resolve(null)
+    promise.resolve(false)
   }
 
   @ReactMethod
-  fun syncData(resources: List<String>, promise: Promise) {
-    promise.resolve(null)
+  fun syncData(resources: ReadableArray, promise: Promise) {
+    if (vitalHealthConnectManager == null) {
+      promise.reject(
+        "VitalHealthConnect is not configured",
+        "VitalHealthConnect is not configured",
+      )
+      return
+    }
+
+    mainScope?.cancel()
+    mainScope = MainScope()
+    mainScope!!.launch {
+      vitalHealthConnectManager!!.syncData(
+        resources.toArrayList().toList().mapNotNull { mapStringToHealthResource(it as String) }
+          .toSet()
+      )
+      promise.resolve(null)
+    }
   }
 
   @ReactMethod
   fun cleanUp(promise: Promise) {
+    statusScope?.cancel()
+    writeScope?.cancel()
+    mainScope?.cancel()
+
     promise.resolve(null)
   }
 
+  @ReactMethod
+  private fun writeHealthData(
+    resource: String,
+    startDate: Long,
+    endDate: Long,
+    value: Double,
+    promise: Promise
+  ) {
+    if (vitalHealthConnectManager == null) {
+      promise.reject(
+        "VitalHealthConnect is not configured",
+        "VitalHealthConnect is not configured",
+      )
+      return
+    }
+
+    writeScope?.cancel()
+    writeScope = MainScope()
+    writeScope!!.launch {
+      try {
+        vitalHealthConnectManager!!.addHealthResource(
+          mapStringToHealthResource(resource)!!,
+          startDate = Instant.ofEpochMilli(startDate),
+          endDate = Instant.ofEpochMilli(endDate),
+          value = value,
+        )
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          "Failed to write data",
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  @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 startStatusUpdate() {
+    statusScope?.cancel()
+    statusScope = MainScope()
+    statusScope?.launch {
+      try {
+        withContext(Dispatchers.Default) {
+          vitalHealthConnectManager?.status?.collect {
+            logger.logI("Status: $it")
+            withContext(Dispatchers.Main) {
+              when (it) {
+                is SyncStatus.ResourceSyncFailed -> {
+                  sendEvent(VitalHealthEvent.Status, WritableNativeMap().apply {
+                    putString("status", "failedSyncing")
+                    putString("resource", it.resource.name)
+                  })
+                }
+                is SyncStatus.ResourceNothingToSync -> {
+                  sendEvent(VitalHealthEvent.Status, WritableNativeMap().apply {
+                    putString("status", "nothingToSync")
+                    putString("resource", it.resource.name)
+                  })
+                }
+                is SyncStatus.ResourceSyncing -> {
+                  sendEvent(VitalHealthEvent.Status, WritableNativeMap().apply {
+                    putString("status", "syncing")
+                    putString("resource", it.resource.name)
+                  })
+                }
+                is SyncStatus.ResourceSyncingComplete -> {
+                  sendEvent(VitalHealthEvent.Status, WritableNativeMap().apply {
+                    putString("status", "successSyncing")
+                    putString("resource", it.resource.name)
+                  })
+                }
+                SyncStatus.SyncingCompleted -> {
+                  sendEvent(VitalHealthEvent.Status, WritableNativeMap().apply {
+                    putString("status", "syncingCompleted")
+                  })
+                }
+                SyncStatus.Unknown -> {
+                  sendEvent(VitalHealthEvent.Status, WritableNativeMap().apply {
+                    putString("status", "unknown")
+                  })
+                }
+              }
+            }
+          }
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          sendEvent(VitalHealthEvent.Status, WritableNativeMap().apply {
+            putString("status", "failedSyncing")
+          })
+        }
+      }
+    }
+  }
+
+  private fun sendEvent(event: VitalHealthEvent, params: Any) {
+    try {
+      reactApplicationContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(event.value, params)
+    } catch (e: Exception) {
+      Log.e("VitalHealth", "sendEvent: $e")
+    }
+  }
+
+  override fun getConstants(): MutableMap<String, Any> {
+    return VitalHealthEvent.values().associate { it.value to it.value }.toMutableMap()
+  }
 
   companion object {
     const val NAME = "VitalHealthReactNative"
   }
+
+  override fun onActivityResult(p0: Activity?, p1: Int, p2: Int, p3: Intent?) {
+    if (p1 == 666) {
+      mainScope?.cancel()
+      mainScope = MainScope()
+      mainScope!!.launch {
+        val grantedPermissions =
+          vitalHealthConnectManager!!.getGrantedPermissions(reactApplicationContext).toSet()
+
+        val notGrantedPermissions = (askedHealthPermissions
+          ?: emptySet()).filter { !grantedPermissions.contains(it) }
+
+        if (notGrantedPermissions.isEmpty()) {
+          askForResourcesResult?.resolve(true)
+        } else {
+          vitalClient?.vitalLogger?.logI("Not granted permissions: $notGrantedPermissions")
+          askForResourcesResult?.resolve(false)
+        }
+        askedHealthPermissions = null
+        askForResourcesResult = null
+      }
+    }
+  }
+
+  override fun onNewIntent(p0: Intent?) {
+    // Not used
+  }
+}
+
+private fun stringToRegion(region: String): Region {
+  when (region) {
+    "eu" -> return Region.EU
+    "us" -> return Region.US
+  }
+
+  throw Exception("Unsupported region $region")
+}
+
+private fun stringToEnvironment(environment: String): Environment {
+  when (environment) {
+    "production" -> return Environment.Production
+    "sandbox" -> return Environment.Sandbox
+    "dev" -> return Environment.Dev
+  }
+
+  throw Exception("Unsupported environment $environment")
+}
+
+private fun mapReadResourceToHealthRecord(resource: String): List<KClass<out Record>> {
+  when (resource) {
+    "profile" -> return listOf(HeightRecord::class, WeightRecord::class)
+    "body" -> return listOf(BodyFatRecord::class)
+    "workout" -> return listOf(ExerciseSessionRecord::class)
+    "activity" -> return listOf(
+      ActiveCaloriesBurnedRecord::class,
+      BasalMetabolicRateRecord::class,
+      StepsRecord::class,
+      DistanceRecord::class,
+      FloorsClimbedRecord::class,
+      Vo2MaxRecord::class
+    )
+    "sleep" -> return listOf(SleepSessionRecord::class)
+    "glucose" -> return listOf(BloodGlucoseRecord::class)
+    "bloodPressure" -> return listOf(BloodPressureRecord::class)
+    "heartRate" -> return listOf(HeartRateVariabilitySdnnRecord::class)
+    "steps" -> return listOf(StepsRecord::class)
+    "activeEnergyBurned" -> return listOf(ActiveCaloriesBurnedRecord::class)
+    "basalEnergyBurned" -> return listOf(BasalMetabolicRateRecord::class)
+    "water" -> return listOf(HydrationRecord::class)
+  }
+  return listOf()
+}
+
+private fun mapWriteResourceToHealthRecord(resource: String): List<KClass<out Record>> {
+  when (resource) {
+    "water" -> return listOf(HydrationRecord::class)
+  }
+
+  return listOf()
+}
+
+private fun mapStringToHealthResource(resource: String): HealthResource? {
+  return when (resource) {
+    "profile" -> return HealthResource.Profile
+    "body" -> return HealthResource.Body
+    "workout" -> return HealthResource.Workout
+    "activity" -> return HealthResource.Activity
+    "sleep" -> return HealthResource.Sleep
+    "glucose" -> return HealthResource.Glucose
+    "bloodPressure" -> return HealthResource.BloodPressure
+    "heartRate" -> return HealthResource.HeartRate
+    "steps" -> return HealthResource.Steps
+    "activeEnergyBurned" -> return HealthResource.ActiveEnergyBurned
+    "basalEnergyBurned" -> return HealthResource.BasalEnergyBurned
+    "water" -> return HealthResource.Water
+    else -> null
+  }
 }

package/ios/VitalHealthReactNative.m

@@ -8,6 +8,17 @@ RCT_EXTERN_METHOD(configure:(BOOL)backgroundDeliveryEnabled
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(setUserId:(NSString *)userId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(configureClient:(NSString *)apiKey
+                  environment:(NSString *)environment
+                  region:(NSString *)region
+                  enableLogs:(BOOL)enableLogs
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(askForResources:(NSArray<NSString *> *)resources
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)

package/ios/VitalHealthReactNative.swift

@@ -41,12 +41,12 @@ class VitalHealthReactNative: RCTEventEmitter {
           payload["status"] = "completed"
       }
 
-      self.sendEvent(withName: "status", body: payload)
+      self.sendEvent(withName: "Status", body: payload)
     }
   }
 
   override func supportedEvents() -> [String]! {
-    return ["status"]
+    return ["Status"]
   }
 
   @objc(configure:numberOfDaysToBackFill:enableLogs:resolver:rejecter:)
@@ -69,6 +69,49 @@ class VitalHealthReactNative: RCTEventEmitter {
     }
   }
 
+   @objc(setUserId:resolver:rejecter:)
+    func setUserId(_ userId: String, resolve: @escaping RCTPromiseResolveBlock, reject:RCTPromiseRejectBlock) {
+      guard let userId = UUID.init(uuidString: userId) else {
+        reject(nil, "userId must be an UUID", nil)
+        return
+      }
+
+      Task {
+        await VitalClient.setUserId(userId)
+        resolve(())
+      }
+    }
+
+    @objc(configureClient:environment:region:enableLogs:resolver:rejecter:)
+    func configureClient(
+      _ apiKey: String,
+      environment: String,
+      region: String,
+      enableLogs: Bool,
+      resolve:@escaping RCTPromiseResolveBlock,
+      reject:RCTPromiseRejectBlock
+    ) {
+
+      let env: Environment
+      switch (environment, region) {
+        case ("production", "us"):
+          env = .production(.us)
+        case ("production", "eu"):
+          env = .production(.eu)
+        case ("sandbox", "us"):
+          env = .sandbox(.us)
+        case ("sandbox", "eu"):
+          env = .sandbox(.eu)
+        default:
+          reject(nil, "enviroment / region values not accepted", nil)
+          return
+      }
+
+      Task {
+        await VitalClient.configure(apiKey: apiKey, environment: env, configuration: .init(logsEnable: enableLogs))
+        resolve(())
+      }
+    }
 
   @objc(ask:writeResources:resolver:rejecter:)
   func ask(

package/lib/health_config.d.ts

@@ -0,0 +1,13 @@
+export declare class HealthConfig {
+    logsEnabled: boolean;
+    numberOfDaysToBackFill: number;
+    androidConfig: AndroidHealthConfig;
+    iOSConfig: IOSHealthConfig;
+}
+export declare class AndroidHealthConfig {
+    syncOnAppStart: boolean;
+}
+export declare class IOSHealthConfig {
+    dataPushMode: string;
+    backgroundDeliveryEnabled: boolean;
+}

package/lib/health_config.js

@@ -0,0 +1,13 @@
+export class HealthConfig {
+    logsEnabled = true;
+    numberOfDaysToBackFill = 90;
+    androidConfig = new AndroidHealthConfig();
+    iOSConfig = new IOSHealthConfig();
+}
+export class AndroidHealthConfig {
+    syncOnAppStart = true;
+}
+export class IOSHealthConfig {
+    dataPushMode = 'automatic';
+    backgroundDeliveryEnabled = true;
+}

package/lib/index.d.ts

@@ -1,7 +1,14 @@
 import { NativeEventEmitter } from 'react-native';
+import type { HealthConfig } from './health_config';
+export declare const VitalHealthReactNativeModule: any;
+export declare const VitalHealthEvents: {
+    statusEvent: string;
+};
 export declare class VitalHealth {
     static status: NativeEventEmitter;
-    static configure(backgroundDeliveryEnabled: boolean, numberOfDaysToBackFill: number, enableLogs: boolean): Promise<void>;
+    static configure(healthConfig: HealthConfig): Promise<void>;
+    static setUserId(userId: string): Promise<void>;
+    static configureClient(apiKey: string, environment: string, region: string, enableLogs: boolean): Promise<void>;
     static askForResources(resources: VitalResource[]): Promise<void>;
     static ask(readResources: VitalResource[], writeResources: VitalWriteResource[]): Promise<void>;
     static writeHealthData(resource: VitalWriteResource, value: number, startDate: Date, endDate: Date): Promise<void>;

package/lib/index.js

@@ -10,10 +10,25 @@ const VitalHealthReactNative = NativeModules.VitalHealthReactNative
             throw new Error(LINKING_ERROR);
         },
     });
+export const VitalHealthReactNativeModule = VitalHealthReactNative;
+export const VitalHealthEvents = {
+    statusEvent: 'Status',
+};
 export class VitalHealth {
     static status = new NativeEventEmitter(VitalHealthReactNative);
-    static configure(backgroundDeliveryEnabled, numberOfDaysToBackFill, enableLogs) {
-        return VitalHealthReactNative.configure(backgroundDeliveryEnabled, numberOfDaysToBackFill, enableLogs);
+    static configure(healthConfig) {
+        if (Platform.OS === 'android') {
+            return VitalHealthReactNative.configure(healthConfig.androidConfig.syncOnAppStart, healthConfig.numberOfDaysToBackFill, healthConfig.logsEnabled);
+        }
+        else {
+            return VitalHealthReactNative.configure(healthConfig.iOSConfig.backgroundDeliveryEnabled, healthConfig.numberOfDaysToBackFill, healthConfig.logsEnabled);
+        }
+    }
+    static setUserId(userId) {
+        return VitalHealthReactNative.setUserId(userId);
+    }
+    static configureClient(apiKey, environment, region, enableLogs) {
+        return VitalHealthReactNative.configureClient(apiKey, environment, region, enableLogs);
     }
     static askForResources(resources) {
         return VitalHealthReactNative.ask(resources, []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryvital/vital-health-react-native",
-  "version": "0.3.2",
+  "version": "1.1.0",
   "description": "Client to access iOS's HealthKit and Android HealthConnect",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -30,7 +30,6 @@
     "test": "jest",
     "typescript": "tsc --declaration",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "release": "release-it",
     "example": "yarn --cwd example",
     "bootstrap": "yarn example && yarn install && yarn example pods",
     "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build"
@@ -54,14 +53,10 @@
     "react-native": "*"
   },
   "devDependencies": {
-    "@arkweid/lefthook": "^0.7.7",
-    "@commitlint/config-conventional": "^17.0.2",
     "@react-native-community/eslint-config": "^3.0.2",
-    "@release-it/conventional-changelog": "^5.0.0",
     "@types/jest": "^28.1.2",
     "@types/react": "~17.0.21",
     "@types/react-native": "0.70.0",
-    "commitlint": "^17.0.2",
     "del-cli": "^5.0.0",
     "eslint": "^8.4.1",
     "eslint-config-prettier": "^8.5.0",
@@ -74,7 +69,6 @@
     "react-native": "0.70.6",
     "react-native-builder-bob": "^0.20.2",
     "react-native-version": "^4.0.0",
-    "release-it": "^15.0.0",
     "typescript": "^4.5.2"
   },
   "resolutions": {
@@ -91,28 +85,6 @@
       "<rootDir>/lib/"
     ]
   },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "release-it": {
-    "git": {
-      "commitMessage": "chore: release ${version}",
-      "tagName": "v${version}"
-    },
-    "npm": {
-      "publish": true
-    },
-    "github": {
-      "release": true
-    },
-    "plugins": {
-      "@release-it/conventional-changelog": {
-        "preset": "angular"
-      }
-    }
-  },
   "eslintConfig": {
     "root": true,
     "extends": [

package/src/health_config.ts

@@ -0,0 +1,15 @@
+export class HealthConfig {
+  logsEnabled = true;
+  numberOfDaysToBackFill = 90;
+  androidConfig = new AndroidHealthConfig();
+  iOSConfig = new IOSHealthConfig();
+}
+
+export class AndroidHealthConfig {
+  syncOnAppStart = true;
+}
+
+export class IOSHealthConfig {
+  dataPushMode = 'automatic';
+  backgroundDeliveryEnabled = true;
+}

package/src/index.tsx

@@ -1,4 +1,5 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+import type { HealthConfig } from './health_config';
 
 const LINKING_ERROR =
   `The package 'vital-health-react-native' doesn't seem to be linked. Make sure: \n\n` +
@@ -17,17 +18,45 @@ const VitalHealthReactNative = NativeModules.VitalHealthReactNative
       }
     );
 
+export const VitalHealthReactNativeModule = VitalHealthReactNative;
+
+export const VitalHealthEvents = {
+  statusEvent: 'Status',
+};
+
 export class VitalHealth {
   static status = new NativeEventEmitter(VitalHealthReactNative);
 
-  static configure(
-    backgroundDeliveryEnabled: boolean,
-    numberOfDaysToBackFill: number,
+  static configure(healthConfig: HealthConfig): Promise<void> {
+    if (Platform.OS === 'android') {
+      return VitalHealthReactNative.configure(
+        healthConfig.androidConfig.syncOnAppStart,
+        healthConfig.numberOfDaysToBackFill,
+        healthConfig.logsEnabled
+      );
+    } else {
+      return VitalHealthReactNative.configure(
+        healthConfig.iOSConfig.backgroundDeliveryEnabled,
+        healthConfig.numberOfDaysToBackFill,
+        healthConfig.logsEnabled
+      );
+    }
+  }
+
+  static setUserId(userId: string): Promise<void> {
+    return VitalHealthReactNative.setUserId(userId);
+  }
+
+  static configureClient(
+    apiKey: string,
+    environment: string,
+    region: string,
     enableLogs: boolean
   ): Promise<void> {
-    return VitalHealthReactNative.configure(
-      backgroundDeliveryEnabled,
-      numberOfDaysToBackFill,
+    return VitalHealthReactNative.configureClient(
+      apiKey,
+      environment,
+      region,
       enableLogs
     );
   }