@tryvital/vital-health-react-native 5.4.3 → 6.0.0-rc.1

package/android/build.gradle

@@ -18,6 +18,20 @@ def isNewArchitectureEnabled() {
   return rootProject.hasProperty("newArchEnabled") &&  rootProject.getProperty("newArchEnabled") == "true"
 }
 
+def getSamsungHealthAarPath() {
+  if (!rootProject.hasProperty('samsungHealthAarPath')) {
+    return null
+  }
+
+  def path = rootProject.getProperty('samsungHealthAarPath')
+  return path ? path.toString().trim() : null
+}
+
+def hasSamsungHealthAarPath() {
+  def path = getSamsungHealthAarPath()
+  return path != null && !path.isEmpty()
+}
+
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
@@ -56,6 +70,14 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
+  sourceSets {
+    main {
+      java.srcDirs += hasSamsungHealthAarPath()
+        ? ['src/samsungHealthEnabled/java']
+        : ['src/samsungHealthDisabled/java']
+    }
+  }
+
 }
 
 repositories {
@@ -129,7 +151,7 @@ repositories {
 }
 
 def kotlin_version = getExtOrDefault('kotlinVersion')
-def vital_sdk_version = '4.2.2'
+def vital_sdk_version = '5.0.0-rc.1'
 
 dependencies {
     //noinspection GradleDynamicVersion
@@ -140,6 +162,10 @@ dependencies {
   implementation "io.tryvital:vital-client:$vital_sdk_version"
   implementation "io.tryvital:vital-health-connect:$vital_sdk_version"
 
+  if (hasSamsungHealthAarPath()) {
+    implementation "io.tryvital:vital-samsung-health:$vital_sdk_version"
+  }
+
   implementation project(':tryvital_vital-core-react-native')
 // From node_modules
 }

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

@@ -0,0 +1,162 @@
+package com.vitalhealthreactnative
+
+import android.content.Context
+import androidx.activity.result.contract.ActivityResultContract
+import io.tryvital.vitalhealthconnect.DefaultSyncNotificationBuilder
+import io.tryvital.vitalhealthconnect.DefaultSyncNotificationContent
+import io.tryvital.vitalhealthconnect.ExperimentalVitalApi
+import io.tryvital.vitalhealthconnect.VitalHealthConnectManager
+import io.tryvital.vitalhealthconnect.autoSyncThrottle
+import io.tryvital.vitalhealthconnect.backgroundSyncMinimumInterval
+import io.tryvital.vitalhealthconnect.disableBackgroundSync
+import io.tryvital.vitalhealthconnect.enableBackgroundSyncContract
+import io.tryvital.vitalhealthconnect.isBackgroundSyncEnabled
+import io.tryvital.vitalhealthconnect.model.PermissionOutcome as HealthConnectPermissionOutcome
+import io.tryvital.vitalhealthcore.model.ConnectionPolicy
+import io.tryvital.vitalhealthcore.model.ProviderAvailability
+import io.tryvital.vitalhealthcore.model.VitalResource
+import io.tryvital.vitalhealthcore.model.WritableVitalResource
+import kotlinx.coroutines.Deferred
+import java.time.Instant
+
+internal object HealthConnectVitalHealthProviderDefinition : VitalHealthProviderDefinition {
+  override val provider = AndroidProvider.HealthConnect
+  override val displayName = "Health Connect"
+  override val supportedWriteResources = setOf(
+    WritableVitalResource.Water,
+    WritableVitalResource.Glucose,
+  )
+  override val syncStatusEvent = VitalHealthEvent.HealthConnectSyncStatus
+  override val connectionStatusEvent = VitalHealthEvent.HealthConnectConnectionStatus
+
+  override fun isAvailable(context: Context): ProviderAvailability {
+    return VitalHealthConnectManager.isAvailable(context)
+  }
+
+  override fun openPlatformHealthAppIntent(context: Context) =
+    VitalHealthConnectManager.openHealthConnectIntent(context)
+
+  override fun getOrCreateManager(context: Context): VitalHealthManagerBridge {
+    return HealthConnectVitalHealthManagerBridge(
+      VitalHealthConnectManager.getOrCreate(context),
+    )
+  }
+}
+
+@OptIn(ExperimentalVitalApi::class)
+private class HealthConnectVitalHealthManagerBridge(
+  private val manager: VitalHealthConnectManager,
+) : VitalHealthManagerBridge {
+  override val status = manager.status
+  override val connectionStatus = manager.connectionStatus
+
+  override var pauseSynchronization: Boolean
+    get() = manager.pauseSynchronization
+    set(value) {
+      manager.pauseSynchronization = value
+    }
+
+  override val isBackgroundSyncEnabled: Boolean
+    get() = manager.isBackgroundSyncEnabled
+
+  override var autoSyncThrottle
+    get() = manager.autoSyncThrottle
+    set(value) {
+      manager.autoSyncThrottle = value
+    }
+
+  override var backgroundSyncMinimumInterval
+    get() = manager.backgroundSyncMinimumInterval
+    set(value) {
+      manager.backgroundSyncMinimumInterval = value
+    }
+
+  override fun configure(
+    syncOnAppStart: Boolean,
+    numberOfDaysToBackFill: Int,
+    logsEnabled: Boolean,
+    connectionPolicy: ConnectionPolicy,
+  ) {
+    manager.configureHealthConnectClient(
+      logsEnabled = logsEnabled,
+      syncOnAppStart = syncOnAppStart,
+      numberOfDaysToBackFill = numberOfDaysToBackFill,
+      connectionPolicy = connectionPolicy,
+    )
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  override fun createPermissionRequestContract(
+    readResources: Set<VitalResource>,
+    writeResources: Set<WritableVitalResource>,
+  ): ActivityResultContract<Unit, Deferred<*>> {
+    return manager.createPermissionRequestContract(
+      readResources = readResources,
+      writeResources = writeResources,
+    ) as ActivityResultContract<Unit, Deferred<*>>
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  override suspend fun resolvePermissionOutcome(result: Deferred<*>): VitalHealthPermissionOutcome {
+    return when ((result as Deferred<HealthConnectPermissionOutcome>).await()) {
+      is HealthConnectPermissionOutcome.Success -> VitalHealthPermissionOutcome.Success
+      is HealthConnectPermissionOutcome.HealthConnectUnavailable ->
+        VitalHealthPermissionOutcome.HealthDataUnavailable
+      is HealthConnectPermissionOutcome.Cancelled -> VitalHealthPermissionOutcome.Cancelled
+      is HealthConnectPermissionOutcome.NotPrompted -> VitalHealthPermissionOutcome.NotPrompted
+      is HealthConnectPermissionOutcome.UnknownError -> VitalHealthPermissionOutcome.UnknownError
+    }
+  }
+
+  override fun hasAskedForPermission(resource: VitalResource): Boolean {
+    return manager.hasAskedForPermission(resource)
+  }
+
+  override suspend fun syncData(resources: Set<VitalResource>?) {
+    manager.syncData(resources)
+  }
+
+  override suspend fun writeRecord(
+    resource: WritableVitalResource,
+    startDate: Instant,
+    endDate: Instant,
+    value: Double,
+  ) {
+    manager.writeRecord(resource, startDate, endDate, value)
+  }
+
+  override fun enableBackgroundSyncContract(): ActivityResultContract<Unit, Boolean> {
+    return manager.enableBackgroundSyncContract()
+  }
+
+  override fun disableBackgroundSync() {
+    manager.disableBackgroundSync()
+  }
+
+  override fun setSyncNotificationContent(
+    context: Context,
+    content: VitalHealthSyncNotificationContent,
+  ): Boolean {
+    val builder = VitalHealthConnectManager.syncNotificationBuilder(context)
+      as? DefaultSyncNotificationBuilder
+      ?: return false
+
+    builder.setContentOverride(
+      DefaultSyncNotificationContent(
+        notificationTitle = content.notificationTitle,
+        notificationContent = content.notificationContent,
+        channelName = content.channelName,
+        channelDescription = content.channelDescription,
+      ),
+    )
+    return true
+  }
+
+  override suspend fun connect() {
+    manager.connect()
+  }
+
+  override suspend fun disconnect() {
+    manager.disconnect()
+  }
+}

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

@@ -0,0 +1,37 @@
+package com.vitalhealthreactnative
+
+import android.content.Context
+import android.content.Intent
+import io.tryvital.vitalhealthcore.model.ProviderAvailability
+import io.tryvital.vitalhealthcore.model.WritableVitalResource
+
+fun raiseUnimplemented(): Nothing {
+  throw IllegalArgumentException("the requested provider is unavailable on this device")
+}
+
+@Suppress("unused")
+internal object UnavailableVitalHealthProviderDefinition : VitalHealthProviderDefinition {
+
+  override val provider: AndroidProvider
+    get() { raiseUnimplemented() }
+  override val displayName: String
+    get() { raiseUnimplemented() }
+  override val supportedWriteResources: Set<WritableVitalResource>
+    get() { raiseUnimplemented() }
+  override val syncStatusEvent: VitalHealthEvent
+    get() { raiseUnimplemented() }
+  override val connectionStatusEvent: VitalHealthEvent
+    get() { raiseUnimplemented() }
+
+  override fun isAvailable(context: Context): ProviderAvailability {
+    return ProviderAvailability.NotInstalled
+  }
+
+  override fun openPlatformHealthAppIntent(context: Context): Intent? {
+    raiseUnimplemented()
+  }
+
+  override fun getOrCreateManager(context: Context): VitalHealthManagerBridge {
+    raiseUnimplemented()
+  }
+}

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

@@ -1,21 +1,16 @@
 package com.vitalhealthreactnative
 
 sealed class VitalHealthEvent(val value: String) {
-  object Status : VitalHealthEvent("Status")
-  object ConnectionStatus : VitalHealthEvent("VitalHealthConnectionStatus")
+  object HealthConnectSyncStatus : VitalHealthEvent("Status")
+  object HealthConnectConnectionStatus : VitalHealthEvent("HealthConnectConnectionStatus")
+  object SamsungHealthSyncStatus : VitalHealthEvent("SamsungHealthSyncStatus")
+  object SamsungHealthConnectionStatus : VitalHealthEvent("SamsungHealthConnectionStatus")
 
   companion object {
     fun values(): Array<VitalHealthEvent> {
-      return arrayOf(Status, ConnectionStatus)
+      return arrayOf(HealthConnectSyncStatus, HealthConnectConnectionStatus, SamsungHealthSyncStatus, SamsungHealthConnectionStatus)
     }
 
-    fun valueOf(value: String): VitalHealthEvent {
-      return when (value) {
-        "Status" -> Status
-        "VitalHealthConnectionStatus" -> ConnectionStatus
-        else -> throw IllegalArgumentException("Invalid VitalHealthEvent value: $value")
-      }
-    }
+    fun valueOf(value: String): VitalHealthEvent = values().first { it.value == value }
   }
-
 }

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

@@ -0,0 +1,100 @@
+package com.vitalhealthreactnative
+
+import android.content.Context
+import android.content.Intent
+import androidx.activity.result.contract.ActivityResultContract
+import io.tryvital.vitalhealthcore.model.ConnectionPolicy
+import io.tryvital.vitalhealthcore.model.ConnectionStatus
+import io.tryvital.vitalhealthcore.model.ProviderAvailability
+import io.tryvital.vitalhealthcore.model.SyncStatus
+import io.tryvital.vitalhealthcore.model.VitalResource
+import io.tryvital.vitalhealthcore.model.WritableVitalResource
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import java.time.Instant
+import kotlin.time.Duration
+
+internal enum class AndroidProvider {
+  HealthConnect, SamsungHealth;
+
+  companion object {
+    fun of(rawValue: String) = when (rawValue) {
+      "health_connect" -> HealthConnect
+      "samsung_health" -> SamsungHealth
+      else -> throw IllegalArgumentException("unrecognized AndroidProvider: ${rawValue}")
+    }
+  }
+}
+
+internal interface VitalHealthProviderDefinition {
+  val provider: AndroidProvider
+  val displayName: String
+  val supportedWriteResources: Set<WritableVitalResource>
+  val syncStatusEvent: VitalHealthEvent
+  val connectionStatusEvent: VitalHealthEvent
+
+  fun isAvailable(context: Context): ProviderAvailability
+  fun openPlatformHealthAppIntent(context: Context): Intent?
+  fun getOrCreateManager(context: Context): VitalHealthManagerBridge
+}
+
+internal interface VitalHealthManagerBridge {
+  val status: Flow<SyncStatus>
+  val connectionStatus: StateFlow<ConnectionStatus>
+  var pauseSynchronization: Boolean
+  val isBackgroundSyncEnabled: Boolean
+  var autoSyncThrottle: Duration
+  var backgroundSyncMinimumInterval: Duration
+
+  fun configure(
+    syncOnAppStart: Boolean,
+    numberOfDaysToBackFill: Int,
+    logsEnabled: Boolean,
+    connectionPolicy: ConnectionPolicy,
+  )
+
+  fun createPermissionRequestContract(
+    readResources: Set<VitalResource>,
+    writeResources: Set<WritableVitalResource>,
+  ): ActivityResultContract<Unit, Deferred<*>>
+
+  suspend fun resolvePermissionOutcome(result: Deferred<*>): VitalHealthPermissionOutcome
+
+  fun hasAskedForPermission(resource: VitalResource): Boolean
+
+  suspend fun syncData(resources: Set<VitalResource>? = null)
+
+  suspend fun writeRecord(
+    resource: WritableVitalResource,
+    startDate: Instant,
+    endDate: Instant,
+    value: Double,
+  )
+
+  fun enableBackgroundSyncContract(): ActivityResultContract<Unit, Boolean>
+  fun disableBackgroundSync()
+
+  fun setSyncNotificationContent(
+    context: Context,
+    content: VitalHealthSyncNotificationContent,
+  ): Boolean
+
+  suspend fun connect()
+  suspend fun disconnect()
+}
+
+internal data class VitalHealthSyncNotificationContent(
+  val notificationTitle: String,
+  val notificationContent: String,
+  val channelName: String,
+  val channelDescription: String,
+)
+
+internal enum class VitalHealthPermissionOutcome(val jsValue: String) {
+  Success("success"),
+  HealthDataUnavailable("healthDataUnavailable"),
+  Cancelled("cancelled"),
+  NotPrompted("notPrompted"),
+  UnknownError("unknownError"),
+}