react-native-move-sdk 0.1.0

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

@@ -0,0 +1,18 @@
+package `in`.dolph.move.sdk
+
+import io.dolphin.move.DrivingService
+import io.dolphin.move.MoveAuth
+import io.dolphin.move.OtherService
+import io.dolphin.move.TimelineDetectionService
+import io.dolphin.move.WalkingService
+
+data class MoveSdkConfig(
+    val auth: MoveAuth,
+    val timelineDetectionServices: List<TimelineDetectionService>,
+    val drivingServices: List<DrivingService>,
+    val walkingServices: List<WalkingService>,
+    val otherServices: List<OtherService>,
+    val tripNotification: MoveNotificationConfig,
+    val recognitionNotification: MoveNotificationConfig,
+    val allowMockLocations: Boolean
+)

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

@@ -0,0 +1,293 @@
+package `in`.dolph.move.sdk
+
+import android.annotation.SuppressLint
+import android.app.Activity
+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.Promise
+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.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import io.dolphin.move.MoveSdk
+
+internal const val EVENT_INIT_ERROR = "DolphinSdk-InitError"
+internal const val EVENT_MOVE_STATE = "DolphinSdk-State"
+internal const val EVENT_TRIP_STATE = "DolphinSdk-TripState"
+internal const val EVENT_AUTH_STATE = "DolphinSdk-AuthState"
+internal const val EVENT_AUTH_BATTERY_PERMISSION = "DolphinSdk-Permission-BatteryOptimization"
+internal const val EVENT_AUTH_OVERLAY_PERMISSION = "DolphinSdk-Permission-Overlay"
+
+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 = "error"
+internal const val ARGUMENT_ERROR_REASON = "errorReason"
+
+internal const val PROMISE_OK = "OK"
+
+class MoveSdkModule(context: ReactApplicationContext) : ReactContextBaseJavaModule(context),
+  ActivityEventListener {
+
+  companion object {
+    const val LOG_TAG = "DOLPHIN_SDK"
+    const val ERROR_CODE = "DOLPHIN_SDK_ERROR"
+
+    // **** PERMISSIONS MODULE START *****
+    const val OVERLAY_REQUEST_CODE = 1
+    const val BATTERY_OPTIMIZATION_REQUEST_CODE = 2
+    // **** PERMISSIONS MODULE END *****
+  }
+
+  private val reactContext: ReactApplicationContext = context
+
+  private val nativeSdkWrapper = NativeMoveSdkWrapper.getInstance(reactContext)
+
+  init {
+    nativeSdkWrapper.applyDelegate(this)
+
+    // **** PERMISSIONS MODULE START *****
+    reactContext.addActivityEventListener(this)
+    // **** PERMISSIONS MODULE START *****
+  }
+
+  // **** PERMISSIONS MODULE START *****
+  override fun onNewIntent(intent: Intent) {
+    // Skip, currently obsolete ActivityEventListener callback
+  }
+  // **** PERMISSIONS MODULE START *****
+
+  @ReactMethod
+  fun initialize(
+    contractId: String,
+    accessToken: String,
+    refreshToken: String,
+    productId: Int,
+    // Config
+    timelineDetectionServices: ReadableArray,
+    drivingServices: ReadableArray,
+    walkingServices: ReadableArray,
+    otherServices: ReadableArray,
+    // Platform config
+    recognitionNotificationTitle: String,
+    recognitionNotificationText: String,
+    recognitionNotificationChannelId: String,
+    recognitionNotificationChannelName: String,
+    recognitionNotificationChannelDescription: String,
+    tripNotificationTitle: String,
+    tripNotificationText: String,
+    tripNotificationChannelId: String,
+    tripNotificationChannelName: String,
+    tripNotificationChannelDescription: String,
+    allowMockLocations: Boolean,
+    promise: Promise?
+  ) {
+
+    nativeSdkWrapper.initialize(
+      contractId,
+      accessToken,
+      refreshToken,
+      productId,
+      // Config
+      timelineDetectionServices,
+      drivingServices,
+      walkingServices,
+      otherServices,
+      // Platform config
+      recognitionNotificationTitle,
+      recognitionNotificationText,
+      recognitionNotificationChannelId,
+      recognitionNotificationChannelName,
+      recognitionNotificationChannelDescription,
+      tripNotificationTitle,
+      tripNotificationText,
+      tripNotificationChannelId,
+      tripNotificationChannelName,
+      tripNotificationChannelDescription,
+      allowMockLocations,
+      promise = promise
+    )
+  }
+
+  @ReactMethod
+  fun resolveError() {
+    nativeSdkWrapper.resolveError()
+  }
+
+  @ReactMethod
+  fun startAutomaticDetection() {
+    nativeSdkWrapper.startAutomaticDetection()
+  }
+
+  @ReactMethod
+  fun stopAutomaticDetection() {
+    nativeSdkWrapper.stopAutomaticDetection()
+  }
+
+  @ReactMethod
+  fun shutdown() {
+    nativeSdkWrapper.shutdown()
+  }
+
+  @ReactMethod
+  fun forceTripRecognition() {
+    nativeSdkWrapper.forceTripRecognition()
+  }
+
+  @ReactMethod
+  fun keepInForeground(enabled: Boolean) {
+    nativeSdkWrapper.keepInForeground(enabled)
+  }
+
+  @ReactMethod
+  fun keepActive(enabled: Boolean) {
+    nativeSdkWrapper.keepActive(enabled)
+  }
+
+  @ReactMethod
+  fun synchronizeUserData() {
+    nativeSdkWrapper.synchronizeUserData()
+  }
+
+  @ReactMethod
+  fun ignoreCurrentTrip() {
+    nativeSdkWrapper.ignoreCurrentTrip()
+  }
+
+  @ReactMethod
+  fun finishCurrentTrip() {
+    nativeSdkWrapper.finishCurrentTrip()
+  }
+
+  @ReactMethod
+  fun getState(promise: Promise) {
+    nativeSdkWrapper.getState(promise)
+  }
+
+  @ReactMethod
+  fun getTripState(promise: Promise) {
+    nativeSdkWrapper.getTripState(promise)
+  }
+
+  @ReactMethod
+  fun updateAuth(
+    contractId: String,
+    accessToken: String,
+    refreshToken: String,
+    productId: Int
+  ) {
+    nativeSdkWrapper.updateAuth(contractId, accessToken, refreshToken, productId)
+  }
+
+  @ReactMethod
+  fun getAuthState(promise: Promise) {
+    nativeSdkWrapper.getAuthState(promise)
+  }
+
+  override fun getName(): String {
+    return "DolphinSdk"
+  }
+
+  override fun getConstants(): MutableMap<String, Any> {
+    val constants: HashMap<String, Any> = HashMap()
+    constants["version"] = MoveSdk.version
+    return constants
+  }
+
+  internal fun emitDeviceEvent(eventName: String, eventData: WritableMap?) {
+    try {
+      reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit(eventName, 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.
+    }
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    // Set up any upstream listeners or background tasks as necessary
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    // Remove upstream listeners, stop unnecessary background tasks
+  }
+
+  // **** PERMISSIONS MODULE START *****
+  @SuppressLint("NewApi")
+  override fun onActivityResult(
+    activity: Activity,
+    requestCode: Int,
+    resultCode: Int,
+    data: Intent?
+  ) {
+    if (requestCode == OVERLAY_REQUEST_CODE) {
+      val eventData = Arguments.createMap()
+      eventData.putBoolean(ARGUMENT_STATE, Settings.canDrawOverlays(reactContext))
+      emitDeviceEvent(EVENT_AUTH_OVERLAY_PERMISSION, eventData)
+    } else if (requestCode == BATTERY_OPTIMIZATION_REQUEST_CODE) {
+      val eventData = Arguments.createMap()
+      eventData.putBoolean(ARGUMENT_STATE, isAppIgnoringBatteryOptimization())
+      emitDeviceEvent(EVENT_AUTH_BATTERY_PERMISSION, eventData)
+    }
+  }
+
+  @ReactMethod
+  fun canDrawOverlays(promise: Promise) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      promise.resolve(Settings.canDrawOverlays(reactContext))
+    } else {
+      promise.resolve(true)
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  @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
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      return pm.isIgnoringBatteryOptimizations(packageName)
+    } else {
+      return true
+    }
+  }
+
+  @ReactMethod
+  fun isAppIgnoringBatteryOptimization(promise: Promise) {
+    promise.resolve(isAppIgnoringBatteryOptimization())
+  }
+
+  @SuppressLint("BatteryLife")
+  @RequiresApi(Build.VERSION_CODES.M)
+  @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)
+  }
+  // **** PERMISSIONS MODULE END *****
+}

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

