react-native-move-sdk 2.13.0 → 2.14.0-1

package/android/src/main/java/com/movesdk/MoveExtensions.kt

@@ -0,0 +1,188 @@
+package com.movesdk
+
+import android.content.Context
+import android.os.PowerManager
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.gson.Gson
+import io.dolphin.move.MoveDetectionService
+import java.util.Locale
+import java.util.regex.Pattern
+
+/**
+ * https://stackoverflow.com/questions/60010298/how-can-i-convert-a-camel-case-string-to-snake-case-and-back-in-idiomatic-kotlin
+ */
+
+val camelRegex = "(?<=[a-zA-Z])[A-Z]".toRegex()
+val snakeRegex = "_[a-zA-Z]".toRegex()
+
+// String extensions
+fun String.camelToSnakeCase(): String {
+  return camelRegex.replace(this) {
+    "_${it.value}"
+  }.uppercase(Locale.getDefault())
+}
+
+fun String.toSnakeCase(): String {
+  return if (Pattern.compile(".*[a-z].*").matcher(this).find()) {
+    camelRegex.replace(this) {
+      "_${it.value}"
+    }.uppercase(Locale.getDefault()).replace("-", "_")
+  } else {
+    uppercase()
+  }
+}
+
+fun String.snakeToUpperCamelCase(): String {
+  val camelCase = StringBuilder()
+  var prevChar = '_'
+  forEach {
+    if (prevChar == '_') {
+      camelCase.append(it.uppercase())
+    } else if (it != '_') {
+      camelCase.append(it.lowercaseChar())
+    }
+    prevChar = it
+  }
+  return camelCase.toString()
+}
+
+fun String.snakeToUpperCamelCaseParam(): String {
+  val camelCase = StringBuilder()
+  var prevChar = '_'
+  forEachIndexed { index, c ->
+    if (index == 0) {
+      camelCase.append(c.lowercaseChar())
+    }else if (prevChar == '_') {
+      camelCase.append(c.uppercase())
+    } else if (c != '_') {
+      camelCase.append(c.lowercaseChar())
+    }
+    prevChar = c
+  }
+  return camelCase.toString()
+}
+
+fun String.equalsService(service: MoveDetectionService): Boolean {
+  return equals(service.name().camelToSnakeCase(), ignoreCase = true)
+}
+
+inline fun <reified T> T.toJsonString(): String {
+  return try {
+    Gson().toJson(this)
+  } catch (e: Exception) {
+    ""
+  }
+}
+
+fun Array<*>.toWritableArray(): WritableArray {
+  val data: WritableArray = Arguments.createArray()
+  for (value in iterator()) {
+    when (value) {
+      is String -> {
+        data.pushString(value)
+      }
+
+      is Boolean -> {
+        data.pushBoolean(value)
+      }
+
+      is Int -> {
+        data.pushInt(value)
+      }
+
+      is Array<*> -> {
+        data.pushArray(value.toWritableArray())
+      }
+
+      is List<*> -> {
+        data.pushArray(value.toTypedArray().toWritableArray())
+      }
+
+      is Map<*, *> -> {
+        data.pushMap(value.toWritableMap())
+      }
+    }
+  }
+  return data
+}
+
+fun Map<*, *>.toWritableMap(): WritableMap {
+  val data: WritableMap = Arguments.createMap()
+  for (entry in iterator()) {
+    val value = entry.value
+    print("${entry.key} : $value")
+    when (value) {
+      is String -> {
+        data.putString(entry.key.toString(), value)
+      }
+
+      is Boolean -> {
+        data.putBoolean(entry.key.toString(), value)
+      }
+
+      is Int -> {
+        data.putInt(entry.key.toString(), value)
+      }
+
+      is Array<*> -> {
+        data.putArray(entry.key.toString(), value.toWritableArray())
+      }
+
+      is List<*> -> {
+        data.putArray(entry.key.toString(), value.toTypedArray().toWritableArray())
+      }
+
+      is Map<*, *> -> {
+        data.putMap(entry.key.toString(), value.toWritableMap())
+      }
+    }
+  }
+  return data
+}
+
+fun Context.isAppIgnoringBatteryOptimization(): Boolean {
+  val packageName = packageName
+  val pm: PowerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
+  return pm.isIgnoringBatteryOptimizations(packageName)
+}
+
+
+internal fun ReactApplicationContext.emitDeviceArrayEvent(eventName: String, data: Array<Any>) {
+  try {
+    val eventData: WritableArray = data.toWritableArray()
+    getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName.toSnakeCase(), eventData)
+  } catch (t: Throwable) {
+    Log.e("SDK Module", t.message, t)
+    //  java.lang.IllegalStateException: Tried to access a JS module before the React instance was fully set up.
+    //  Calls to ReactContext#getJSModule should only happen once initialize() has been called on your native module.
+  }
+}
+
+internal fun ReactApplicationContext.emitDeviceMapEvent(eventName: String, data: Map<*, *>) {
+  try {
+    val eventData: WritableMap = data.toWritableMap()
+    getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName.toSnakeCase(), eventData)
+  } catch (t: Throwable) {
+    Log.e("SDK Module", t.message, t)
+    //  java.lang.IllegalStateException: Tried to access a JS module before the React instance was fully set up.
+    //  Calls to ReactContext#getJSModule should only happen once initialize() has been called on your native module.
+  }
+}
+
+internal fun ReactApplicationContext.emitDeviceStringEvent(eventName: String, data: String) {
+  try {
+    getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName.toSnakeCase(), data)
+  } catch (t: Throwable) {
+    Log.e("SDK Module", t.message, t)
+    //  java.lang.IllegalStateException: Tried to access a JS module before the React instance was fully set up.
+    //  Calls to ReactContext#getJSModule should only happen once initialize() has been called on your native module.
+  }
+}

