hypertrack-sdk-react-native 7.19.1 → 8.0.0

package/android/gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

package/android/src/main/AndroidManifest.xml

@@ -1,5 +1,4 @@
-
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.hypertrack.reactnative.androidsdk">
-	<application />
+          package="com.reactnativehypertracksdk">
+
 </manifest>

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

@@ -0,0 +1,284 @@
+package com.hypertrack.reactnative.androidsdk
+
+import android.location.Location
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.hypertrack.sdk.*
+import com.hypertrack.sdk.TrackingStateObserver.OnTrackingStateChangeListener
+import java.util.*
+
+@ReactModule(name = HTSDKModule.NAME)
+class HTSDKModule(reactContext: ReactApplicationContext?) :
+  ReactContextBaseJavaModule(reactContext) {
+  var trackingStateChangeListener: OnTrackingStateChangeListener? = null
+  var sdkInstance: HyperTrack? = null
+  override fun getName(): String {
+    return NAME
+  }
+
+  @ReactMethod
+  fun addListener(type: String?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  fun removeListeners(type: Int?) {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  @ReactMethod
+  fun initialize(
+    publishableKey: String?,
+    startsTracking: Boolean,
+    automaticallyRequestPermissions: Boolean?,
+    promise: Promise
+  ) {
+    try {
+      sdkInstance = HyperTrack.getInstance(
+        publishableKey!!
+      ).backgroundTrackingRequirement(false)
+      subscribeToTracking()
+      if (startsTracking) {
+        sdkInstance!!.start()
+      }
+      promise.resolve(true)
+    } catch (exception: Exception) {
+      Log.e(TAG, "Hypertrack SDK initialization failed.", exception)
+      val error = String.format(Locale.ENGLISH, "%d", RN_ERROR_INVALID_PUBLISHABLE_KEY)
+      promise.reject(error, Exception("Hypertrack SDK initialization failed."))
+    }
+  }
+
+  fun subscribeToTracking() {
+    if (trackingStateChangeListener != null) {
+      sdkInstance!!.removeTrackingListener(trackingStateChangeListener)
+      trackingStateChangeListener = null
+    }
+    trackingStateChangeListener = object : OnTrackingStateChangeListener {
+      override fun onError(trackingError: TrackingError) {
+
+        val params = Arguments.createMap()
+        params.putInt("code", convertToRNErrorsCode(trackingError.code))
+        params.putString("message", trackingError.message)
+        reactApplicationContext
+          .getJSModule(RCTDeviceEventEmitter::class.java)
+          .emit("onTrackingErrorHyperTrack", params)
+      }
+
+      override fun onTrackingStart() {
+        reactApplicationContext
+          .getJSModule(RCTDeviceEventEmitter::class.java)
+          .emit("onTrackingStateChanged", sdkInstance!!.isTracking)
+      }
+
+      override fun onTrackingStop() {
+        reactApplicationContext
+          .getJSModule(RCTDeviceEventEmitter::class.java)
+          .emit("onTrackingStateChanged", sdkInstance!!.isTracking)
+      }
+    }
+    sdkInstance!!.addTrackingListener(trackingStateChangeListener)
+  }
+
+  @ReactMethod
+  fun getDeviceID(promise: Promise) {
+    promise.resolve(sdkInstance!!.deviceID)
+  }
+
+  @ReactMethod
+  fun isTracking(promise: Promise) {
+    promise.resolve(sdkInstance!!.isTracking)
+  }
+
+  @ReactMethod
+  fun startTracking() {
+    sdkInstance!!.start()
+  }
+
+  @ReactMethod
+  fun stopTracking() {
+    sdkInstance!!.stop()
+  }
+
+  @ReactMethod
+  fun syncDeviceSettings() {
+    sdkInstance!!.syncDeviceSettings()
+  }
+
+  @ReactMethod
+  fun addGeotag(rMap: ReadableMap, promise: Promise) {
+    try {
+      sdkInstance!!.addGeotag(rMap.toHashMap())
+      promise.resolve(locationResultToMap(sdkInstance!!.latestLocation))
+    } catch (e: Exception) {
+      val error = String.format(Locale.ENGLISH, "%d", RN_ERROR_GENERAL)
+      promise.reject(error, e)
+    }
+  }
+
+  @ReactMethod
+  fun isAvailable(promise: Promise) {
+    promise.resolve(sdkInstance!!.availability.equals(Availability.AVAILABLE))
+  }
+
+
+  @ReactMethod
+  fun setAvailability(availability: Boolean, promise: Promise) {
+    if (availability) {
+      sdkInstance!!.availability = Availability.AVAILABLE
+    } else {
+      sdkInstance!!.availability = Availability.UNAVAILABLE
+    }
+    promise.resolve(sdkInstance!!.availability.equals(Availability.AVAILABLE))
+  }
+
+//  @ReactMethod
+//  fun addGeotag(rMap: ReadableMap, expectedLocation: ReadableMap, promise: Promise) {
+//    try {
+//      val expected = expectedLocationFromMap(expectedLocation)
+//      val result = sdkInstance!!.addGeotag(rMap.toHashMap(), expected)
+//      if (result is GeotagResult.Success) {
+//        val deviceLocation = result.deviceLocation
+//        val map = Arguments.createMap()
+//        map.putDouble("latitude", deviceLocation.latitude)
+//        map.putDouble("longitude", deviceLocation.longitude)
+//        promise.resolve(map)
+//      } else {
+//        val error = String.format(Locale.ENGLISH, "%d", RN_ERROR_GENERAL)
+//        promise.reject(error)
+//      }
+//    } catch (e: Exception) {
+//      val error = String.format(Locale.ENGLISH, "%d", RN_ERROR_GENERAL)
+//      promise.reject(error, e)
+//    }
+//  }
+
+  private fun expectedLocationFromMap(expectedLocation: ReadableMap): Location? {
+    return if (!expectedLocation.hasKey(LATITUDE) || !expectedLocation.hasKey(LONGITUDE)) null else try {
+      val latitude = expectedLocation.getDouble(LATITUDE)
+      val longitude = expectedLocation.getDouble(LONGITUDE)
+      if (longitude > 180.0 || longitude < -180.0) return null
+      if (latitude > 90.0 || latitude < -90.0) return null
+      val expected = Location("any")
+      expected.latitude = latitude
+      expected.longitude = longitude
+      expected
+    } catch (ignored: Throwable) {
+      null
+    }
+  }
+
+  private fun fail(error: Int, promise: Promise) {
+    val map = Arguments.createMap()
+    map.putInt("code", error)
+    promise.resolve(map)
+  }
+
+  @ReactMethod
+  fun setDeviceName(name: String?, promise: Promise) {
+    try {
+      sdkInstance!!.setDeviceName(name)
+      promise.resolve(true)
+    } catch (e: Exception) {
+      val error = String.format(Locale.ENGLISH, "%d", RN_ERROR_GENERAL)
+      promise.reject(error, e)
+    }
+  }
+
+  @ReactMethod
+  fun setMetadata(rMap: ReadableMap, promise: Promise) {
+    try {
+      sdkInstance!!.setDeviceMetadata(rMap.toHashMap())
+      promise.resolve(true)
+    } catch (e: Exception) {
+      val error = String.format(Locale.ENGLISH, "%d", RN_ERROR_GENERAL)
+      promise.reject(error, e)
+    }
+  }
+
+  @ReactMethod
+  fun enableDebugLogging(enable: Boolean) {
+    if (enable) {
+      HyperTrack.enableDebugLogging()
+    }
+  }
+
+  @ReactMethod
+  fun enableMockLocation(enable: Boolean) {
+    if (enable) {
+      sdkInstance!!.allowMockLocations()
+    }
+  }
+
+  @ReactMethod
+  fun getLocation(promise: Promise) {
+    promise.resolve(locationResultToMap(sdkInstance!!.latestLocation))
+  }
+
+  @ReactMethod
+  fun getCurrentLocation(promise: Promise) {
+    sdkInstance!!.getCurrentLocation { result -> promise.resolve(locationResultToMap(result)) }
+  }
+
+  private fun locationResultToMap(result: Result<Location, OutageReason>): WritableMap {
+    val resultMap = Arguments.createMap()
+    if (result.isSuccess) {
+      val location = result.value
+      val locationMap = Arguments.createMap()
+      locationMap.putDouble(LATITUDE, location.latitude)
+      locationMap.putDouble(LONGITUDE, location.longitude)
+      resultMap.putMap(KEY_LOCATION, locationMap)
+    } else {
+      val outage = result.error
+      val errorMap = Arguments.createMap()
+      errorMap.putString(KEY_OUTAGE_CODE, getOutageName(outage))
+      resultMap.putMap(KEY_ERROR, errorMap)
+    }
+    return resultMap
+  }
+
+  private fun getOutageName(outageReason: OutageReason): String {
+    return when (outageReason) {
+      OutageReason.MISSING_LOCATION_PERMISSION -> OUTAGE_CODE_LOCATION_PERMISSIONS_DENIED
+      OutageReason.MISSING_ACTIVITY_PERMISSION -> OUTAGE_CODE_MOTION_ACTIVITY_PERMISSIONS_DENIED
+      OutageReason.LOCATION_SERVICE_DISABLED -> OUTAGE_CODE_LOCATION_SERVICES_DISABLED
+      OutageReason.NOT_TRACKING -> OUTAGE_CODE_NOT_RUNNING
+      OutageReason.START_HAS_NOT_FINISHED -> OUTAGE_CODE_STARTING
+      OutageReason.NO_GPS_SIGNAL, OutageReason.RESTART_REQUIRED -> OUTAGE_CODE_GPS_SIGNAL_LOST
+      else -> OUTAGE_CODE_GPS_SIGNAL_LOST
+    }
+  }
+
+  private fun convertToRNErrorsCode(androidSdkCode: Int): Int {
+    return when (androidSdkCode) {
+      TrackingError.INVALID_PUBLISHABLE_KEY_ERROR -> RN_ERROR_INVALID_PUBLISHABLE_KEY
+      TrackingError.AUTHORIZATION_ERROR -> RN_ERROR_AUTHORIZATION_FAILED
+      TrackingError.PERMISSION_DENIED_ERROR -> RN_ERROR_PERMISSION_DENIED
+      else -> RN_ERROR_GENERAL
+    }
+  }
+
+  companion object {
+    private const val TAG = "HTSDKModule"
+    private const val KEY_LOCATION = "location"
+    private const val KEY_ERROR = "error"
+    private const val KEY_OUTAGE_CODE = "code"
+    const val NAME = "HyperTrack"
+    const val LATITUDE = "latitude"
+    const val LONGITUDE = "longitude"
+    const val ACCURACY = "accuracy"
+    private const val OUTAGE_CODE_LOCATION_PERMISSIONS_DENIED = "location_permissions_denied"
+    private const val OUTAGE_CODE_LOCATION_SERVICES_DISABLED = "location_services_disabled"
+    private const val OUTAGE_CODE_MOTION_ACTIVITY_PERMISSIONS_DENIED =
+      "motion_activity_permissions_denied"
+    private const val OUTAGE_CODE_NOT_RUNNING = "not_running"
+    private const val OUTAGE_CODE_GPS_SIGNAL_LOST = "gps_signal_lost"
+    private const val OUTAGE_CODE_STARTING = "starting"
+    private const val RN_ERROR_GENERAL = 0
+    private const val RN_ERROR_INVALID_PUBLISHABLE_KEY = 1
+    private const val RN_ERROR_AUTHORIZATION_FAILED = 2
+    private const val RN_ERROR_PERMISSION_DENIED = 3
+  }
+}

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

@@ -0,0 +1,17 @@
+package com.reactnativehypertracksdk
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.hypertrack.reactnative.androidsdk.HTSDKModule
+
+
+class HyperTrackSdkPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(HTSDKModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/hypertrack-sdk-react-native.podspec

@@ -1,18 +1,37 @@
-require 'json'
-package = JSON.parse(File.read(File.join(__dir__, './', 'package.json')))
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_version = '2021.06.28.00-v2'
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 
 Pod::Spec.new do |s|
-  s.name              = package['name']
-  s.version           = package['version']
-  s.summary           = package['description']
-  s.requires_arc      = true
-  s.author            = "HyperTrack Inc."
-  s.license           = package['license']
-  s.homepage          = package['homepage']
-  s.source            = { :git => 'https://github.com/hypertrack/sdk-react-native.git' }
-  s.platform          = :ios, '11.0'
-  s.dependency        'React-Core'
-  s.dependency        'HyperTrack/Objective-C', '4.12.4'
-  s.source_files      = "ios/*.{xcodeproj}", "ios/RNHyperTrack/*.{h,m}"
-  s.cocoapods_version = '>= 1.10.0'
+  s.name         = "hypertrack-sdk-react-native"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "10.0" }
+  s.source       = { :git => "https://github.com/hypertrack/sdk-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  s.dependency "React-Core"
+  s.dependency 'HyperTrack/Objective-C', '4.12.4'
+
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly", folly_version
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+  end
 end

package/ios/{RNHyperTrack/RNHyperTrack.h → HyperTrack.h}

@@ -1,8 +1,7 @@
 #import <React/RCTEventEmitter.h>
 #import <React/RCTBridgeModule.h>
-
 @import HyperTrack;
 
 @interface HyperTrack : RCTEventEmitter <RCTBridgeModule>
-  
+
 @end