react-native-move-sdk 2.13.0 → 2.14.0

package/android/build.gradle.kts

@@ -0,0 +1,42 @@
+fun isNewArchitectureEnabled(): Boolean {
+  // Check if the project has the "newArchEnabled" property and if its value is "true"
+  return project.hasProperty("newArchEnabled") && project.property("newArchEnabled") == "true"
+}
+
+plugins {
+  id("com.facebook.react")
+  id("com.android.library")// version "8.6.0"
+  id("org.jetbrains.kotlin.android")// version "2.0.21"
+}
+
+android {
+  compileSdk = 35
+  buildToolsVersion = "35.0.0"
+  namespace = "com.movesdk"
+
+  compileOptions {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+  }
+
+  defaultConfig {
+    minSdk = 26
+    buildConfigField("boolean", "IS_TURBO_MODULE", isNewArchitectureEnabled().toString())
+  }
+
+  sourceSets {
+    getByName("main") {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs("src/turbo", "src/main/java")
+      } else {
+        java.srcDirs("src/legacy", "src/main/java")
+      }
+    }
+  }
+}
+
+dependencies {
+  implementation("com.facebook.react:react-android")
+  api("io.dolphin.move:move-sdk:2.14.0.95")
+  implementation("androidx.health.connect:connect-client:1.1.0-beta01")
+}

package/android/gradle.properties

@@ -1,8 +1,18 @@
-MoveSdk_kotlinVersion=1.7.10
-MoveSdk_compileSdkVersion=33
-MoveSdk_targetSdkVersion=32
+# Project-wide Gradle settings.
 
-android.useAndroidX=true
-android.enableJetifier=true
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
 
-org.gradle.jvmargs=-Xmx4g
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx512m -XX:MaxMetaspaceSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=512m
+
+# Use this property to specify which architecture you want to build.
+# You can also override it from the CLI using
+# ./gradlew <task> -PreactNativeArchitectures=x86_64
+reactNativeArchitectures=armeabi-v7a,arm64-v8a,x86,x86_64

package/android/settings.gradle.kts

@@ -0,0 +1,35 @@
+import java.io.FileInputStream
+import java.util.Properties
+
+pluginManagement {
+  includeBuild("../node_modules/@react-native/gradle-plugin")
+  repositories {
+    google()
+    mavenCentral()
+    gradlePluginPortal()
+  }
+}
+
+dependencyResolutionManagement {
+  val localPropsFile = File(rootProject.projectDir, "local.properties")
+  val properties = Properties()
+  if (localPropsFile.exists()) {
+    properties.apply {
+      load(FileInputStream(localPropsFile))
+    }
+  }
+  repositories {
+    google()
+    mavenCentral()
+    maven {
+      url = uri("https://dolphin.jfrog.io/artifactory/move-sdk-libs-release")
+    }
+  }
+}
+
+plugins {
+  id("com.facebook.react.settings")
+}
+
+rootProject.name = "RN Move SDK"
+includeBuild("../node_modules/@react-native/gradle-plugin")

package/android/src/{main/java/in/dolph/move/sdk → legacy}/MoveSdkModule.kt

@@ -1,18 +1,11 @@
-package `in`.dolph.move.sdk
+package com.movesdk
 
 import android.annotation.SuppressLint
 import android.app.Activity
-import android.bluetooth.BluetoothManager
-import android.content.Context
 import android.content.Intent
-import android.net.Uri
-import android.os.Build
-import android.os.PowerManager
 import android.provider.Settings
 import android.util.Log
-import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.ActivityEventListener
-import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
@@ -20,65 +13,24 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.movesdk.shared.ARGUMENT_STATE
+import com.movesdk.shared.BATTERY_OPTIMIZATION_REQUEST_CODE
+import com.movesdk.shared.EVENT_AUTH_BATTERY_PERMISSION
+import com.movesdk.shared.EVENT_AUTH_OVERLAY_PERMISSION
+import com.movesdk.shared.OVERLAY_REQUEST_CODE
 import io.dolphin.move.MoveSdk
-import io.dolphin.move.MoveServiceFailure
 import io.dolphin.move.MoveServiceWarning