package/android/src/main/java/{in/dolph/move/sdk/MoveSdkRepository.kt → com/movesdk/MoveSdkConfigRepository.kt}

@@ -1,4 +1,4 @@
-package `in`.dolph.move.sdk
+package com.movesdk
 
 import android.content.Context
 import android.content.SharedPreferences
@@ -66,6 +66,8 @@ internal fun valueOfMoveDetectionService(
     MoveDetectionService.AssistanceCall
   } else if (it.equalsService(MoveDetectionService.AutomaticImpactDetection)) {
     MoveDetectionService.AutomaticImpactDetection
+  } else if (it.equalsService(MoveDetectionService.Health)) {
+    MoveDetectionService.Health
   } else {
     // default case?
     throw IllegalArgumentException("$it is not known, use one of " + MoveDetectionService::class.sealedSubclasses.joinToString { kClass ->

package/android/src/main/java/com/movesdk/MoveSdkPackage.kt

@@ -0,0 +1,32 @@
+package com.movesdk
+
+import com.movesdk.BuildConfig
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class MoveSdkPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == MoveSdkModule.NAME) {
+      MoveSdkModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      MoveSdkModule.NAME to ReactModuleInfo(
+        name = MoveSdkModule.NAME,
+        className = MoveSdkModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = BuildConfig.IS_TURBO_MODULE,
+        hasConstants = false,
+      )
+    )
+  }
+}

package/android/src/main/java/{in/dolph/move/sdk → com/movesdk}/NativeMoveSdkWrapper.kt

@@ -1,18 +1,55 @@
-package `in`.dolph.move.sdk
+package com.movesdk
 
 import android.annotation.SuppressLint
 import android.bluetooth.BluetoothManager
+import android.content.ActivityNotFoundException
 import android.content.Context
+import android.content.Intent
+import android.net.Uri
 import android.os.Build
+import android.provider.Settings
 import android.util.Log