@@ -0,0 +1,19 @@
+package `in`.dolph.move.sdk
+
+import android.view.View
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+
+class MoveSdkPackage : ReactPackage {
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): MutableList<ViewManager<out View, out ReactShadowNode<*>>> {
+        return mutableListOf()
+    }
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
+        return mutableListOf(MoveSdkModule(reactContext))
+    }
+}

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

@@ -0,0 +1,194 @@
+package `in`.dolph.move.sdk
+
+import android.content.Context
+import android.content.SharedPreferences
+import io.dolphin.move.DrivingService
+import io.dolphin.move.MoveAuth
+import io.dolphin.move.OtherService
+import io.dolphin.move.TimelineDetectionService
+import io.dolphin.move.WalkingService
+
+private const val SHARED_PREF_NAME = "move-react"
+
+private const val PROPERTY_TIMELINE_SERVICES = "timelineDetectionServices"
+private const val PROPERTY_DRIVING_SERVICES = "drivingServices"
+private const val PROPERTY_WALKING_SERVICES = "walkingServices"
+private const val PROPERTY_OTHER_SERVICES = "otherServices"
+
+private const val PROPERTY_PRODUCT_ID = "productId"
+private const val PROPERTY_CONTRACT_ID = "contractId"
+private const val PROPERTY_ACCESS_TOKEN = "accessToken"
+private const val PROPERTY_REFRESH_TOKEN = "refreshToken"
+
+private const val PROPERTY_ALLOW_MOCK = "allowMockLocations"
+private const val PROPERTY_STARTED = "isInRunningState"
+
+private const val PROPERTY_NOTIFICATION_TITLE = "NotificationTitle"
+private const val PROPERTY_NOTIFICATION_TEXT = "NotificationText"
+private const val PROPERTY_NOTIFICATION_CHANNELID = "NotificationChannelId"
+private const val PROPERTY_NOTIFICATION_CHANNELNAME = "NotificationChannelName"
+private const val PROPERTY_NOTIFICATION_CHANNELDESCRIPTION = "NotificationChannelName"
+
+private const val NOTIFICATION_RECOGNITION = "recognition"
+private const val NOTIFICATION_TRIP = "trip"
+
+class MoveSdkConfigRepository(context: Context) {
+
+    private val sharedPreferences: SharedPreferences =
+        context.applicationContext.getSharedPreferences(
+            SHARED_PREF_NAME,
+            Context.MODE_PRIVATE
+        )
+
+    fun storeConfig(config: MoveSdkConfig) {
+
+        // Persist data for native init next app start
+        val editor = sharedPreferences.edit()
+
+        storeAuth(config.auth)
+
+        editor.putStringSet(
+            PROPERTY_TIMELINE_SERVICES,
+            config.timelineDetectionServices.map { it.toString() }.toSet()
+        )
+        editor.putStringSet(
+            PROPERTY_DRIVING_SERVICES,
+            config.drivingServices.map { it.toString() }.toSet()
+        )
+        editor.putStringSet(
+            PROPERTY_WALKING_SERVICES,
+            config.walkingServices.map { it.toString() }.toSet()
+        )
+        editor.putStringSet(
+            PROPERTY_OTHER_SERVICES,
+            config.otherServices.map { it.toString() }.toSet()
+        )
+
+        editor.putBoolean(PROPERTY_ALLOW_MOCK, config.allowMockLocations)
+        editor.apply()
+
+        // Platform config
+        val recognitionNotification = config.recognitionNotification
+        storeNotificationConfig(NOTIFICATION_RECOGNITION, recognitionNotification)
+
+        val tripNotification = config.tripNotification
+        storeNotificationConfig(NOTIFICATION_TRIP, tripNotification)
+    }
+
+    private fun storeNotificationConfig(
+        prefix: String,
+        recognitionNotification: MoveNotificationConfig
+    ) {
+        val editor = sharedPreferences.edit()
+        editor.putString(prefix + PROPERTY_NOTIFICATION_TITLE, recognitionNotification.title)
+        editor.putString(prefix + PROPERTY_NOTIFICATION_TEXT, recognitionNotification.text)
+        editor.putString(
+            prefix + PROPERTY_NOTIFICATION_CHANNELID,
+            recognitionNotification.channelId
+        )
+        editor.putString(
+            prefix + PROPERTY_NOTIFICATION_CHANNELNAME,
+            recognitionNotification.channelName
+        )
+        editor.putString(
+            prefix + PROPERTY_NOTIFICATION_CHANNELDESCRIPTION,
+            recognitionNotification.channelDescription
+        )
+        editor.apply()
+    }
+
+    fun storeAuth(auth: MoveAuth) {
+        // Persist data for native init next app start
+        val editor = sharedPreferences.edit()
+        editor.putInt(PROPERTY_PRODUCT_ID, auth.productId.toInt())
+        editor.putString(PROPERTY_CONTRACT_ID, auth.contractId)
+        editor.putString(PROPERTY_ACCESS_TOKEN, auth.accessToken)
+        editor.putString(PROPERTY_REFRESH_TOKEN, auth.refreshToken)
+        editor.apply()
+    }
+
+    fun loadConfig(): MoveSdkConfig {
+
+        val productId = sharedPreferences.getInt(PROPERTY_PRODUCT_ID, 0)
+        val contractId = sharedPreferences.getString(PROPERTY_CONTRACT_ID, "") ?: ""
+        val accessToken: String = sharedPreferences.getString(PROPERTY_ACCESS_TOKEN, "") ?: ""
+        val refreshToken = sharedPreferences.getString(PROPERTY_REFRESH_TOKEN, "") ?: ""
+
+        // Config
+
+        val timelineDetectionServices: List<TimelineDetectionService> =
+            sharedPreferences.getStringSet(PROPERTY_TIMELINE_SERVICES, emptySet())?.map {
+                TimelineDetectionService.valueOf(it)
+            } ?: emptyList()
+
+        val drivingServices: List<DrivingService> =
+            sharedPreferences.getStringSet(PROPERTY_DRIVING_SERVICES, emptySet())?.map {
+                DrivingService.valueOf(it)
+            } ?: emptyList()
+
+        val walkingServices: List<WalkingService> =
+            sharedPreferences.getStringSet(PROPERTY_WALKING_SERVICES, emptySet())?.map {
+                WalkingService.valueOf(it)
+            } ?: emptyList()
+
+        val otherServices: List<OtherService> =
+            sharedPreferences.getStringSet(PROPERTY_OTHER_SERVICES, emptySet())?.map {
+                OtherService.valueOf(it)
+            } ?: emptyList()
+
+        // Platform config
+        val allowMockLocations: Boolean = sharedPreferences.getBoolean(PROPERTY_ALLOW_MOCK, false)
+
+        val recognitionNotification = loadNotificationConfig(NOTIFICATION_RECOGNITION)
+        val tripNotification = loadNotificationConfig(NOTIFICATION_TRIP)
+
+        return MoveSdkConfig(
+            auth = MoveAuth(
+                contractId = contractId,
+                accessToken = accessToken,
+                refreshToken = refreshToken,
+                productId = productId.toLong(),
+            ),
+            timelineDetectionServices = timelineDetectionServices,
+            drivingServices = drivingServices,
+            walkingServices = walkingServices,
+            otherServices = otherServices,
+            tripNotification = tripNotification,
+            recognitionNotification = recognitionNotification,
+            allowMockLocations = allowMockLocations
+        )
+    }
+
+    private fun loadNotificationConfig(prefix: String): MoveNotificationConfig {
+        val notificationTitle: String =
+            sharedPreferences.getString(prefix + PROPERTY_NOTIFICATION_TITLE, "") ?: ""
+        val notificationText: String =
+            sharedPreferences.getString(prefix + PROPERTY_NOTIFICATION_TEXT, "") ?: ""
+        val notificationChannelId: String =
+            sharedPreferences.getString(prefix + PROPERTY_NOTIFICATION_CHANNELID, "") ?: ""
+        val notificationChannelName: String =
+            sharedPreferences.getString(prefix + PROPERTY_NOTIFICATION_CHANNELNAME, "") ?: ""
+        val notificationChannelDescription: String =
+            sharedPreferences.getString(prefix + PROPERTY_NOTIFICATION_CHANNELDESCRIPTION, "") ?: ""
+
+        return MoveNotificationConfig(
+            title = notificationTitle,
+            text = notificationText,
+            channelId = notificationChannelId,
+            channelName = notificationChannelName,
+            channelDescription = notificationChannelDescription
+        )
+    }
+
+    fun storeRunningState(running: Boolean) {
+        sharedPreferences.edit().putBoolean(PROPERTY_STARTED, running).apply()
+    }
+
+    fun loadRunningState(): Boolean {
+        return sharedPreferences.getBoolean(PROPERTY_STARTED, false)
+    }
+
+    fun clear() {
+        sharedPreferences.edit().clear().apply()
+    }
+}