hypertrack-sdk-react-native 10.0.3-psl19.1 → 11.0.0

package/CHANGELOG.md

@@ -3,6 +3,54 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [11.0.0] - 2023-09-08
+
+### Added
+
+- `locate()` to ask for one-time user location
+- `subscribeToLocation()` to subscribe to user location updates
+- `getErrors()`
+- `getName()`
+- `getMetadata()`
+- HyperTrackError types:
+  - `noExemptionFromBackgroundStartRestrictions`
+  - `permissionsNotificationsDenied`
+
+### Changed
+
+- Updated HyperTrack Android SDK to 7.0.1
+- Add Android SDK plugins (`location-services-google-19-0-1` and `push-service-firebase`)
+- Updated HyperTrack iOS SDK to 5.0.1
+- The whole HyperTrack API is now static
+- Changed the way to provide publishableKey (you need to add `HyperTrackPublishableKey` `meta-data` item to your `AndroidManifest.xml`)
+- Renamed HyperTrackError types:
+  - `gpsSignalLost` to `locationSignalLost`
+  - `locationPermissionsDenied` to `permissionsLocationDenied`
+  - `locationPermissionsInsufficientForBackground` to `permissionsLocationInsufficientForBackground`
+  - `locationPermissionsNotDetermined` to `permissionsLocationNotDetermined`
+  - `locationPermissionsProvisional` to `locationPermissionsProvisional`
+  - `locationPermissionsReducedAccuracy` to `permissionsLocationReducedAccuracy`
+  - `locationPermissionsRestricted` to `permissionsLocationRestricted`
+- Renamed `isAvailable()` to `getIsAvailable()`
+- Renamed `isTracking()` to `getIsTracking()`
+- Renamed `setAvailability()` to `setIsAvailable(boolean)`
+- Changed `startTracking()` and `stopTracking()` to `setIsTracking(boolean)`
+- Renamed `subscribeToTracking()` to `subscribeToIsTracking()`
+- Renamed `subscribeToAvailability()` to `subscribeToIsAvailable()`
+
+### Removed
+
+- `initialize()` method (the API is now static)
+- `SdkInitParams` (the config now should be done with the `AndroidManifest` metadata and `Info.plist`)
+- Motion Activity permissions are not required for tracking anymore
+- HyperTrackError types:
+  - `motionActivityPermissionsDenied`
+  - `motionActivityServicesDisabled`
+  - `motionActivityServicesUnavailable`
+  - `motionActivityPermissionsRestricted`
+  - `networkConnectionUnavailable`
+- `sync()` method
+
 ## [10.0.3] - 2023-08-04
 
 ### Fixed

package/CONTRIBUTING.md

@@ -11,7 +11,7 @@
        - HyperTrackSdk_HyperTrackSDKVersion
    - ios
      - [hypertrack-sdk-react-native.podspec](hypertrack-sdk-react-native.podspec)
-       - s.dependency 'HyperTrack/Objective-C', '**version**'
+       - s.dependency 'HyperTrack', '**version**'
 
 2. Increment wrapper version
 

package/README.md