-import java.util.Timer
-import java.util.TimerTask
-
-internal const val EVENT_INIT_ERROR = "MoveSdk-InitError"
-internal const val EVENT_MOVE_STATE = "MoveSdk-State"
-internal const val EVENT_TRIP_STATE = "MoveSdk-TripState"
-internal const val EVENT_AUTH_STATE = "MoveSdk-AuthState"
-internal const val EVENT_ERRORS = "MoveSdk-Errors"
-internal const val EVENT_WARNINGS = "MoveSdk-Warnings"
-internal const val EVENT_MOVE_DEVICES = "MoveSdk-Devices"
-internal const val EVENT_AUTH_BATTERY_PERMISSION = "MoveSdk-Permission-BatteryOptimization"
-internal const val EVENT_AUTH_OVERLAY_PERMISSION = "MoveSdk-Permission-Overlay"
-internal const val EVENT_MOVE_SCAN_RESULT = "MOVE_SDK_SCAN_RESULT"
-internal const val EVENT_MOVE_SDK_APP = "MOVE_SDK_APP_EVENT"
-internal const val EVENT_MOVE_CONFIG_UPDATE = "MOVE_SDK_CONFIG_UPDATE"
-internal const val EVENT_MOVE_SDK_TRIP_START = "MOVE_SDK_TRIP_START"
-internal const val EVENT_MOVE_SDK_DEVICE_STATE = "MOVE_SDK_DEVICE_STATE"
-internal const val EVENT_MOVE_SDK_LOG = "MOVE_SDK_LOG"
-internal const val EVENT_MOVE_SDK_HEALTH = "MOVE_SDK_HEALTH"
-
-internal const val ARGUMENT_ACCESS_TOKEN = "accessToken"
-internal const val ARGUMENT_REFRESH_TOKEN = "refreshToken"
-internal const val ARGUMENT_STATE = "state"
-internal const val ARGUMENT_ERROR = "errors"
-internal const val ARGUMENT_ERRORS = "errors"
-internal const val ARGUMENT_WARNINGS = "warnings"
-internal const val ARGUMENT_LOG = "log"
-internal const val ARGUMENT_WARNING = "warnings"
-internal const val ARGUMENT_ERROR_REASON = "errorReason"
-internal const val ARGUMENT_DEVICES = "devices"
-internal const val ARGUMENT_SCAN_RESULTS = "results"
-internal const val ARGUMENT_MOVE_SERVICES = "services"
-internal const val ARGUMENT_MOVE_HEALTH = "health"
-
-internal const val PROMISE_OK = "OK"
 
 class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context),
   ActivityEventListener {
 
   companion object {
-    const val LOG_TAG = "MOVE_SDK"
-    const val ERROR_CODE = "MOVE_SDK_ERROR"
-
-    // **** PERMISSIONS MODULE START *****
-    const val OVERLAY_REQUEST_CODE = 1
-    const val BATTERY_OPTIMIZATION_REQUEST_CODE = 2
-    // **** PERMISSIONS MODULE END *****
+    const val NAME = "MoveSdk"
   }
 
   private val reactContext: ReactApplicationContext = context
 
   private val nativeSdkWrapper = NativeMoveSdkWrapper.getInstance(reactContext)
-  private val timersHolder = mutableMapOf<String, Timer?>()
 
   init {
     nativeSdkWrapper.applyDelegate(this)
@@ -263,7 +215,7 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
   }
 
   override fun getName(): String {
-    return "MoveSdk"
+    return NAME
   }
 
   override fun getConstants(): MutableMap<String, Any> {
@@ -272,39 +224,16 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
     return constants
   }
 
-  internal fun emitDeviceEvent(eventName: String, data: Array<Any>) {
-    try {
-      val eventData: WritableArray = data.toWritableArray()
-      reactContext.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.
-    }
+  fun emitDeviceEvent(eventName: String, data: Array<Any>) {
+    reactContext.emitDeviceArrayEvent(eventName, data)
   }
 
-  internal fun emitDeviceEvent(eventName: String, data: Map<*, *>) {
-    try {
-      val eventData: WritableMap = data.toWritableMap()
-      reactContext.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.
-    }
+  fun emitDeviceEvent(eventName: String, data: Map<*, *>) {
+    reactContext.emitDeviceMapEvent(eventName, data)
   }
 
-  internal fun emitDeviceEvent(eventName: String, data: String) {
-    try {
-      reactContext.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.
-    }
+  fun emitDeviceEvent(eventName: String, data: String) {
+    reactContext.emitDeviceStringEvent(eventName, data)
   }
 
   @ReactMethod
@@ -319,8 +248,7 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
 
   @ReactMethod
   fun getErrors(promise: Promise?) {
-    val errors: List<MoveServiceFailure> = nativeSdkWrapper.getErrors() ?: emptyList()
-    promise?.resolve(errors.failuresToArray().toWritableArray())
+    nativeSdkWrapper.getErrors(promise)
   }
 
   @ReactMethod
@@ -331,8 +259,7 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
 
   @ReactMethod
   fun getDeviceQualifier(promise: Promise) {
-    val deviceQualifier = nativeSdkWrapper.getDeviceQualifier()
-    promise.resolve(deviceQualifier)
+    promise.resolve(nativeSdkWrapper.getDeviceQualifier())
   }
 
   @ReactMethod
@@ -387,33 +314,16 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
 
   @ReactMethod
   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
-    }
+    nativeSdkWrapper.setTimer(
+      delay = delay,
+      key = key,
+      callback = callback
+    )
   }
 
   @ReactMethod
   fun cancelTimer(key: String?) {
-    key ?: return
-    try {
-      timersHolder[key]?.cancel()
-    } catch (e: Exception) {
-      Log.i("cancelTimer", "error: ${e.message}")
-    }
+    nativeSdkWrapper.cancelTimer(key = key)
   }
 
   @ReactMethod
@@ -481,7 +391,7 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
       emitDeviceEvent(EVENT_AUTH_OVERLAY_PERMISSION, eventData)
     } else if (requestCode == BATTERY_OPTIMIZATION_REQUEST_CODE) {
       val eventData = mutableMapOf<Any, Any>()
-      eventData[ARGUMENT_STATE] = isAppIgnoringBatteryOptimization()
+      eventData[ARGUMENT_STATE] = reactContext.isAppIgnoringBatteryOptimization()
       emitDeviceEvent(EVENT_AUTH_BATTERY_PERMISSION, eventData)
     }
   }
