react-native-move-sdk 2.4.1 → 2.4.3

package/android/build.gradle

@@ -29,7 +29,7 @@ def getExtOrIntegerDefault(name) {
 android {
   compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
   defaultConfig {
-    minSdkVersion 16
+    minSdkVersion 26
     targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
     versionCode 1
     versionName "1.0"
@@ -66,8 +66,6 @@ repositories {
     url "https://dolphin.jfrog.io/artifactory/move-sdk-libs-release"
   }
 
-
-
   def found = false
   def defaultDir = null
   def androidSourcesName = 'React Native sources'
@@ -144,7 +142,7 @@ dependencies {
   // noinspection GradleDynamicVersion
 
   implementation "com.facebook.react:react-native:+"
-  api "io.dolphin.move:move-sdk:2.4.1.70"
+  api "io.dolphin.move:move-sdk:2.4.2.71"
 
   testImplementation 'junit:junit:4.13.2'
   testImplementation "androidx.test:core:1.4.0"

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,13 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           package="in.dolph.move.sdk">
+  <application>
+    <receiver
+      android:name="in.dolph.move.sdk.BluetoothConnectionsReceiver"
+      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>
 </manifest>

package/android/src/main/java/in/dolph/move/sdk/BluetoothConnectionsReceiver.kt

@@ -0,0 +1,96 @@
+package `in`.dolph.move.sdk
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothDevice
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+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 io.dolphin.move.MoveDevice
+
+const val SHARED_PREF_CONNECTIONS_NAME = "move-react-connections"
+
+class BluetoothConnectionsReceiver : BroadcastReceiver() {
+  override fun onReceive(context: Context, intent: Intent?) {
+    val device: BluetoothDevice =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        intent?.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
+      } else {
+        intent?.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+      } ?: return
+
+    when (intent?.action) {
+      BluetoothDevice.ACTION_ACL_CONNECTED -> {
+        handleDeviceConnection(context.applicationContext, device, true)
+      }
+
+      BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
+        handleDeviceConnection(context.applicationContext, device, false)
+      }
+    }
+  }
+
+  @SuppressLint("MissingPermission")
+  private fun handleDeviceConnection(context: Context, device: BluetoothDevice, isConnected: Boolean) {
+    val nativeSdkWrapper = NativeMoveSdkWrapper.getInstance(context.applicationContext)
+    if (!hasBluetoothReadPermissions(context)) {
+      nativeSdkWrapper.emitDeviceEvent(EVENT_MOVE_SDK_APP, "Missing BLUETOOTH_CONNECT permission")
+      nativeSdkWrapper.emitDeviceEvent(EVENT_MOVE_DEVICES, emptyList<MoveDevice>().toTypedArray())
+      return
+    }
+    val sharedPreferences: SharedPreferences =
+      context.getSharedPreferences(
+        SHARED_PREF_CONNECTIONS_NAME,
+        Context.MODE_PRIVATE
+      )
+    val name = device.name ?: device.address ?: ""
+    val moveDevice = MoveDevice(
+      id = device.address ?: "",
+      name = name,
+      manufacturerId = null,
+    )
+    nativeSdkWrapper.emitDeviceEvent(
+      EVENT_MOVE_SDK_APP,
+      "Device ${moveDevice.name} is ${if (isConnected) "connected" else "disconnected"}"
+    )
+    val gson = Gson()
+    val jsonString = try {
+      gson.toJson(moveDevice)
+    } catch (e: Exception) {
+      nativeSdkWrapper.emitDeviceEvent(EVENT_MOVE_SDK_APP, "Error parsing MoveDevice to json string")
+      null
+    }
+    sharedPreferences.edit {
+      if (isConnected) {
+        putString(moveDevice.id, jsonString)
+      } else {
+        remove(moveDevice.id)
+      }
+    }
+    val connectedDevices = sharedPreferences.all.mapNotNull {
+      try {
+        gson.fromJson(it.value as? String, MoveDevice::class.java)
+      } catch (e: Exception) {
+        null
+      }
+    }
+    nativeSdkWrapper.emitDeviceEvent(EVENT_MOVE_DEVICES, connectedDevices.toMoveDeviceTypedArray())
+  }
+
+  private fun hasBluetoothReadPermissions(context: Context): Boolean {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      ContextCompat.checkSelfPermission(
+        context,
+        Manifest.permission.BLUETOOTH_CONNECT
+      ) == PackageManager.PERMISSION_GRANTED
+    } else {
+      true
+    }
+  }
+}

package/android/src/main/java/in/dolph/move/sdk/DeviceScanner.kt

@@ -0,0 +1,186 @@
+package `in`.dolph.move.sdk
+
+import android.Manifest
+import android.annotation.SuppressLint
+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 io.dolphin.move.MoveDevice
+import io.dolphin.move.MoveSdk
+import java.nio.ByteBuffer
+import java.util.*
+
+private const val TAG = "Android native scanner"
+
+class DeviceScanner(
+  private val context: Context,
+) {
+
+  private val discoveredDevices = mutableSetOf<MoveDevice>()
+  private var onNewDevices: ((List<MoveDevice>) -> Unit)? = null
+  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 leCallback = object : ScanCallback() {
+    @SuppressLint("MissingPermission")
+    override fun onScanResult(callbackType: Int, result: ScanResult) {
+      if (proximityId != null && manufacturerId != null) {
+        val manufacturerSpecificDataId =
+          manufacturerId?.let { result.scanRecord?.getManufacturerSpecificData(it) }
+        val uuid = getProximityUUID(manufacturerSpecificDataId)
+        if (uuid.isNullOrEmpty() || !uuid.equals(proximityId, true)) return
+      }
+      val device = MoveSdk.get()?.convertToMoveDevice(result) ?: return
+      if (!discoveredDevices.contains(device)) {
+        discoveredDevices.add(device)
+        onNewDevices?.invoke(listOf(device))
+      }
+    }
+  }
+
+  @SuppressLint("MissingPermission")
+  fun startScanning(
+    filters: List<String>,
+    manufacturerId: Int?,
+    uuid: String?,
+    onNewDevices: (List<MoveDevice>) -> Unit,
+    onNewEvent: (String, String?) -> Unit,
+  ) {
+    if (filters.contains(MoveDeviceFilter.PAIRED.filter)) {
+      proceedWithConnectedDevices(onNewDevices, onNewEvent)
+    }
+    if (filters.contains(MoveDeviceFilter.BEACON.filter)) {
+      this.onNewDevices = onNewDevices
+      this.proximityId = uuid
+      this.manufacturerId = manufacturerId
+      proceedWithBleDevices(onNewDevices, onNewEvent)
+    }
+  }
+
+  @SuppressLint("MissingPermission")
+  fun stopScanning() {
+    btManager?.adapter?.bluetoothLeScanner?.stopScan(leCallback)
+    onNewDevices = null
+    proximityId = null
+    manufacturerId = null
+  }
+
+  private fun getProximityUUID(manufacturerSpecificData: ByteArray?): String? {
+    if (manufacturerSpecificData == null || manufacturerSpecificData.size < 23) {
+      return null
+    }
+    val resultBuffer = ByteBuffer.wrap(manufacturerSpecificData)
+    val uuidA = resultBuffer.getLong(2)
+    val uuidB = resultBuffer.getLong(10)
+    val uuid = UUID(uuidA, uuidB)
+    return uuid.toString().uppercase(Locale.getDefault())
+  }
+
+  private fun isPermissionGranted(permission: String): Boolean {
+    return try {
+      ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+    } catch (e: Exception) {
+      false
+    }
+  }
+
+  private fun proceedWithConnectedDevices(
+    onNewDevices: (List<MoveDevice>) -> Unit,
+    onNewEvent: (String, String?) -> Unit,
+  ) {
+    val hasFeature = context.packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH)
+    if (!hasFeature) {
+      onNewEvent(TAG, "Missing FEATURE_BLUETOOTH")
+      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
+      }
+    }
+    onNewDevices(connectedDevices)
+  }
+
+  @SuppressLint("MissingPermission")
+  private fun proceedWithBleDevices(
+    onNewDevices: (List<MoveDevice>) -> Unit,
+    onNewEvent: (String, String?) -> Unit,
+  ) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      if (!isPermissionGranted(Manifest.permission.BLUETOOTH_SCAN)) {
+        onNewEvent(TAG, "Missing BLUETOOTH_SCAN permission")
+        onNewDevices.invoke(emptyList())
+        return
+      }
+      if (!isPermissionGranted(Manifest.permission.BLUETOOTH_CONNECT)) {
+        onNewEvent(TAG, "Missing BLUETOOTH_CONNECT permission")
+        onNewDevices.invoke(emptyList())
+        return
+      }
+    }
+    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
+      if (!isPermissionGranted(Manifest.permission.ACCESS_FINE_LOCATION)) {
+        onNewEvent(TAG, "Missing ACCESS_FINE_LOCATION permission")
+        onNewDevices.invoke(emptyList())
+        return
+      }
+      if (!isPermissionGranted(Manifest.permission.BLUETOOTH_ADMIN)) {
+        onNewEvent(TAG, "Missing BLUETOOTH_ADMIN permission")
+        onNewDevices.invoke(emptyList())
+        return
+      }
+    }
+    if (Build.VERSION.SDK_INT == Build.VERSION_CODES.R || Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {
+      if (!isPermissionGranted(Manifest.permission.ACCESS_BACKGROUND_LOCATION)) {
+        onNewEvent(TAG, "Missing ACCESS_BACKGROUND_LOCATION permission")
+        onNewDevices.invoke(emptyList())
+        return
+      }
+    }
+    if (btManager?.adapter?.isEnabled == false) {
+      onNewEvent(TAG, "Please turn on bluetooth")
+      onNewDevices.invoke(emptyList())
+      return
+    }
+    val hasFeature = context.packageManager.hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)
+    if (!hasFeature) {
+      onNewEvent(TAG, "Missing FEATURE_BLUETOOTH_LE")
+      onNewDevices.invoke(emptyList())
+      return
+    }
+    discoveredDevices.clear()
+    btManager?.adapter?.bluetoothLeScanner?.startScan(leCallback)
+  }
+}
+
+enum class MoveDeviceFilter(val filter: String) {
+  BEACON("beacon"),
+  PAIRED("paired");
+}