+import android.widget.Toast
+import androidx.activity.result.ActivityResultLauncher
+import androidx.health.connect.client.PermissionController
+import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.permission.HealthPermission.Companion.PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND
+import androidx.health.connect.client.records.StepsRecord
+import com.facebook.react.ReactActivity
+import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import com.google.gson.Gson
-import `in`.dolph.move.sdk.extentions.PermissionUtils
-import `in`.dolph.move.sdk.metadata.METADATA_PREF
-import `in`.dolph.move.sdk.metadata.MetadataStorage
-import `in`.dolph.move.sdk.metadata.MetadataStorageImpl
+import com.movesdk.extentions.PermissionUtils
+import com.movesdk.metadata.METADATA_PREF
+import com.movesdk.metadata.MetadataStorage
+import com.movesdk.metadata.MetadataStorageImpl
+import com.movesdk.shared.ARGUMENT_ERROR
+import com.movesdk.shared.ARGUMENT_ERRORS
+import com.movesdk.shared.ARGUMENT_MOVE_HEALTH
+import com.movesdk.shared.ARGUMENT_MOVE_SERVICES
+import com.movesdk.shared.ARGUMENT_STATE
+import com.movesdk.shared.ARGUMENT_WARNINGS
+import com.movesdk.shared.BATTERY_OPTIMIZATION_REQUEST_CODE
+import com.movesdk.shared.EVENT_AUTH_STATE
+import com.movesdk.shared.EVENT_ERRORS
+import com.movesdk.shared.EVENT_INIT_ERROR
+import com.movesdk.shared.EVENT_MOVE_CONFIG_UPDATE
+import com.movesdk.shared.EVENT_MOVE_DEVICES
+import com.movesdk.shared.EVENT_MOVE_SCAN_RESULT
+import com.movesdk.shared.EVENT_MOVE_SDK_APP
+import com.movesdk.shared.EVENT_MOVE_SDK_DEVICE_STATE
+import com.movesdk.shared.EVENT_MOVE_SDK_HEALTH
+import com.movesdk.shared.EVENT_MOVE_SDK_LOG
+import com.movesdk.shared.EVENT_MOVE_SDK_TRIP_START
+import com.movesdk.shared.EVENT_MOVE_STATE
+import com.movesdk.shared.EVENT_TRIP_STATE
+import com.movesdk.shared.EVENT_WARNINGS
+import com.movesdk.shared.LOG_TAG
+import com.movesdk.shared.OVERLAY_REQUEST_CODE
+import com.movesdk.shared.PROMISE_OK
 import io.dolphin.move.AuthSetupStatus
 import io.dolphin.move.DeviceDiscovery
 import io.dolphin.move.DrivingService
@@ -35,12 +72,13 @@ import io.dolphin.move.MoveServiceWarning
 import io.dolphin.move.MoveShutdownResult
 import io.dolphin.move.MoveTripState
 import io.dolphin.move.WalkingService
-import java.util.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import kotlin.collections.ArrayList
+import java.util.Date
+import java.util.Timer
+import java.util.TimerTask
 
 @SuppressLint("StaticFieldLeak", "MissingPermission")
 class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener,
@@ -75,6 +113,15 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     ),
     gson,
   )