@@ -493,98 +403,23 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
 
   @ReactMethod
   fun requestDrawOverlaysPermission() {
-    val intent = Intent(
-      Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
-      Uri.parse("package:${reactContext.packageName}")
-    )
-    reactContext.currentActivity!!.startActivityForResult(intent, OVERLAY_REQUEST_CODE)
-  }
-
-  private fun isAppIgnoringBatteryOptimization(): Boolean {
-    val packageName = reactContext.packageName
-    val pm: PowerManager = reactContext.getSystemService(Context.POWER_SERVICE) as PowerManager
-    return pm.isIgnoringBatteryOptimizations(packageName)
+    nativeSdkWrapper.requestDrawOverlaysPermission(reactContext)
   }
 
   @ReactMethod
   fun isAppIgnoringBatteryOptimization(promise: Promise) {
-    promise.resolve(isAppIgnoringBatteryOptimization())
+    promise.resolve(reactContext.isAppIgnoringBatteryOptimization())
   }
 
   @SuppressLint("BatteryLife")
   @ReactMethod
   fun requestAppIgnoringBatteryOptimization() {
-    val intent = Intent(
-      Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS,
-      Uri.parse("package:" + reactContext.packageName)
-    )
-    reactContext.currentActivity?.startActivityForResult(intent, BATTERY_OPTIMIZATION_REQUEST_CODE)
+    nativeSdkWrapper.requestAppIgnoringBatteryOptimization(reactContext)
   }
-  // endregion PERMISSIONS MODULE
-}
-
-internal 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
-}
 
-internal 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())
-      }
-    }
+  @ReactMethod
+  fun requestHealthPermissions(promise: Promise?) {
+    nativeSdkWrapper.requestHealthPermissions(promise)
   }
-  return data
+  // endregion PERMISSIONS MODULE
 }

