react-native-radar 3.20.4 → 3.21.0-beta.2

package/android/src/oldarch/java/com/radar/RadarModule.java

@@ -0,0 +1,416 @@
+package com.radar;
+import android.Manifest;
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.ActivityCompat;
+
+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.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
+import io.radar.sdk.Radar;
+import io.radar.sdk.RadarTrackingOptions;
+import io.radar.sdk.RadarTrackingOptions.RadarTrackingOptionsForegroundService;
+import io.radar.sdk.RadarTripOptions;
+import io.radar.sdk.RadarVerifiedReceiver;
+import io.radar.sdk.model.RadarAddress;
+import io.radar.sdk.model.RadarContext;
+import io.radar.sdk.model.RadarEvent;
+import io.radar.sdk.model.RadarGeofence;
+import io.radar.sdk.model.RadarPlace;
+import io.radar.sdk.model.RadarRouteMatrix;
+import io.radar.sdk.model.RadarRoutes;
+import io.radar.sdk.model.RadarTrip;
+import io.radar.sdk.model.RadarUser;
+import io.radar.sdk.model.RadarVerifiedLocationToken;
+import io.radar.sdk.RadarNotificationOptions;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.EnumSet;
+import java.util.Map;
+
+public class RadarModule extends ReactContextBaseJavaModule implements PermissionListener {
+
+    public static final String NAME = "RNRadar";
+    private static final String TAG = "RadarModule";
+    private static final int PERMISSIONS_REQUEST_CODE = 20160525; // random request code (Radar's birthday!)
+    private Promise mPermissionsRequestPromise;
+
+    private RadarOldArchReceiver receiver;
+    private RadarOldArchVerifiedReceiver verifiedReceiver;    
+    private int listenerCount = 0;
+    private boolean fraud = false;
+    private RadarModuleImpl radarModuleImpl;
+
+    public RadarModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        receiver = new RadarOldArchReceiver();
+        verifiedReceiver = new RadarOldArchVerifiedReceiver();
+        radarModuleImpl = new RadarModuleImpl();
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        if (listenerCount == 0) {
+            if (fraud) {
+                verifiedReceiver.hasListeners = true;
+            }
+            receiver.hasListeners = true;
+        }
+
+        listenerCount += 1;
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        listenerCount -= count;
+        if (listenerCount == 0) {
+            if (fraud) {
+                verifiedReceiver.hasListeners = false;
+            }
+            receiver.hasListeners = false;
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "RNRadar";
+    }
+
+    @ReactMethod
+    public void initialize(String publishableKey, boolean fraud) {
+        this.fraud = fraud;
+        SharedPreferences.Editor editor = getReactApplicationContext().getSharedPreferences("RadarSDK", Context.MODE_PRIVATE).edit();
+        editor.putString("x_platform_sdk_type", "ReactNative");
+        editor.putString("x_platform_sdk_version", "3.21.0-beta.2");
+        editor.apply();
+        if (fraud) {
+            Radar.initialize(getReactApplicationContext(), publishableKey, receiver, Radar.RadarLocationServicesProvider.GOOGLE, fraud);
+            Radar.setVerifiedReceiver(verifiedReceiver);
+        } else {
+            Radar.initialize(getReactApplicationContext(), publishableKey);
+            Radar.setReceiver(receiver);
+        }
+    }
+
+    @ReactMethod
+    public void setLogLevel(String level) {
+        radarModuleImpl.setLogLevel(level);
+    }
+
+    @ReactMethod
+    public void setUserId(String userId) {
+        radarModuleImpl.setUserId(userId);
+    }
+
+    @ReactMethod
+    public void getUserId(final Promise promise) {
+        radarModuleImpl.getUserId(promise);
+    }
+
+    @ReactMethod
+    public void setDescription(String description) {
+        radarModuleImpl.setDescription(description);
+    }
+
+    @ReactMethod
+    public void getDescription(final Promise promise) {
+        radarModuleImpl.getDescription(promise);
+    }
+
+    @ReactMethod
+    public void nativeSdkVersion(final Promise promise) {
+        radarModuleImpl.nativeSdkVersion(promise);
+    }
+
+    @ReactMethod
+    public void setMetadata(ReadableMap metadataMap) throws JSONException {
+        radarModuleImpl.setMetadata(metadataMap);
+    }
+
+    @ReactMethod
+    public void getMetadata(final Promise promise) throws JSONException {        
+        radarModuleImpl.getMetadata(promise);
+    }
+
+    @ReactMethod
+    public void setAnonymousTrackingEnabled(boolean enabled) {
+        radarModuleImpl.setAnonymousTrackingEnabled(enabled);
+    }
+
+    @ReactMethod
+    public void getPermissionsStatus(final Promise promise) {
+        if (promise == null) {
+            return;
+        }
+
+        Activity activity = getCurrentActivity();
+
+        if (activity == null) {
+            promise.resolve("UNKNOWN");
+
+            return;
+        }
+
+        boolean foreground = ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED || 
+                             ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        boolean background = foreground;
+        boolean denied = ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_FINE_LOCATION);
+        
+        if (Build.VERSION.SDK_INT >= 29) {
+            background = ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        }
+
+        if (background) {
+            promise.resolve("GRANTED_BACKGROUND");
+        } else if (foreground) {
+            promise.resolve("GRANTED_FOREGROUND");
+        } else if (denied) {
+            promise.resolve("DENIED");
+        } else {
+            promise.resolve("NOT_DETERMINED");
+        }
+    }
+
+    @Override
+    public boolean onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        if (requestCode == PERMISSIONS_REQUEST_CODE && mPermissionsRequestPromise != null) {
+            getPermissionsStatus(mPermissionsRequestPromise);
+            mPermissionsRequestPromise = null;
+        }
+        return true;
+    }
+
+
+    @ReactMethod
+    public void requestPermissions(boolean background, final Promise promise) {
+        PermissionAwareActivity activity = (PermissionAwareActivity)getCurrentActivity();
+        mPermissionsRequestPromise = promise;
+        if (activity != null) {
+            if (Build.VERSION.SDK_INT >= 23) {
+                if (background && Build.VERSION.SDK_INT >= 29) {
+                    activity.requestPermissions(new String[] { Manifest.permission.ACCESS_BACKGROUND_LOCATION }, PERMISSIONS_REQUEST_CODE, this);
+                } else {
+                    activity.requestPermissions(new String[] { Manifest.permission.ACCESS_FINE_LOCATION }, PERMISSIONS_REQUEST_CODE, this);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    public void getLocation(String desiredAccuracy, final Promise promise) {
+        radarModuleImpl.getLocation(desiredAccuracy, promise);
+    }
+
+    @ReactMethod
+    public void trackOnce(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.trackOnce(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void trackVerified(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.trackVerified(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void isTrackingVerified(final Promise promise) {
+        radarModuleImpl.isTrackingVerified(promise);
+    }
+
+    @ReactMethod
+    public void setProduct(String product) {
+        radarModuleImpl.setProduct(product);
+    }
+
+    @ReactMethod
+    public void getVerifiedLocationToken(final Promise promise) {
+        radarModuleImpl.getVerifiedLocationToken(promise);
+    }
+
+    @ReactMethod
+    public void clearVerifiedLocationToken() {
+        radarModuleImpl.clearVerifiedLocationToken();
+    }
+
+    @ReactMethod
+    public void startTrackingEfficient() {
+        radarModuleImpl.startTrackingEfficient();
+    }
+
+    @ReactMethod
+    public void startTrackingResponsive() {
+        radarModuleImpl.startTrackingResponsive();
+    }
+
+    @ReactMethod
+    public void startTrackingContinuous() {
+        radarModuleImpl.startTrackingContinuous();
+    }
+
+    @ReactMethod
+    public void startTrackingCustom(ReadableMap optionsMap) {
+        radarModuleImpl.startTrackingCustom(optionsMap);
+    }
+
+    @ReactMethod
+    public void startTrackingVerified(ReadableMap optionsMap) {
+        radarModuleImpl.startTrackingVerified(optionsMap);
+    }
+
+    @ReactMethod
+    public void mockTracking(ReadableMap optionsMap) {
+        radarModuleImpl.mockTracking(optionsMap);
+    }
+
+    @ReactMethod
+    public void stopTracking() {
+        radarModuleImpl.stopTracking();
+    }
+
+    @ReactMethod
+    public void stopTrackingVerified() {
+        radarModuleImpl.stopTrackingVerified();
+    }
+
+    @ReactMethod
+    public void isTracking(final Promise promise) {
+        radarModuleImpl.isTracking(promise);
+    }
+
+    @ReactMethod
+    public void getTrackingOptions(final Promise promise) {
+        radarModuleImpl.getTrackingOptions(promise);
+    }
+
+    @ReactMethod
+    public void isUsingRemoteTrackingOptions(final Promise promise) {
+        radarModuleImpl.isUsingRemoteTrackingOptions(promise);
+    }
+
+    @ReactMethod
+    public void setForegroundServiceOptions(ReadableMap optionsMap) {
+        radarModuleImpl.setForegroundServiceOptions(optionsMap);
+    }
+
+    @ReactMethod
+    public void setNotificationOptions(ReadableMap optionsMap) {
+        radarModuleImpl.setNotificationOptions(optionsMap);
+    }
+
+    @ReactMethod
+    public void acceptEvent(String eventId, String verifiedPlaceId) {
+            Radar.acceptEvent(eventId, verifiedPlaceId);
+    }
+
+    @ReactMethod
+    public void rejectEvent(String eventId) {
+            Radar.rejectEvent(eventId);
+    }
+
+    @ReactMethod
+    public void getTripOptions(final Promise promise) {
+        radarModuleImpl.getTripOptions(promise);
+    }
+
+    @ReactMethod
+    public void startTrip(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.startTrip(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void completeTrip(final Promise promise) {
+        radarModuleImpl.completeTrip(promise);
+    }
+
+    @ReactMethod
+    public void cancelTrip(final Promise promise) {
+        radarModuleImpl.cancelTrip(promise);
+    }
+
+    @ReactMethod
+    public void updateTrip(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.updateTrip(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void getContext(@Nullable ReadableMap locationMap, final Promise promise) {
+        radarModuleImpl.getContext(locationMap, promise);
+    }
+
+    @ReactMethod
+    public void searchPlaces(ReadableMap optionsMap, final Promise promise) {
+       radarModuleImpl.searchPlaces(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void searchGeofences(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.searchGeofences(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void autocomplete(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.autocomplete(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void geocode(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.geocode(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void reverseGeocode(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.reverseGeocode(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void ipGeocode(final Promise promise) {
+        radarModuleImpl.ipGeocode(promise);
+    }
+
+    @ReactMethod
+    public void validateAddress(ReadableMap addressMap, final Promise promise) {
+        radarModuleImpl.validateAddress(addressMap, promise);
+    }
+
+    @ReactMethod
+    public void getDistance(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.getDistance(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void getMatrix(ReadableMap optionsMap, final Promise promise) {
+        radarModuleImpl.getMatrix(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void logConversion(ReadableMap optionsMap, final Promise promise) throws JSONException  {
+        radarModuleImpl.logConversion(optionsMap, promise);
+    }
+
+    @ReactMethod
+    public void getHost(final Promise promise) {
+        radarModuleImpl.getHost(promise);
+    }
+
+    @ReactMethod
+    public void getPublishableKey(final Promise promise) {
+        radarModuleImpl.getPublishableKey(promise);
+    }
+    
+}

package/android/src/{main/java/io/radar/react/RNRadarReceiver.java → oldarch/java/com/radar/RadarOldArchReceiver.java}

@@ -1,4 +1,4 @@
-package io.radar.react;
+package com.radar;
 
 import android.content.Context;
 import android.location.Location;
@@ -22,10 +22,10 @@ import io.radar.sdk.model.RadarEvent;
 import io.radar.sdk.model.RadarUser;
 import java.util.concurrent.atomic.AtomicInteger;
 
-public class RNRadarReceiver extends RadarReceiver {
+public class RadarOldArchReceiver extends RadarReceiver {
 
     private ReactNativeHost reactNativeHost;
-    private static final String TAG = "RNRadarReceiver";
+    private static final String TAG = "RadarOldArchReceiver";
     protected boolean hasListeners = false;
 
     private void sendEvent(final String eventName, final Object data) {
@@ -43,9 +43,9 @@ public class RNRadarReceiver extends RadarReceiver {
             reactNativeHost = reactApplication.getReactNativeHost();
 
             WritableMap map = Arguments.createMap();
-            map.putArray("events", RNRadarUtils.arrayForJson(RadarEvent.toJson(events)));
+            map.putArray("events", RadarUtils.arrayForJson(RadarEvent.toJson(events)));
             if (user != null) {
-                map.putMap("user", RNRadarUtils.mapForJson(user.toJson()));
+                map.putMap("user", RadarUtils.mapForJson(user.toJson()));
             }
 
             sendEvent("events", map);
@@ -61,8 +61,8 @@ public class RNRadarReceiver extends RadarReceiver {
             reactNativeHost = reactApplication.getReactNativeHost();
 
             WritableMap map = Arguments.createMap();
-            map.putMap("location", RNRadarUtils.mapForJson(Radar.jsonForLocation(location)));
-            map.putMap("user", RNRadarUtils.mapForJson(user.toJson()));
+            map.putMap("location", RadarUtils.mapForJson(Radar.jsonForLocation(location)));
+            map.putMap("user", RadarUtils.mapForJson(user.toJson()));
 
             sendEvent("location", map);
         } catch (Exception e) {
@@ -77,7 +77,7 @@ public class RNRadarReceiver extends RadarReceiver {
             reactNativeHost = reactApplication.getReactNativeHost();
 
             WritableMap map = Arguments.createMap();
-            map.putMap("location", RNRadarUtils.mapForJson(Radar.jsonForLocation(location)));
+            map.putMap("location", RadarUtils.mapForJson(Radar.jsonForLocation(location)));
             map.putBoolean("stopped", stopped);
             map.putString("source", source.toString());
 

package/android/src/{main/java/io/radar/react/RNRadarVerifiedReceiver.java → oldarch/java/com/radar/RadarOldArchVerifiedReceiver.java}

@@ -1,4 +1,4 @@
-package io.radar.react;
+package com.radar;
 
 import android.content.Context;
 import android.util.Log;
@@ -18,10 +18,10 @@ import io.radar.sdk.Radar;
 import io.radar.sdk.RadarVerifiedReceiver;
 import io.radar.sdk.model.RadarVerifiedLocationToken;
 
-public class RNRadarVerifiedReceiver extends RadarVerifiedReceiver {
+public class RadarOldArchVerifiedReceiver extends RadarVerifiedReceiver {
 
     private ReactNativeHost reactNativeHost;
-    private static final String TAG = "RNRadarVerifiedReceiver";
+    private static final String TAG = "RadarOldArchVerifiedReceiver";
     protected boolean hasListeners = false;
 
     private void sendEvent(final String eventName, final Object data) {
@@ -38,7 +38,7 @@ public class RNRadarVerifiedReceiver extends RadarVerifiedReceiver {
             ReactApplication reactApplication = ((ReactApplication)context.getApplicationContext());
             reactNativeHost = reactApplication.getReactNativeHost();
 
-            sendEvent("token", RNRadarUtils.mapForJson(token.toJson()));
+            sendEvent("token", RadarUtils.mapForJson(token.toJson()));
         } catch (Exception e) {
             Log.e(TAG, "Exception", e);
         }

package/app.plugin.js

@@ -1 +1 @@
-module.exports = require('./plugin/build');
+module.exports = require('./plugin/build/withRadar');

package/dist/@types/RadarNativeInterface.d.ts

@@ -1,4 +1,4 @@
-import { Location, RadarAddress, RadarAddressCallback, RadarAutocompleteOptions, RadarContextCallback, RadarEventChannel, RadarGeocodeOptions, RadarGetDistanceOptions, RadarGetMatrixOptions, RadarIPGeocodeCallback, RadarListenerCallback, RadarLocationCallback, RadarLogConversionCallback, RadarLogConversionOptions, RadarLogLevel, RadarMetadata, RadarMockTrackingOptions, RadarNotificationOptions, RadarPermissionsStatus, RadarReverseGeocodeOptions, RadarRouteCallback, RadarRouteMatrix, RadarSearchGeofencesCallback, RadarSearchGeofencesOptions, RadarSearchPlacesCallback, RadarSearchPlacesOptions, RadarStartTripOptions, RadarTrackCallback, RadarTrackingOptions, RadarTrackingOptionsDesiredAccuracy, RadarTrackingOptionsForegroundService, RadarTrackOnceOptions, RadarTrackVerifiedCallback, RadarTrackVerifiedOptions, RadarTripCallback, RadarTripOptions, RadarUpdateTripOptions, RadarValidateAddressCallback, RadarVerifiedTrackingOptions } from "./types";
+import type { RadarPermissionsStatus, RadarTrackCallback, RadarTrackOnceOptions, RadarLocationUpdateCallback, RadarClientLocationUpdateCallback, RadarErrorCallback, RadarLogUpdateCallback, RadarEventUpdateCallback, RadarTokenUpdateCallback, RadarLogLevel, RadarMetadata, RadarTrackingOptionsDesiredAccuracy, RadarLocationCallback, RadarTrackVerifiedCallback, RadarTrackVerifiedOptions, RadarTrackingOptions, RadarVerifiedTrackingOptions, RadarMockTrackingOptions, RadarTrackingOptionsForegroundService, RadarNotificationOptions, RadarTripOptions, RadarStartTripOptions, RadarTripCallback, RadarUpdateTripOptions, RadarContextCallback, RadarSearchPlacesOptions, RadarSearchPlacesCallback, RadarSearchGeofencesCallback, RadarSearchGeofencesOptions, RadarAutocompleteOptions, RadarAddressCallback, RadarReverseGeocodeOptions, RadarGeocodeOptions, RadarValidateAddressCallback, RadarIPGeocodeCallback, RadarAddress, RadarLogConversionOptions, RadarGetDistanceOptions, RadarRouteCallback, RadarGetMatrixOptions, RadarLogConversionCallback, RadarRouteMatrix } from "./types";
 export interface RadarNativeInterface {
     initialize: (publishableKey: string, fraud?: boolean) => void;
     setLogLevel: (level: RadarLogLevel) => void;
@@ -8,13 +8,11 @@ export interface RadarNativeInterface {
     getDescription: () => Promise<string>;
     setMetadata: (metadata: RadarMetadata) => void;
     getMetadata: () => Promise<RadarMetadata>;
-    setProduct(product: string): void;
-    getProduct: () => Promise<string>;
     setAnonymousTrackingEnabled: (enabled: boolean) => void;
     getPermissionsStatus: () => Promise<RadarPermissionsStatus>;
     requestPermissions: (background: boolean) => Promise<RadarPermissionsStatus>;
     getLocation: (desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy) => Promise<RadarLocationCallback>;
-    trackOnce: (options?: RadarTrackOnceOptions | Location) => Promise<RadarTrackCallback>;
+    trackOnce: (options?: RadarTrackOnceOptions) => Promise<RadarTrackCallback>;
     trackVerified: (options?: RadarTrackVerifiedOptions) => Promise<RadarTrackVerifiedCallback>;
     getVerifiedLocationToken: () => Promise<RadarTrackVerifiedCallback>;
     clearVerifiedLocationToken: () => void;
@@ -24,6 +22,7 @@ export interface RadarNativeInterface {
     startTrackingCustom: (options: RadarTrackingOptions) => void;
     startTrackingVerified: (options?: RadarVerifiedTrackingOptions) => void;
     isTrackingVerified: () => Promise<boolean>;
+    setProduct(product: string): void;
     mockTracking: (options: RadarMockTrackingOptions) => void;
     stopTracking: () => void;
     stopTrackingVerified: () => void;
@@ -50,9 +49,20 @@ export interface RadarNativeInterface {
     getDistance: (option: RadarGetDistanceOptions) => Promise<RadarRouteCallback>;
     getMatrix: (option: RadarGetMatrixOptions) => Promise<RadarRouteMatrix>;
     logConversion: (options: RadarLogConversionOptions) => Promise<RadarLogConversionCallback>;
-    sendEvent: (name: string, metadata: RadarMetadata) => void;
-    on: (channel: RadarEventChannel, callback: RadarListenerCallback) => void;
-    off: (channel: RadarEventChannel, callback?: Function | undefined) => void;
     nativeSdkVersion: () => Promise<string>;
     rnSdkVersion: () => string;
+    onLocationUpdate: (callback: RadarLocationUpdateCallback) => void;
+    clearLocationUpdate: () => void;
+    onClientLocationUpdate: (callback: RadarClientLocationUpdateCallback) => void;
+    clearClientLocationUpdate: () => void;
+    onError: (callback: RadarErrorCallback) => void;
+    clearError: () => void;
+    onLog: (callback: RadarLogUpdateCallback) => void;
+    clearLog: () => void;
+    onEventUpdate: (callback: RadarEventUpdateCallback) => void;
+    clearEventUpdate: () => void;
+    onTokenUpdate: (callback: RadarTokenUpdateCallback) => void;
+    clearTokenUpdate: () => void;
+    getHost: () => Promise<string>;
+    getPublishableKey: () => Promise<string>;
 }

package/dist/@types/types.d.ts

@@ -7,8 +7,6 @@ export interface RadarTrackOnceOptions {
 export interface RadarTrackVerifiedOptions {
     beacons?: boolean;
     desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy;
-    reason?: string;
-    transactionId?: string;
 }
 /**
  * Options for tracking the user's location.
@@ -248,7 +246,10 @@ export interface RadarErrorCallback {
 export interface RadarLogUpdateCallback {
     (status: string): void;
 }
-export type RadarListenerCallback = RadarEventUpdateCallback | RadarLocationUpdateCallback | RadarClientLocationUpdateCallback | RadarErrorCallback | RadarLogUpdateCallback;
+export interface RadarTokenUpdateCallback {
+    (token: Object): void;
+}
+export type RadarListenerCallback = RadarEventUpdateCallback | RadarLocationUpdateCallback | RadarClientLocationUpdateCallback | RadarErrorCallback | RadarLogUpdateCallback | RadarTokenUpdateCallback;
 export type RadarPermissionsStatus = "GRANTED_FOREGROUND" | "GRANTED_BACKGROUND" | "DENIED" | "NOT_DETERMINED" | "UNKNOWN";
 export type RadarLocationSource = "FOREGROUND_LOCATION" | "BACKGROUND_LOCATION" | "MANUAL_LOCATION" | "VISIT_ARRIVAL" | "VISIT_DEPARTURE" | "GEOFENCE_ENTER" | "GEOFENCE_DWELL" | "GEOFENCE_EXIT" | "MOCK_LOCATION" | "BEACON_ENTER" | "BEACON_EXIT" | "UNKNOWN";
 export type RadarEventChannel = "clientLocation" | "location" | "error" | "events" | "log" | "token";

package/dist/NativeRadar.d.ts

@@ -0,0 +1,86 @@
+import type { TurboModule } from 'react-native';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+export type LocationEmitter = {
+    location: Object;
+    user: Object;
+};
+export type ClientLocationEmitter = {
+    location: Object;
+    stopped: boolean;
+    source: string;
+};
+export type ErrorEmitter = {
+    status: string;
+};
+export type LogEmitter = {
+    message: string;
+};
+export type EventsEmitter = {
+    events: Array<Object>;
+    user: Object;
+};
+export type TokenEmitter = {
+    token: Object;
+};
+export interface Spec extends TurboModule {
+    initialize(publishableKey: string, fraud: boolean): void;
+    requestPermissions(background: boolean): Promise<string>;
+    getPermissionsStatus(): Promise<string>;
+    trackOnce(trackOnceOptions: Object | null): Promise<Object>;
+    setLogLevel(level: string): void;
+    setUserId(userId: string): void;
+    getUserId(): Promise<string>;
+    setDescription(description: string): void;
+    getDescription(): Promise<string>;
+    setMetadata(metadata: Object): void;
+    getMetadata(): Promise<Object>;
+    setAnonymousTrackingEnabled(enabled: boolean): void;
+    getLocation(desiredAccuracy: string | null): Promise<Object>;
+    trackVerified(trackVerifiedOptions: Object | null): Promise<Object>;
+    getVerifiedLocationToken(): Promise<Object>;
+    clearVerifiedLocationToken(): void;
+    startTrackingEfficient(): void;
+    startTrackingResponsive(): void;
+    startTrackingContinuous(): void;
+    startTrackingCustom(options: Object): void;
+    startTrackingVerified(options: Object | null): void;
+    isTrackingVerified(): Promise<boolean>;
+    setProduct(product: string): void;
+    mockTracking(options: Object): void;
+    stopTracking(): void;
+    stopTrackingVerified(): void;
+    getTrackingOptions(): Promise<Object>;
+    isUsingRemoteTrackingOptions(): Promise<boolean>;
+    isTracking(): Promise<boolean>;
+    setForegroundServiceOptions(options: Object): void;
+    setNotificationOptions(options: Object): void;
+    getTripOptions(): Promise<Object>;
+    startTrip(options: Object): Promise<Object>;
+    completeTrip(): Promise<Object>;
+    cancelTrip(): Promise<Object>;
+    updateTrip(options: Object): Promise<Object>;
+    acceptEvent(eventId: string, verifiedPlaceId: string): void;
+    rejectEvent(eventId: string): void;
+    getContext(location: Object): Promise<Object>;
+    searchPlaces(options: Object): Promise<Object>;
+    searchGeofences(options: Object): Promise<Object>;
+    autocomplete(options: Object): Promise<Object>;
+    geocode(options: Object): Promise<Object>;
+    reverseGeocode(options: Object): Promise<Object>;
+    ipGeocode(): Promise<Object>;
+    validateAddress(address: Object): Promise<Object>;
+    getDistance(options: Object): Promise<Object>;
+    getMatrix(options: Object): Promise<Object>;
+    logConversion(options: Object): Promise<Object>;
+    nativeSdkVersion(): Promise<string>;
+    getHost(): Promise<string>;
+    getPublishableKey(): Promise<string>;
+    readonly locationEmitter: EventEmitter<LocationEmitter>;
+    readonly clientLocationEmitter: EventEmitter<ClientLocationEmitter>;
+    readonly errorEmitter: EventEmitter<ErrorEmitter>;
+    readonly logEmitter: EventEmitter<LogEmitter>;
+    readonly eventsEmitter: EventEmitter<EventsEmitter>;
+    readonly tokenEmitter: EventEmitter<TokenEmitter>;
+}
+declare const _default: Spec;
+export default _default;

package/dist/NativeRadar.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.getEnforcing('RNRadar');

package/dist/helpers.d.ts

@@ -1,2 +1,2 @@
-export function getHost(): any;
-export function getPublishableKey(): any;
+export function getHost(): Promise<string>;
+export function getPublishableKey(): Promise<string>;