+  private val timersHolder = mutableMapOf<String, Timer?>()
+  private var healthPermissionPromise: Promise? = null
+  private val permissions =
+    setOf(
+      HealthPermission.getReadPermission(StepsRecord::class),
+      PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND,
+    )
+  private var requestPermissionsLauncher: ActivityResultLauncher<Set<String>>? = null
+
   fun init(context: Context) {
     val moveSdk = MoveSdk.init(context.applicationContext)
 
@@ -94,25 +141,6 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
 
     moveSdk.setDeviceStateListener(this)
     moveSdk.setMoveHealthScoreListener(this)
-
-    // Initialize notifications by default (might be overwritten by setup)
-    // TODO remove notification setup in init when VIG1-1620 will be fixed
-/*    val config: MoveSdkConfig = configRepository.loadConfig()
-    try {
-      moveSdk.recognitionNotification(config.recognitionNotification.toAndroidNotification(context))
-      moveSdk.tripNotification(config.tripNotification.toAndroidNotification(context))
-    } catch (t: Throwable) {
-      *//**
-       * TODO Find cause, maybe channelID 0?
-       * Caused by: java.lang.IllegalArgumentException
-      at android.os.Parcel.createExceptionOrNull(Parcel.java:2429)
-      at android.os.Parcel.createException(Parcel.java:2409)
-      at android.os.Parcel.readException(Parcel.java:2392)
-      at android.os.Parcel.readException(Parcel.java:2334)
-      at android.app.INotificationManager$Stub$Proxy.createNotificationChannels(INotificationManager.java:3933)
-       *//*
-    }
-    */
   }
 
   fun allowMockLocations(allowMockLocations: Boolean) {
@@ -145,7 +173,11 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     walkingServices.toArrayList().forEach {
       val serviceName = if (it == "WALKING_LOCATION") "LOCATION" else it
       try {
-        walkingServicesToUse.add(WalkingService.valueOf(serviceName.toString().snakeToUpperCamelCase()))
+        walkingServicesToUse.add(
+          WalkingService.valueOf(
+            serviceName.toString().snakeToUpperCamelCase()
+          )
+        )
       } catch (t: Throwable) {
         t.printStackTrace()
       }
@@ -172,7 +204,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     val moveOptions = options?.let(::extractMoveOptions)
 
     try {
-      Log.d(MoveSdkModule.LOG_TAG, "MOVE SDK Version " + MoveSdk.version)
+      Log.d(LOG_TAG, "MOVE SDK Version " + MoveSdk.version)
 
       val moveAuth = MoveAuth(
         userId = userId,
@@ -200,7 +232,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
       promise?.resolve(PROMISE_OK)
     } catch (t: Throwable) {
       val message = "SETUP_ERROR: ${t.message}"
-      Log.e(MoveSdkModule.LOG_TAG, message, t)
+      Log.e(LOG_TAG, message, t)
       emitDeviceEvent(EVENT_MOVE_SDK_APP, message)
       promise?.reject(Exception(message))
     }
@@ -229,7 +261,11 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     walkingServices.toArrayList().forEach {
       val serviceName = if (it == "WALKING_LOCATION") "LOCATION" else it
       try {
-        walkingServicesToUse.add(WalkingService.valueOf(serviceName.toString().snakeToUpperCamelCase()))
+        walkingServicesToUse.add(
+          WalkingService.valueOf(
+            serviceName.toString().snakeToUpperCamelCase()
+          )
+        )
       } catch (t: Throwable) {
         t.printStackTrace()
       }
@@ -257,7 +293,8 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     val moveOptions = try {
       val motionPermissionMandatory = featureOptions?.get("motionPermissionMandatory") as? Boolean
       val useBackendConfig = featureOptions?.get("useBackendConfig") as? Boolean
-      val backgroundLocationPermissionMandatory = featureOptions?.get("backgroundLocationPermissionMandatory") as? Boolean
+      val backgroundLocationPermissionMandatory =
+        featureOptions?.get("backgroundLocationPermissionMandatory") as? Boolean
       val overlayPermissionMandatory = featureOptions?.get("overlayPermissionMandatory") as? Boolean
       val deviceDiscovery = featureOptions?.get("deviceDiscovery") as? Map<String, Any>
       val startDelay = deviceDiscovery?.get("startDelay") as? Double
@@ -277,12 +314,12 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
         ),
       )
     } catch (e: Exception) {
-      Log.e(MoveSdkModule.LOG_TAG, "setup: ${e.message}", e)
+      Log.e(LOG_TAG, "setup: ${e.message}", e)
       null
     }
 
     try {
-      Log.d(MoveSdkModule.LOG_TAG, "MOVE SDK Version " + MoveSdk.version)
+      Log.d(LOG_TAG, "MOVE SDK Version " + MoveSdk.version)
 
       MoveSdk.get()?.setNotificationText(
         notification = MoveNotification(
@@ -305,6 +342,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
               AuthSetupStatus.SUCCESS -> {
                 promise?.resolve(PROMISE_OK)
               }
+
               AuthSetupStatus.INVALID_CODE,
               AuthSetupStatus.NETWORK_ERROR -> promise?.reject(Exception(result.status.name))
             }
@@ -313,7 +351,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
       )
     } catch (t: Throwable) {
       val message = "SETUP_ERROR: ${t.message}"
-      Log.e(MoveSdkModule.LOG_TAG, message, t)
+      Log.e(LOG_TAG, message, t)
       emitDeviceEvent(EVENT_MOVE_SDK_APP, message)
       promise?.reject(Exception(message))
     }
@@ -352,8 +390,14 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     }
   }
 
-  fun getErrors(): List<MoveServiceFailure>? {
-    return MoveSdk.get()?.getServiceErrors()
+  fun getErrors(promise: Promise?) {
+    mainScope.launch {
+      val errors: List<MoveServiceFailure>
+      withContext(ioContext) {
+        errors = MoveSdk.get()?.getServiceErrors() ?: emptyList()
+      }
+      promise?.resolve(errors.failuresToArray().toWritableArray())
+    }
   }
 
   fun getWarnings(): List<MoveServiceWarning>? {
@@ -443,7 +487,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     data.putString(ARGUMENT_ERROR_REASON, state.reason.toString())
     }**/
     emitDeviceEvent(EVENT_MOVE_STATE, data)
-    Log.d(MoveSdkModule.LOG_TAG, "Move SDK $state")
+    Log.d(LOG_TAG, "Move SDK $state")
   }
 
   override fun onTripStateChanged(tripState: MoveTripState) {
@@ -630,18 +674,18 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
   }
 
 // TODO uncomment when will be fixed VIG1-1620