@@ -2,8 +2,8 @@
 
 ![GitHub](https://img.shields.io/github/license/hypertrack/sdk-react-native.svg)
 ![npm](https://img.shields.io/npm/v/hypertrack-sdk-react-native.svg)
-![iOS SDK](https://img.shields.io/badge/iOS%20SDK-4.16.1-brightgreen.svg)
-![Android SDK](https://img.shields.io/badge/Android%20SDK-6.4.2-brightgreen.svg)
+![iOS SDK](https://img.shields.io/badge/iOS%20SDK-5.0.1-brightgreen.svg)
+![Android SDK](https://img.shields.io/badge/Android%20SDK-7.0.1-brightgreen.svg)
 
 [HyperTrack](https://www.hypertrack.com) lets you add live location tracking to your mobile app. Live location is made available along with ongoing activity, tracking controls and tracking outage with reasons.
 

package/android/build.gradle

@@ -144,8 +144,12 @@ def hyperTrackSdk_version = getExtOrDefault('HyperTrackSDKVersion')
 dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"
+
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    implementation "com.hypertrack:hypertrack:$hyperTrackSdk_version"
+
+    implementation "com.hypertrack:sdk-android:$hyperTrackSdk_version"
+    implementation "com.hypertrack:location-services-google-19-0-1:$hyperTrackSdk_version"
+    implementation "com.hypertrack:push-service-firebase:$hyperTrackSdk_version"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -2,5 +2,5 @@ HyperTrackSdk_kotlinVersion=1.6.21
 HyperTrackSdk_minSdkVersion=23
 HyperTrackSdk_targetSdkVersion=30
 HyperTrackSdk_compileSdkVersion=31
-HyperTrackSdk_HyperTrackSDKVersion=6.4.2-psl19.1
+HyperTrackSdk_HyperTrackSDKVersion=7.0.1
 android.useAndroidX=true

package/android/src/main/java/com/reactnativehypertracksdk/HyperTrackReactNativePlugin.kt

@@ -4,120 +4,67 @@ import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.hypertrack.sdk.*
-import com.hypertrack.sdk.AvailabilityStateObserver.OnAvailabilityStateChangeListener
-import com.hypertrack.sdk.TrackingStateObserver.OnTrackingStateChangeListener
+import com.hypertrack.sdk.android.HyperTrack
 import com.reactnativehypertracksdk.common.*
+import com.reactnativehypertracksdk.common.Serialization.serializeErrors
 import com.reactnativehypertracksdk.common.Serialization.serializeIsAvailable
 import com.reactnativehypertracksdk.common.Serialization.serializeIsTracking
+import com.reactnativehypertracksdk.common.Serialization.serializeLocateResult
+import com.reactnativehypertracksdk.common.Serialization.serializeLocation
+import com.reactnativehypertracksdk.common.Serialization.serializeLocationResult
 
-@Suppress("ComplexRedundantLet")
 @ReactModule(name = HyperTrackReactNativePlugin.NAME)
 class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
     ReactContextBaseJavaModule(reactContext) {
 
-    var trackingStateListener: OnTrackingStateChangeListener? = null
-    var availabilityListener: OnAvailabilityStateChangeListener? = null
+    private var locateSubscription: HyperTrack.Cancellable? = null
 
     override fun getName(): String {
         return NAME
     }
 
+    /**
+     * ReactNative built-in methods
+     */
+
     @ReactMethod
-    fun addListener(type: String?) {
-        when (type) {
-            EVENT_TRACKING -> {
-                HyperTrackSdkWrapper.isTracking().let {
-                    when (it) {
-                        is Success -> {
-                            emitIsTracking(it.success)
-                        }
-                        is Failure -> {
-                            throw Exception("isTracking failed: ${it.failure}", it.failure)
-                        }
-                    }
-                }
+    fun addListener(eventName: String?) {
+        // called when RN app subscribes to an event
+        when (eventName) {
+            EVENT_ERRORS -> {
+                emitEvent(EVENT_ERRORS, serializeErrors(HyperTrack.errors).toWriteableArray())
             }
-            EVENT_AVAILABILITY -> {
-                HyperTrackSdkWrapper.isAvailable().let {
-                    when (it) {
-                        is Success -> {
-                            emitIsAvailable(it.success)
-                        }
-                        is Failure -> {
-                            throw Exception("isAvailable failed: ${it.failure}", it.failure)
-                        }
-                    }
-                }
+            EVENT_IS_AVAILABLE -> {
+                emitEvent(EVENT_IS_AVAILABLE, serializeIsAvailable(HyperTrack.isAvailable).toWritableMap())
             }
-            EVENT_ERRORS -> {
-                HyperTrackSdkWrapper.getInitialErrors().let {
-                    emitErrors(it)
-                }
+            EVENT_IS_TRACKING -> {
+                emitEvent(EVENT_IS_TRACKING, serializeIsTracking(HyperTrack.isTracking).toWritableMap())
+            }
+            EVENT_LOCATION -> {
+                emitEvent(EVENT_LOCATION, serializeLocationResult(HyperTrack.location).toWritableMap())
             }
             else -> Unit
         }
         // Keep: Required for RN built in Event Emitter Calls.
     }
 
-    @ReactMethod
-    fun removeListeners(type: Int?) {
-        // Keep: Required for RN built in Event Emitter Calls.
+    override fun initialize() {
+        super.initialize()
+        initListeners()
     }
 
     @ReactMethod
-    fun initializeSdk(
-        initParams: ReadableMap,
-        promise: Promise
-    ) {
-        HyperTrackSdkWrapper
-            .initializeSdk(initParams.toHashMap())
-            .mapSuccess { sdk ->
-                initListeners(sdk)
-            }
-            .toPromise(promise)
+    fun removeListeners(type: Int?) {
+        // Keep: Required for RN built in Event Emitter Calls.
     }
 
-    private fun initListeners(sdkInstance: HyperTrack) {
-        if (trackingStateListener != null) {
-            sdkInstance.removeTrackingListener(trackingStateListener)
-            trackingStateListener = null
-        }
-        trackingStateListener = object : OnTrackingStateChangeListener {
-            override fun onError(trackingError: TrackingError) {
-                emitErrors(HyperTrackSdkWrapper.getErrors(trackingError))
-            }
-
-            override fun onTrackingStart() {
-                emitIsTracking(serializeIsTracking(true))
-            }
-
-            override fun onTrackingStop() {
-                emitIsTracking(serializeIsTracking(false))
-            }
-        }.also {
-            sdkInstance.addTrackingListener(it)
-        }
+    /**
+     * SDK methods
+     */
 
-        if (availabilityListener != null) {
-            sdkInstance.removeAvailabilityListener(availabilityListener)
-            availabilityListener = null
-        }
-        availabilityListener =
-            object : AvailabilityStateObserver.OnAvailabilityStateChangeListener {
-                override fun onError(p0: AvailabilityError) {
-                    // ignored, errors are handled by trackingStateListener
-                }
-
-                override fun onAvailable() {
-                    emitIsAvailable(serializeIsAvailable(true))
-                }
-
-                override fun onUnavailable() {
-                    emitIsAvailable(serializeIsAvailable(false))
-                }
-            }.also {
-                sdkInstance.addAvailabilityListener(it)
-            }
+    @ReactMethod
+    fun addGeotag(args: ReadableMap, promise: Promise) {
+        HyperTrackSdkWrapper.addGeotag(args.toHashMap()).toPromise(promise)
     }
 
     @ReactMethod
@@ -126,43 +73,52 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
     }
 
     @ReactMethod
-    fun isTracking(promise: Promise) {
-        HyperTrackSdkWrapper.isTracking().toPromise(promise)
+    fun getErrors(promise: Promise) {
+        HyperTrackSdkWrapper.getErrors().toPromise(promise)
     }
 
     @ReactMethod
-    fun startTracking() {
-        HyperTrackSdkWrapper.startTracking()
+    fun getIsAvailable(promise: Promise) {
+        HyperTrackSdkWrapper.getIsAvailable().toPromise(promise)
     }
 
     @ReactMethod
-    fun stopTracking() {
-        HyperTrackSdkWrapper.stopTracking()
+    fun getIsTracking(promise: Promise) {
+        HyperTrackSdkWrapper.getIsTracking().toPromise(promise)
     }
 
     @ReactMethod
-    fun sync() {
-        HyperTrackSdkWrapper.sync()
+    fun getLocation(promise: Promise) {
+        HyperTrackSdkWrapper.getLocation().toPromise(promise)
     }
 
     @ReactMethod
-    fun addGeotag(args: ReadableMap, promise: Promise) {
-        HyperTrackSdkWrapper.addGeotag(args.toHashMap()).toPromise(promise)
+    fun getMetadata(promise: Promise) {
+        HyperTrackSdkWrapper.getMetadata().toPromise(promise)
     }
 
     @ReactMethod
-    fun isAvailable(promise: Promise) {
-        HyperTrackSdkWrapper.isAvailable().toPromise(promise)
+    fun getName(promise: Promise) {
+        HyperTrackSdkWrapper.getName().toPromise(promise)
     }
 
     @ReactMethod
-    fun setAvailability(args: ReadableMap) {
-        HyperTrackSdkWrapper.setAvailability(args.toHashMap())
+    fun locate(promise: Promise) {
+        locateSubscription?.cancel()
+        locateSubscription = HyperTrack.locate {
+            emitEvent(EVENT_LOCATE, serializeLocateResult(it).toWritableMap())
+        }
+        Success(Unit).toPromise(promise)
     }
 
     @ReactMethod
-    fun setName(args: ReadableMap) {
-        HyperTrackSdkWrapper.setName(args.toHashMap())
+    fun setIsAvailable(args: ReadableMap) {
+        HyperTrackSdkWrapper.setIsAvailable(args.toHashMap())
+    }
+
+    @ReactMethod
+    fun setIsTracking(args: ReadableMap) {
+        HyperTrackSdkWrapper.setIsTracking(args.toHashMap())
     }
 
     @ReactMethod
@@ -171,20 +127,26 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
     }
 
     @ReactMethod
-    fun getLocation(promise: Promise) {
-        HyperTrackSdkWrapper.getLocation().toPromise(promise)
+    fun setName(args: ReadableMap) {
+        HyperTrackSdkWrapper.setName(args.toHashMap())
     }
 
-    private fun emitIsTracking(isTracking: Map<String, Any?>) {
-        emitEvent(EVENT_TRACKING, isTracking.toWritableMap())
-    }
+    private fun initListeners() {
+        HyperTrack.subscribeToErrors {
+            emitEvent(EVENT_ERRORS, serializeErrors(it).toWriteableArray())
+        }
 
-    private fun emitIsAvailable(isAvailable: Map<String, Any?>) {
-        emitEvent(EVENT_AVAILABILITY, isAvailable.toWritableMap())
-    }
+        HyperTrack.subscribeToIsAvailable {
+            emitEvent(EVENT_IS_AVAILABLE, serializeIsAvailable(it).toWritableMap())
+        }
 
-    private fun emitErrors(errors: List<Map<String, Any?>>) {
-        emitEvent(EVENT_ERRORS, errors.toWriteableArray())
+        HyperTrack.subscribeToIsTracking {
+            emitEvent(EVENT_IS_TRACKING, serializeIsTracking(it).toWritableMap())
+        }
+
+        HyperTrack.subscribeToLocation {
+            emitEvent(EVENT_LOCATION, serializeLocationResult(it).toWritableMap())
+        }
     }
 
     private fun emitEvent(event: String, data: WritableMap) {
@@ -193,6 +155,7 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
             .emit(event, data)
     }
 
+    @Suppress("SameParameterValue")
     private fun emitEvent(event: String, data: WritableArray) {
         reactApplicationContext
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
@@ -200,9 +163,11 @@ class HyperTrackReactNativePlugin(reactContext: ReactApplicationContext?) :
     }
 
     companion object {
-        private const val EVENT_TRACKING = "onTrackingChanged"
-        private const val EVENT_AVAILABILITY = "onAvailabilityChanged"
-        private const val EVENT_ERRORS = "onError"
+        private const val EVENT_ERRORS = "errors"
+        private const val EVENT_IS_AVAILABLE = "isAvailable"
+        private const val EVENT_IS_TRACKING = "isTracking"
+        private const val EVENT_LOCATE = "locate"
+        private const val EVENT_LOCATION = "location"
 
         const val NAME = "HyperTrackReactNativePlugin"
     }

package/android/src/main/java/com/reactnativehypertracksdk/ReactNativeSerialization.kt

@@ -5,26 +5,33 @@ import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.reactnativehypertracksdk.common.Failure
-import com.reactnativehypertracksdk.common.Result
+import com.reactnativehypertracksdk.common.WrapperResult
 import com.reactnativehypertracksdk.common.Success
 
 @Suppress("UNCHECKED_CAST")
-internal fun <T> Result<T>.toPromise(promise: Promise) {
+internal fun <T> WrapperResult<T>.toPromise(promise: Promise) {
     when (this) {
         is Success -> {
             when (this.success) {
                 is Map<*, *> -> {
                     promise.resolve((this.success as Map<String, Any>).toWritableMap())
                 }
+
+                is List<*> -> {
+                    promise.resolve((this.success as List<Any>).toWriteableArray())
+                }
+
                 is Unit -> {
                     promise.resolve(null)
                 }
+
                 else -> {
                     // using nested exception to correctly display error in RN logs
                     promise.reject(Exception(IllegalArgumentException(this.success.toString())))
                 }
             }
         }
+
         is Failure -> {
             /**
              * ReactNative NativeBridge converts the Exception to JS Error
@@ -42,7 +49,7 @@ internal fun <T> Result<T>.toPromise(promise: Promise) {
              *
              *   Default ReactNative logger skips the Exception class name in logs, so we build a
              *   custom Exception to include the class name in the message.
-             *   
+             *
              *   Default Exception.toString() will print both the class name and the message
              */
             val exception = Exception(this.failure.toString())
@@ -60,9 +67,11 @@ internal fun List<Any>.toWriteableArray(): WritableArray {
                 is String -> {
                     writableArray.pushString(it)
                 }
+
                 is Map<*, *> -> {
                     writableArray.pushMap((it as Map<String, Any>).toWritableMap())
                 }
+
                 else -> {
                     throw Exception(IllegalArgumentException(it.javaClass.toString()))
                 }
@@ -81,24 +90,35 @@ internal fun Map<String, Any?>.toWritableMap(): WritableMap {
                 is String -> {
                     putString(key, value)
                 }
+
                 is Int -> {
                     putInt(key, value)
                 }
+
                 is Double -> {
                     putDouble(key, value)
                 }
+                
+                is Float -> {
+                    putDouble(key, value.toDouble())
+                }
+
                 is Boolean -> {
                     putBoolean(key, value)
                 }
+
                 is List<*> -> {
                     putArray(key, (value as List<String>).toWriteableArray())
                 }
+
                 is Map<*, *> -> {
                     putMap(key, (value as Map<String, Any>).toWritableMap())
                 }
+
                 null -> {
                     putNull(key)
                 }
+
                 else -> {
                     throw Exception(IllegalArgumentException(entry.value?.javaClass.toString()))
                 }