react-native-move-sdk 0.1.5 → 0.2.1

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

@@ -3,24 +3,26 @@ package `in`.dolph.move.sdk
 import android.annotation.SuppressLint
 import android.content.Context
 import android.util.Log
-import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.WritableMap
+import io.dolphin.move.AssistanceCallState
 import io.dolphin.move.DrivingService
 import io.dolphin.move.MoveAuth
 import io.dolphin.move.MoveAuthState
+import io.dolphin.move.MoveConfig
 import io.dolphin.move.MoveConfigurationError
+import io.dolphin.move.MoveDetectionService
 import io.dolphin.move.MoveSdk
 import io.dolphin.move.MoveSdkState
+import io.dolphin.move.MoveServiceFailure
+import io.dolphin.move.MoveServiceWarning
 import io.dolphin.move.MoveTripState
-import io.dolphin.move.OtherService
-import io.dolphin.move.TimelineDetectionService
 import io.dolphin.move.WalkingService
 
 @SuppressLint("StaticFieldLeak", "MissingPermission")
 class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener,
-  MoveSdk.InitializeListener, MoveSdk.TripStateListener, MoveSdk.AuthStateUpdateListener {
+  MoveSdk.InitializeListener, MoveSdk.TripStateListener, MoveSdk.AuthStateUpdateListener,
+  MoveSdk.MoveLogCallback, MoveSdk.MoveErrorListener, MoveSdk.MoveWarningListener {
 
   companion object {
 
@@ -39,31 +41,50 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
 
   private var delegate: MoveSdkModule? = null
 
-  fun isNativeInitializationEnabled(): Boolean {
-    val config = configRepository.loadConfig()
-    val accessToken: String = config.auth.accessToken
-    val isInRunningState = configRepository.loadRunningState()
-    return isInRunningState && accessToken.isNotEmpty()
-  }
+  fun init(context: Context) {
+    val moveSdk = MoveSdk.init(context.applicationContext)
+
+    moveSdk.sdkStateListener(this)
+    moveSdk.tripStateListener(this)
+    moveSdk.authStateUpdateListener(this)
+    moveSdk.initializationListener(this)
+    moveSdk.setLogListener(this)
 
-  fun initNative() {
-    Log.i("MoveModule", "Init native")
+    moveSdk.setServiceErrorListener(this)
+    moveSdk.setServiceWarningListener(this)
 
+    // Initialize notifications by default (might be overwritten by setup)
     val config: MoveSdkConfig = configRepository.loadConfig()
-    initialize(config)
+    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) {
+    MoveSdk.get()?.allowMockLocations(allowMockLocations)
   }
 
   @SuppressLint("MissingPermission")
-  fun initialize(
-    contractId: String,
+  fun setup(
+    userId: String,
     accessToken: String,
     refreshToken: String,
-    productId: Int,
+    projectId: Int,
     // Config
     timelineDetectionServices: ReadableArray,
     drivingServices: ReadableArray,
     walkingServices: ReadableArray,
-    otherServices: ReadableArray,
     // Platform config
     recognitionNotificationTitle: String,
     recognitionNotificationText: String,
@@ -75,29 +96,37 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     tripNotificationChannelId: String,
     tripNotificationChannelName: String,
     tripNotificationChannelDescription: String,
-    allowMockLocations: Boolean,
     promise: Promise?
   ) {
 
-    val timelineDetectionServicesToUse = mutableListOf<TimelineDetectionService>()
+    val timelineDetectionServicesToUse = mutableListOf<MoveDetectionService>()
     val drivingServicesToUse = mutableListOf<DrivingService>()
     val walkingServicesToUse = mutableListOf<WalkingService>()
-    val otherServicesToUse = mutableListOf<OtherService>()
-
-    timelineDetectionServices.toArrayList().forEach {
-      timelineDetectionServicesToUse.add(TimelineDetectionService.valueOf("$it"))
-    }
 
     walkingServices.toArrayList().forEach {
-      walkingServicesToUse.add(WalkingService.valueOf("$it"))
+      try {
+        walkingServicesToUse.add(WalkingService.valueOf(it.toString().snakeToLowerCamelCase()))
+      } catch (t: Throwable) {
+        t.printStackTrace()
+      }
     }
 
     drivingServices.toArrayList().forEach {
-      drivingServicesToUse.add(DrivingService.valueOf("$it"))
+      try {
+        drivingServicesToUse.add(DrivingService.valueOf(it.toString().snakeToLowerCamelCase()))
+      } catch (t: Throwable) {
+        t.printStackTrace()
+      }
     }
 
-    otherServices.toArrayList().forEach {
-      otherServicesToUse.add(OtherService.valueOf("$it"))
+    timelineDetectionServices.toArrayList().forEach { service ->
+      timelineDetectionServicesToUse.add(
+        valueOfMoveDetectionService(
+          service.toString(),
+          drivingServicesToUse,
+          walkingServicesToUse
+        )
+      )
     }
 
     val recognitionNotification = MoveNotificationConfig(
@@ -114,55 +143,42 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
       tripNotificationChannelName,
       tripNotificationChannelDescription,
     )
+    // TODO - just use recognition notification for now
+    val walkingNotification = recognitionNotification
 
     try {
       Log.d(MoveSdkModule.LOG_TAG, "MOVE SDK Version " + MoveSdk.version)
 
+      val moveAuth = MoveAuth(
+        userId = userId,
+        accessToken = accessToken,
+        refreshToken = refreshToken,
+        projectId = projectId.toLong(),
+      )
+      val moveConfig = MoveConfig(timelineDetectionServicesToUse)
+      val moveSdk = MoveSdk.setup(moveAuth, moveConfig)
+
       val moveSdkConfig = MoveSdkConfig(
-        auth = MoveAuth(
-          contractId = contractId,
-          accessToken = accessToken,
-          refreshToken = refreshToken,
-          productId = productId.toLong(),
-        ),
         timelineDetectionServices = timelineDetectionServicesToUse,
-        drivingServices = drivingServicesToUse,
-        walkingServices = walkingServicesToUse,
-        otherServices = otherServicesToUse,
-        tripNotification = tripNotification,
+        auth = moveAuth,
         recognitionNotification = recognitionNotification,
-        allowMockLocations = allowMockLocations
+        tripNotification = tripNotification,
+        walkingNotification = walkingNotification
       )
-
       configRepository.storeConfig(moveSdkConfig)
-      initialize(moveSdkConfig)
+
+      moveSdk.tripNotification(recognitionNotification.toAndroidNotification(context))
+      moveSdk.recognitionNotification(tripNotification.toAndroidNotification(context))
+      moveSdk.walkingLocationNotification(walkingNotification.toAndroidNotification(context))
 
       promise?.resolve(PROMISE_OK)
     } catch (t: Throwable) {
-      promise?.reject(MoveSdkModule.ERROR_CODE, t.message)
+      promise?.reject(Exception("SETUP_ERROR"))
     }
   }
 
-  private fun initialize(config: MoveSdkConfig) {
-    MoveSdk.Builder()
-      .authentication(config.auth)
-      .initializationListener(this)
-      .sdkStateListener(this)
-      .authStateUpdateListener(this)
-      .tripStateListener(this)
-      .timelineDetectionService(config.timelineDetectionServices)
-      .drivingServices(config.drivingServices)
-      .walkingServices(config.walkingServices)
-      .otherServices(config.otherServices)
-      .recognitionNotification(config.tripNotification.toAndroidNotification(context))
-      .tripNotification(config.recognitionNotification.toAndroidNotification(context))
-      .allowMockLocations(config.allowMockLocations)
-      .consoleLogging(true)
-      .init(context)
-  }
-
   fun resolveError() {
-    (MoveSdk.get()?.getSdkState() as MoveSdkState.Error).resolved()
+    MoveSdk.get()?.resolveError()
   }
 
   fun startAutomaticDetection() {
@@ -187,6 +203,14 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     MoveSdk.get()?.forceTripRecognition()
   }
 
+  fun getErrors(): List<MoveServiceFailure>? {
+    return MoveSdk.get()?.getServiceErrors()
+  }
+
+  fun getWarnings(): List<MoveServiceWarning>? {
+    return MoveSdk.get()?.getServiceWarnings()
+  }
+
   fun keepInForeground(enabled: Boolean) {
     MoveSdk.get()?.keepInForeground(enabled)
   }
@@ -211,7 +235,7 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
 
   fun getState(promise: Promise) {
     MoveSdk.get()?.let {
-      promise.resolve(it.getSdkState().toString())
+      promise.resolve(it.getSdkState().toString().toSnakeCase())
     } ?: promise.resolve(null)
   }
 
@@ -221,20 +245,47 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     } ?: promise.resolve(MoveTripState.UNKNOWN.toString())
   }
 
+  fun initiateAssistanceCall(promise: Promise) {
+    MoveSdk.get()?.initiateAssistanceCall(object : MoveSdk.AssistanceStateListener {
+      override fun onAssistanceStateChanged(assistanceState: AssistanceCallState) {
+        if (assistanceState == AssistanceCallState.SUCCESS) {
+          promise.resolve(true)
+        } else {
+          promise.reject(Exception(assistanceState.name.toSnakeCase()))
+        }
+      }
+    }) ?: promise.reject(Exception("ASSISTANCE_CALL_ERROR"))
+  }
+
+  fun geocode(latitude: Double, longitude: Double, promise: Promise) {
+    MoveSdk.get()?.let {
+      it.geocode(latitude, longitude) { result ->
+        val error = result.error
+        if (error != null) {
+          promise.reject(Exception(error.name.toSnakeCase()))
+        } else {
+          val address = result.address
+          promise.resolve(address)
+        }
+      }
+    } ?: promise.reject(Exception("GEOCODE_ERROR"))
+  }
+
   override fun onError(error: MoveConfigurationError) {
-    val data = Arguments.createMap()
-    data.putString(ARGUMENT_ERROR, error.toString())
+    val data = mutableMapOf<Any, Any>()
+    data[ARGUMENT_ERROR] = error.toString().toSnakeCase()
     emitDeviceEvent(EVENT_INIT_ERROR, data)
   }
 
   override fun onStateChanged(sdk: MoveSdk, state: MoveSdkState) {
-    val data = Arguments.createMap()
-
-    data.putString(ARGUMENT_STATE, state.toString())
+    val data = mutableMapOf<Any, Any>()
+    data[ARGUMENT_STATE] = state.toString().toSnakeCase()
 
+    /**
+     * There is no SDK State Error anymore
     if (state is MoveSdkState.Error) {
-      data.putString(ARGUMENT_ERROR_REASON, state.reason.toString())
-    }
+    data.putString(ARGUMENT_ERROR_REASON, state.reason.toString())
+    }**/
     emitDeviceEvent(EVENT_MOVE_STATE, data)
 
     if (state is MoveSdkState.Ready) {
@@ -250,8 +301,8 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
   }
 
   override fun onTripStateChanged(tripState: MoveTripState) {
-    val data = Arguments.createMap()
-    data.putString(ARGUMENT_STATE, tripState.toString())
+    val data = mutableMapOf<Any, Any>()
+    data[ARGUMENT_STATE] = tripState.toString().toSnakeCase()
     emitDeviceEvent(EVENT_TRIP_STATE, data)
   }
 
@@ -266,8 +317,8 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     productId: Int
   ) {
     val auth = MoveAuth(
-      productId = productId.toLong(),
-      contractId = contractId,
+      projectId = productId.toLong(),
+      userId = contractId,
       accessToken = accessToken,
       refreshToken = refreshToken,
     )
@@ -275,8 +326,8 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
     configRepository.storeAuth(auth)
 
     MoveSdk.get()?.updateAuth(auth) { configurationError ->
-      val data = Arguments.createMap()
-      data.putString(ARGUMENT_ERROR, configurationError.toString())
+      val data = mutableMapOf<Any, Any>()
+      data[ARGUMENT_ERROR] = configurationError.toString()
       emitDeviceEvent(EVENT_INIT_ERROR, data)
     }
   }
@@ -288,20 +339,69 @@ class NativeMoveSdkWrapper(private val context: Context) : MoveSdk.StateListener
   }
 
   override fun onAuthStateUpdate(state: MoveAuthState) {
-    val data = Arguments.createMap()
-    data.putString(ARGUMENT_STATE, state.toString())
+    val data = mutableMapOf<Any, Any>()
+    data[ARGUMENT_STATE] = state.toString().toSnakeCase()
+    /**
+     * No need to store anything any more
     if (state is MoveAuthState.VALID) {
-      data.putString(ARGUMENT_ACCESS_TOKEN, state.auth.accessToken)
-      data.putString(ARGUMENT_REFRESH_TOKEN, state.auth.refreshToken)
+    data.putString(ARGUMENT_ACCESS_TOKEN, state.auth.accessToken)
+    data.putString(ARGUMENT_REFRESH_TOKEN, state.auth.refreshToken)
 
-      // Only store valid auth here
-      configRepository.storeAuth(state.auth)
-    }
+    // Only store valid auth here
+    configRepository.storeAuth(state.auth)
+    }**/
 
     emitDeviceEvent(EVENT_AUTH_STATE, data)
   }
 
-  private fun emitDeviceEvent(eventName: String, eventData: WritableMap?) {
+  private fun emitDeviceEvent(eventName: String, eventData: Map<Any, Any>) {
+    delegate?.emitDeviceEvent(eventName, eventData)
+  }
+
+  private fun emitDeviceEvent(eventName: String, eventData: Array<Any>) {
     delegate?.emitDeviceEvent(eventName, eventData)
   }
+
+  override fun onLogReceived(eventName: String, value: String?) {
+    // TBD
+    val data = mutableMapOf<Any, Any>()
+    data[ARGUMENT_LOG] = "$eventName ${value ?: ""}".trim()
+    emitDeviceEvent(EVENT_INIT_ERROR, data)
+  }
+
+  override fun onMoveError(serviceFailures: List<MoveServiceFailure>) {
+    val data = mutableMapOf<Any, Any>()
+    data[ARGUMENT_ERRORS] = serviceFailures.failuresToArray()
+    emitDeviceEvent(EVENT_ERRORS, data)
+  }
+
+  override fun onMoveWarning(serviceWarnings: List<MoveServiceWarning>) {
+    val data = mutableMapOf<Any, Any>()
+    data[ARGUMENT_WARNINGS] = serviceWarnings.warningsToArray()
+    emitDeviceEvent(EVENT_WARNINGS, data)
+  }
+}
+
+fun List<MoveServiceFailure>.failuresToArray(): Array<Any> {
+  val data = mutableListOf<Any>()
+  forEach {
+    val map = mutableMapOf<String, Any>()
+    map["service"] = it.service.name().toSnakeCase()
+    map["reasons"] =
+      it.reasons.map { reason -> reason.name.toSnakeCase() }
+    data.add(map)
+  }
+  return data.toTypedArray()
+}
+
+fun List<MoveServiceWarning>.warningsToArray(): Array<Any> {
+  val data = mutableListOf<Any>()
+  forEach {
+    val map = mutableMapOf<String, Any?>()
+    map["service"] = it.service?.name()?.toSnakeCase()
+    map["reasons"] =
+      it.warnings.map { reason -> reason.name.toSnakeCase() }
+    data.add(map)
+  }
+  return data.toTypedArray()
 }

package/android/src/test/java/io/dolphin/move/MoveWrapperTest.kt

@@ -0,0 +1,157 @@
+package io.dolphin.move
+
+import `in`.dolph.move.sdk.EVENT_AUTH_BATTERY_PERMISSION
+import `in`.dolph.move.sdk.EVENT_AUTH_OVERLAY_PERMISSION
+import `in`.dolph.move.sdk.MoveSdkModule
+import `in`.dolph.move.sdk.NativeMoveSdkWrapper
+import `in`.dolph.move.sdk.failuresToArray
+import `in`.dolph.move.sdk.toSnakeCase
+import android.content.Context
+import android.content.SharedPreferences
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.nhaarman.mockitokotlin2.any
+import com.nhaarman.mockitokotlin2.mock
+import com.nhaarman.mockitokotlin2.times
+import com.nhaarman.mockitokotlin2.verify
+import com.nhaarman.mockitokotlin2.whenever
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import org.junit.After
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Ignore
+import org.junit.Test
+
+@ExperimentalCoroutinesApi
+class MoveWrapperTest {
+
+  @Before
+  fun setup(): Unit {
+    Unit
+  }
+
+  @After
+  fun teardown(): Unit {
+  }
+
+  @Test
+  fun `test sdk state snake case`(): Unit {
+
+    Assert.assertEquals("READY", MoveSdkState.Ready.name.toSnakeCase())
+    Assert.assertEquals("RUNNING", MoveSdkState.Running.name.toSnakeCase())
+    Assert.assertEquals("UNINITIALISED", MoveSdkState.Uninitialised.name.toSnakeCase())
+  }
+
+  @Test
+  fun `test trip state snake case`(): Unit {
+
+    Assert.assertEquals("UNKNOWN", MoveTripState.UNKNOWN.name)
+    Assert.assertEquals("UNKNOWN", MoveTripState.UNKNOWN.name.toSnakeCase())
+    Assert.assertEquals("DRIVING", MoveTripState.DRIVING.name)
+    Assert.assertEquals("IDLE", MoveTripState.IDLE.name)
+    Assert.assertEquals("IGNORED", MoveTripState.IGNORED.name)
+    Assert.assertEquals("HALT", MoveTripState.HALT.name)
+  }
+
+  @Test
+  fun `test errors`(): Unit {
+
+    val errors: List<MoveServiceFailure> = mutableListOf(
+      MoveServiceFailure(
+        service = MoveDetectionService.Driving(),
+        reasons = listOf(MoveError.PhonePermissionMissing, MoveError.LocationPermissionMissing)
+      )
+    )
+    val failuresToArray = errors.failuresToArray()
+    failuresToArray.toString()
+  }
+
+  @Test
+  fun `test device event naming`(): Unit {
+
+    Assert.assertEquals("MOVE_SDK_PERMISSION_OVERLAY", EVENT_AUTH_OVERLAY_PERMISSION.toSnakeCase())
+    Assert.assertEquals(
+      "MOVE_SDK_PERMISSION_BATTERY_OPTIMIZATION",
+      EVENT_AUTH_BATTERY_PERMISSION.toSnakeCase()
+    )
+  }
+
+  @Ignore("Writeable* classes cannot be tested")
+  @Test
+  fun `test device events`(): Unit {
+
+    val context: Context = mock()
+    val promise: Promise = mock()
+    val sharedPrefs: SharedPreferences = mock()
+
+    val reactContext: ReactApplicationContext = mock()
+    whenever(context.getSharedPreferences(any(), any())).thenReturn(sharedPrefs)
+    whenever(reactContext.applicationContext).thenReturn(context)
+
+    val deviceEventModule: DeviceEventManagerModule.RCTDeviceEventEmitter = mock()
+    val targetClass = DeviceEventManagerModule.RCTDeviceEventEmitter::class.java
+    whenever(reactContext.getJSModule(targetClass)).thenReturn(
+      deviceEventModule
+    )
+
+    val moveSdkModule = MoveSdkModule(reactContext)
+    moveSdkModule.emitDeviceEvent("Move-SdkEvent", emptyArray())
+  }
+
+  @Test
+  fun `test reject assistance call`(): Unit {
+
+    val context: Context = mock()
+    val promise: Promise = mock()
+    val sharedPrefs: SharedPreferences = mock()
+
+    whenever(context.getSharedPreferences(any(), any())).thenReturn(sharedPrefs)
+    whenever(context.applicationContext).thenReturn(context)
+
+    val nativeMoveSdkWrapper = NativeMoveSdkWrapper(context)
+    nativeMoveSdkWrapper.initiateAssistanceCall(promise)
+    verify(promise, times(1)).reject(any<Throwable>())
+  }
+
+  @Test
+  fun `test auth state snake case`(): Unit {
+
+    Assert.assertEquals("UNKNOWN", MoveAuthState.UNKNOWN.name)
+    Assert.assertEquals(
+      "EXPIRED",
+      MoveAuthState.EXPIRED(
+        MoveAuth(
+          projectId = 1,
+          userId = "",
+          accessToken = "",
+          refreshToken = ""
+        )
+      ).name
+    )
+  }
+
+  @Test
+  fun `test snake to camel`(): Unit {
+
+    Assert.assertEquals("READY", MoveSdkState.Ready.name.toSnakeCase())
+    Assert.assertEquals("RUNNING", MoveSdkState.Running.name.toSnakeCase())
+    Assert.assertEquals("UNINITIALISED", MoveSdkState.Uninitialised.name.toSnakeCase())
+  }
+
+  @Test
+  fun `test error to snake`(): Unit {
+    Assert.assertEquals(
+      "PHONE_PERMISSION_MISSING",
+      MoveError.PhonePermissionMissing.name.toSnakeCase()
+    )
+  }
+
+  @Test
+  fun `test warning to snake`(): Unit {
+    Assert.assertEquals(
+      "ACTIVITY_PERMISSION_MISSING",
+      MoveWarning.ActivityPermissionMissing.name.toSnakeCase()
+    )
+  }
+}

package/ios/MoveSdk-Bridging-Header.h

@@ -1,2 +1,3 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTViewManager.h>
+#import <React/RCTBundleURLProvider.h>

package/ios/MoveSdk.xcodeproj/project.pbxproj

@@ -7,7 +7,7 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
-		09A2803B25DA82E000603CBF /* DolphinSdk.swift in Sources */ = {isa = PBXBuildFile; fileRef = 09A2803A25DA82E000603CBF /* DolphinSdk.swift */; };
+		ABD6EADC2906D6FE00BAC83D /* MoveSdk.swift in Sources */ = {isa = PBXBuildFile; fileRef = ABD6EADB2906D6FE00BAC83D /* MoveSdk.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -23,10 +23,9 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
-		09A2803825DA82E000603CBF /* DolphinSdk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DolphinSdk.h; sourceTree = "<group>"; };
-		09A2803925DA82E000603CBF /* DolphinSdkDemoReactNative-Bridging-Header.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "DolphinSdkDemoReactNative-Bridging-Header.h"; sourceTree = "<group>"; };
-		09A2803A25DA82E000603CBF /* DolphinSdk.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DolphinSdk.swift; sourceTree = "<group>"; };
 		134814201AA4EA6300B7C361 /* libMoveSdk.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libMoveSdk.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		ABD6EADA2906D6FE00BAC83D /* MoveSdk.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MoveSdk.h; sourceTree = "<group>"; };
+		ABD6EADB2906D6FE00BAC83D /* MoveSdk.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MoveSdk.swift; sourceTree = "<group>"; };
 		F4FF95D5245B92E700C19C63 /* MoveSdk-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "MoveSdk-Bridging-Header.h"; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
@@ -44,9 +43,8 @@
 		09A2803725DA82E000603CBF /* NativeModule */ = {
 			isa = PBXGroup;
 			children = (
-				09A2803825DA82E000603CBF /* DolphinSdk.h */,
-				09A2803925DA82E000603CBF /* DolphinSdkDemoReactNative-Bridging-Header.h */,
-				09A2803A25DA82E000603CBF /* DolphinSdk.swift */,
+				ABD6EADA2906D6FE00BAC83D /* MoveSdk.h */,
+				ABD6EADB2906D6FE00BAC83D /* MoveSdk.swift */,
 			);
 			path = NativeModule;
 			sourceTree = "<group>";
@@ -125,7 +123,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				09A2803B25DA82E000603CBF /* DolphinSdk.swift in Sources */,
+				ABD6EADC2906D6FE00BAC83D /* MoveSdk.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

package/ios/NativeModule/{DolphinSdk.h → MoveSdk.h}

@@ -5,30 +5,38 @@
 
 @interface DolphinSdkInternal: RCTEventEmitter
 +(void)initIfPossibleWithLaunchOptions:(NSDictionary *) launchOptions;
++(void)performBackgroundFetch: (void (^)(UIBackgroundFetchResult))completionHandler;
 -(void)sendAppEvent:(NSString *) eventInfo;
 @end
 
 
-@interface RCT_EXTERN_MODULE(DolphinSdk, DolphinSdkInternal)
+@interface RCT_EXTERN_MODULE(RCTMoveSdk, DolphinSdkInternal)
 
-RCT_EXTERN_METHOD(initialize: (NSString *)contractId
+RCT_EXTERN_METHOD(setup: (NSString *)contractId
                   accessToken: (NSString *)accessToken
                   refreshToken: (NSString *)refreshToken
                   productId: (NSInteger *)productId
-                  timelineDetectionServices: (NSArray<NSString> *)timelineDetectionServices
+				  timelineDetectionServices: (NSArray<NSString> *)timelineDetectionServices
                   drivingServices: (NSArray<NSString> *)drivingServices
                   walkingServices: (NSArray<NSString> *)walkingServices
-                  otherServices: (NSArray<NSString> *)otherServices
                   resolve: (RCTPromiseResolveBlock)resolve
-                  reject: (RCTPromiseRejectBlock)reject
-                  )
+                  reject: (RCTPromiseRejectBlock)reject)
 				  
 RCT_EXTERN_METHOD(getState: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 				  
 RCT_EXTERN_METHOD(getTripState: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
-				  
+
+RCT_EXTERN_METHOD(getWarnings: (RCTPromiseResolveBlock)resolve
+				  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getErrors: (RCTPromiseResolveBlock)resolve
+				  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(initiateAssistanceCall: (RCTPromiseResolveBlock)resolve
+				  rejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(startAutomaticDetection)
 
 RCT_EXTERN_METHOD(stopAutomaticDetection)
@@ -54,6 +62,12 @@ RCT_EXTERN_METHOD(updateAuth: (NSString *)contractId
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(geocode: (double)latitude: (double)longitude
+				  resolver: (RCTPromiseResolveBlock)resolve
+				  rejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(resolveError)
 
+RCT_EXTERN_METHOD(requestMotionPermission)
+
 @end