package/android/src/main/java/in/dolph/move/sdk/Mapper.kt

@@ -0,0 +1,27 @@
+package `in`.dolph.move.sdk
+
+import io.dolphin.move.MoveDevice
+import io.dolphin.move.MoveScanResult
+
+fun List<MoveScanResult>.toScanResultArray(): Array<Any> {
+  val data = mutableListOf<Any>()
+  forEach {
+    val map = mutableMapOf<String, Any?>()
+    map["isDiscovered"] = it.isDiscovered
+    map["name"] = it.device.name
+    map["device"] = it.device.toJsonString()
+    data.add(map)
+  }
+  return data.toTypedArray()
+}
+
+fun List<MoveDevice>.toMoveDeviceTypedArray(): Array<Any> {
+  val devices = mutableListOf<Any>()
+  forEach {
+    val map = mutableMapOf<String, Any?>()
+    map["name"] = it.name
+    map["data"] = it.toJsonString()
+    devices.add(map)
+  }
+  return devices.toTypedArray()
+}

package/android/src/main/java/in/dolph/move/sdk/MoveExtensions.kt

@@ -1,5 +1,6 @@
 package `in`.dolph.move.sdk
 
+import com.google.gson.Gson
 import io.dolphin.move.MoveDetectionService
 import java.util.Locale
 import java.util.regex.Pattern