-/*  private fun getIconIdByName(name: String?): Int? {
-    Log.i("MissingNotifications", "getIconIdByName name = $name")
-    name ?: return null
-    val packageName = context.packageName
-    return try {
-      val resource = context.resources.getIdentifier(name, "drawable", packageName).takeIf { it != 0 }
-      Log.i("MissingNotifications", "getIdentifier resource = $resource")
-      resource
-    } catch (e: Exception) {
-      null
-    }
-  }*/
+  /*  private fun getIconIdByName(name: String?): Int? {
+      Log.i("MissingNotifications", "getIconIdByName name = $name")
+      name ?: return null
+      val packageName = context.packageName
+      return try {
+        val resource = context.resources.getIdentifier(name, "drawable", packageName).takeIf { it != 0 }
+        Log.i("MissingNotifications", "getIdentifier resource = $resource")
+        resource
+      } catch (e: Exception) {
+        null
+      }
+    }*/
 
   override fun onTripStarted(startDate: Date) {
     emitDeviceEvent(EVENT_MOVE_SDK_TRIP_START, startDate.time.toString())
@@ -660,7 +704,11 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     walkingServices.toArrayList().forEach {
       val serviceName = if (it == "WALKING_LOCATION") "LOCATION" else it
       try {
-        walkingServicesToUse.add(WalkingService.valueOf(serviceName.toString().snakeToUpperCamelCase()))
+        walkingServicesToUse.add(
+          WalkingService.valueOf(
+            serviceName.toString().snakeToUpperCamelCase()
+          )
+        )
       } catch (t: Throwable) {
         t.printStackTrace()
       }
@@ -713,23 +761,33 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
   fun isBluetoothEnabled(): Boolean {
     val adapter = context.getSystemService(BluetoothManager::class.java)?.adapter
     if (adapter == null) {
-      Log.i(MoveSdkModule.LOG_TAG, "BluetoothManager is missing or BT adapter is null")
+      Log.i(LOG_TAG, "BluetoothManager is missing or BT adapter is null")
     }
     return adapter?.isEnabled == true
   }
+
   fun hasDiscoveryPermissions(): Boolean {
     var hasPermissions = true
     val hasBluetoothScanPermission = PermissionUtils.hasBluetoothScanPermission(context)
-    Log.i(MoveSdkModule.LOG_TAG, "Discovery permission check: BluetoothScanPermission = $hasBluetoothScanPermission")
+    Log.i(
+      LOG_TAG,
+      "Discovery permission check: BluetoothScanPermission = $hasBluetoothScanPermission"
+    )
     hasPermissions = hasPermissions && hasBluetoothScanPermission
     if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
       val hasFineLocationPermission = PermissionUtils.hasFineLocationPermission(context)
-      Log.i(MoveSdkModule.LOG_TAG, "Discovery permission check: FineLocationPermission = $hasFineLocationPermission")
+      Log.i(
+        LOG_TAG,
+        "Discovery permission check: FineLocationPermission = $hasFineLocationPermission"
+      )
       hasPermissions = hasPermissions && hasFineLocationPermission
     }
     if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R || Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {
       val hasBackgroundLocationPermission = PermissionUtils.hasBackgroundLocationPermission(context)
-      Log.i(MoveSdkModule.LOG_TAG, "Discovery permission check: BackgroundLocationPermission = $hasBackgroundLocationPermission")
+      Log.i(
+        LOG_TAG,
+        "Discovery permission check: BackgroundLocationPermission = $hasBackgroundLocationPermission"
+      )
       hasPermissions = hasPermissions && hasBackgroundLocationPermission
     }
     return hasPermissions
@@ -750,10 +808,85 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
         health.add(healthItem)
         data[ARGUMENT_MOVE_HEALTH] = health
         emitDeviceEvent(EVENT_MOVE_SDK_HEALTH, data)
-        Log.d(MoveSdkModule.LOG_TAG, "onMoveHealthScoreChanged $data")
+        Log.d(LOG_TAG, "onMoveHealthScoreChanged $data")
       }
     } catch (e: Exception) {
-      Log.e(MoveSdkModule.LOG_TAG, "Exception in Health listener", e)
+      Log.e(LOG_TAG, "Exception in Health listener", e)
+    }
+  }
+
+  fun setTimer(delay: Int? = 0, key: String, callback: Callback) {
+    try {
+      val timer = timersHolder[key]
+      timer?.cancel()
+      Timer().also {
+        timersHolder[key] = it
+        it.schedule(
+          object : TimerTask() {
+            override fun run() {
+              callback.invoke()
+            }
+          },
+          delay?.toLong() ?: 0L,
+        )
+      }
+    } catch (e: Exception) {
+      // Do nothing
+    }
+  }
+
+  fun cancelTimer(key: String?) {
+    key ?: return
+    try {
+      timersHolder[key]?.cancel()
+    } catch (e: Exception) {
+      Log.i("cancelTimer", "error: ${e.message}")
+    }
+  }
+
+  fun requestDrawOverlaysPermission(context: ReactContext) {
+    val intent = Intent(
+      Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+      Uri.parse("package:${context.packageName}")
+    )
+    context.currentActivity!!.startActivityForResult(intent, OVERLAY_REQUEST_CODE)
+  }
+
+  fun requestAppIgnoringBatteryOptimization(context: ReactContext) {
+    val intent = Intent(
+      Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS,
+      Uri.parse("package:" + context.packageName)
+    )
+    context.currentActivity?.startActivityForResult(intent, BATTERY_OPTIMIZATION_REQUEST_CODE)
+  }
+
+  fun registerRequestPermissionLauncher(activity: ReactActivity) {
+    val requestPermissionActivityContract =
+      PermissionController.createRequestPermissionResultContract()
+    requestPermissionsLauncher =
+      activity.registerForActivityResult(requestPermissionActivityContract) { granted ->
+        if (granted.containsAll(permissions)) {
+          Log.d(LOG_TAG, "Health connect permission has been granted")
+          MoveSdk.get()?.resolveError()
+          healthPermissionPromise?.resolve(true)
+        } else {
+          Log.d(LOG_TAG, "Health connect permission NOT granted")
+          healthPermissionPromise?.reject(Throwable("Granted: $granted"))
+        }
+        healthPermissionPromise = null
+      }
+  }
+
+  fun requestHealthPermissions(promise: Promise?) {
+    healthPermissionPromise = promise
+    try {
+      requestPermissionsLauncher?.launch(permissions)
+    } catch (e: ActivityNotFoundException) {
+      Log.w(LOG_TAG, "No Activity found to handle Intent.\n Install Health connect")
+      promise?.reject(Throwable("Install Health connect!"))
+    } catch (e: Exception) {
+      Log.w(LOG_TAG, e.message, e)
+      promise?.reject(e)
     }
   }
 }