package/android/src/main/AndroidManifest.xml

@@ -1,13 +1,3 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="in.dolph.move.sdk">
-  <application>
-    <receiver
-      android:name="in.dolph.move.sdk.WrapperBtConnectionsReceiver"
-      android:exported="true">
-      <intent-filter>
-        <action android:name="android.bluetooth.device.action.ACL_CONNECTED" />
-        <action android:name="android.bluetooth.device.action.ACL_DISCONNECTED" />
-      </intent-filter>
-    </receiver>
-  </application>
+          package="com.movesdk">
 </manifest>

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

@@ -1,4 +1,4 @@
-package `in`.dolph.move.sdk
+package com.movesdk
 
 import android.Manifest
 import android.annotation.SuppressLint
@@ -6,17 +6,20 @@ import android.bluetooth.BluetoothManager
 import android.bluetooth.le.ScanCallback
 import android.bluetooth.le.ScanResult
 import android.content.Context
-import android.content.SharedPreferences
 import android.content.pm.PackageManager
 import android.os.Build
 import androidx.core.content.ContextCompat
-import androidx.core.content.edit
-import com.google.gson.Gson
-import `in`.dolph.move.sdk.extentions.PermissionUtils
+import com.movesdk.extentions.PermissionUtils
+import com.movesdk.extentions.getConnectedDevices
 import io.dolphin.move.MoveDevice
 import io.dolphin.move.MoveSdk
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import java.nio.ByteBuffer
-import java.util.*
+import java.util.Locale
+import java.util.UUID
 
 private const val TAG = "Android native scanner"
 
@@ -29,7 +32,9 @@ class DeviceScanner(
   private var proximityId: String? = null
   private var manufacturerId: Int? = null
   private val btManager: BluetoothManager? = context.getSystemService(BluetoothManager::class.java)
-  private val gson = Gson()
+
+  private val mainScope = CoroutineScope(Dispatchers.Main)
+  private val ioContext = Dispatchers.IO
 
   private val leCallback = object : ScanCallback() {
     @SuppressLint("MissingPermission")
@@ -123,29 +128,22 @@ class DeviceScanner(
       onNewDevices.invoke(emptyList())
       return
     }
-    val sharedPreferences: SharedPreferences =
-      context.getSharedPreferences(
-        SHARED_PREF_CONNECTIONS_NAME,
-        Context.MODE_PRIVATE
-      )
+
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
       if (!isPermissionGranted(Manifest.permission.BLUETOOTH_CONNECT)) {
         onNewEvent(TAG, "Missing BLUETOOTH_CONNECT permission")
         onNewDevices.invoke(emptyList())
-        if (sharedPreferences.all.isNotEmpty()) {
-          sharedPreferences.edit { clear() }
-        }
         return
       }
     }
-    val connectedDevices = sharedPreferences.all.mapNotNull {
-      try {
-        gson.fromJson(it.value as? String, MoveDevice::class.java)
-      } catch (e: Exception) {
-        null
+    mainScope.launch {
+      val connectedDevices = withContext(ioContext) {
+        context.getConnectedDevices().mapNotNull {
+          MoveSdk.get()?.convertToMoveDevice(it)
+        }
       }
+      onNewDevices(connectedDevices)
     }
-    onNewDevices(connectedDevices)
   }
 
   @SuppressLint("MissingPermission")

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

@@ -1,7 +1,8 @@
-package `in`.dolph.move.sdk
+package com.movesdk
 
 import android.util.Log
 import com.facebook.react.bridge.ReadableMap
+import com.movesdk.shared.LOG_TAG
 import io.dolphin.move.DeviceDiscovery
 import io.dolphin.move.MoveDevice
 import io.dolphin.move.MoveOptions
@@ -56,7 +57,7 @@ fun extractMoveOptions(options: ReadableMap): MoveOptions? {
       ),
     )
   } catch (e: Exception) {
-    Log.e(MoveSdkModule.LOG_TAG, "Error extractions Move options from JS map: ${e.message}", e)
+    Log.e(LOG_TAG, "Error extractions Move options from JS map: ${e.message}", e)
     null
   }
 }