@@ -61,3 +62,11 @@ fun String.snakeToUpperCamelCaseParam(): String {
 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) {
+    ""
+  }
+}

package/android/src/main/java/in/dolph/move/sdk/MoveSdkModule.kt

@@ -17,6 +17,7 @@ import com.facebook.react.bridge.ReactApplicationContext
 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
@@ -30,8 +31,11 @@ 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 ARGUMENT_ACCESS_TOKEN = "accessToken"
 internal const val ARGUMENT_REFRESH_TOKEN = "refreshToken"
@@ -42,6 +46,8 @@ 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 PROMISE_OK = "OK"
 
@@ -86,7 +92,7 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
     timelineDetectionServices: ReadableArray,
     drivingServices: ReadableArray,
     walkingServices: ReadableArray,
-    options: ReadableArray,
+    options: ReadableMap?,
     // Platform config
     recognitionNotificationTitle: String,
     recognitionNotificationText: String,
@@ -100,7 +106,6 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
     tripNotificationChannelDescription: String,
     promise: Promise?
   ) {
-
     nativeSdkWrapper.setup(
       userId,
       accessToken,
@@ -260,6 +265,17 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
     }
   }
 
+  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.
+    }
+  }
+
   @ReactMethod
   fun addListener(eventName: String) {
     // Set up any upstream listeners or background tasks as necessary
@@ -294,6 +310,45 @@ class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModu
     promise.resolve(isAuthValid)
   }
 
+  @ReactMethod
+  fun registerDevices(devices: ReadableArray) {
+    try {
+      nativeSdkWrapper.registerDevices(devices.toArrayList() as? ArrayList<Map<String, String>>)
+    } catch (t: Throwable) {
+      Log.e("SDK Module", t.message, t)
+    }
+  }
+
+  @ReactMethod
+  fun unregisterDevices(devices: ReadableArray) {
+    try {
+      nativeSdkWrapper.unregisterDevices(devices.toArrayList() as? ArrayList<Map<String, String>>)
+    } catch (t: Throwable) {
+      Log.e("SDK Module", t.message, t)
+    }
+  }
+
+  @ReactMethod
+  fun getRegisteredDevices(promise: Promise) {
+    nativeSdkWrapper.getRegisteredDevices(promise)
+  }
+
+  @ReactMethod
+  fun startScanningDevices(filter: ReadableArray?, uuid: String?, manufacturerId: Int?) {
+    Log.i("MODULE_SCAN_DEVICE", "startScanningDevices: ${filter}")
+    val filters = try {
+      filter?.toArrayList()?.map { it.toString() }.orEmpty()
+    } catch (e: Exception) {
+      emptyList<String>()
+    }
+    nativeSdkWrapper.startScanningDevices(filters, manufacturerId, uuid)
+  }
+
+  @ReactMethod
+  fun stopScanningDevices() {
+    nativeSdkWrapper.stopScanningDevices()
+  }
+
   // region PERMISSIONS MODULE
   @SuppressLint("NewApi")
   override fun onActivityResult(
@@ -368,18 +423,23 @@ internal fun Array<*>.toWritableArray(): WritableArray {
       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())
       }
@@ -397,18 +457,23 @@ internal fun Map<*, *>.toWritableMap(): WritableMap {
       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())
       }