@@ -762,16 +895,19 @@ fun List<MoveServiceFailure>.failuresToArray(): Array<Any> {
   val data = mutableListOf<Any>()
   forEach {
     val map = mutableMapOf<String, Any>()
-    val serviceName = when(val nativeService = it.service) {
+    val serviceName = when (val nativeService = it.service) {
       is MoveDetectionService.Driving ->
-        nativeService.drivingServices?.firstOrNull()?.name?.toSnakeCase() ?: nativeService.name().toSnakeCase()
-      is MoveDetectionService.Walking ->{
+        nativeService.drivingServices?.firstOrNull()?.name?.toSnakeCase() ?: nativeService.name()
+          .toSnakeCase()
+
+      is MoveDetectionService.Walking -> {
         if (nativeService.walkingServices?.isNotEmpty() == true) {
           "WALKING_LOCATION"
         } else {
           nativeService.name().toSnakeCase()
         }
       }
+
       else -> nativeService.name().toSnakeCase()
     }
     map["service"] = serviceName
@@ -786,9 +922,11 @@ fun List<MoveServiceWarning>.warningsToArray(): Array<Any> {
   val data = mutableListOf<Any>()
   forEach {
     val map = mutableMapOf<String, Any?>()
-    val serviceName = when(val nativeService = it.service) {
+    val serviceName = when (val nativeService = it.service) {
       is MoveDetectionService.Driving ->
-        nativeService.drivingServices?.firstOrNull()?.name?.toSnakeCase() ?: nativeService.name().toSnakeCase()
+        nativeService.drivingServices?.firstOrNull()?.name?.toSnakeCase() ?: nativeService.name()
+          .toSnakeCase()
+
       is MoveDetectionService.Walking -> {
         if (nativeService.walkingServices?.isNotEmpty() == true) {
           "WALKING_LOCATION"
@@ -796,6 +934,7 @@ fun List<MoveServiceWarning>.warningsToArray(): Array<Any> {
           nativeService.name().toSnakeCase()
         }
       }
+
       else -> nativeService?.name()?.toSnakeCase()
     }
     map["service"] = serviceName
@@ -805,3 +944,4 @@ fun List<MoveServiceWarning>.warningsToArray(): Array<Any> {
   }
   return data.toTypedArray()
 }
+