react-native-radar 3.5.5 → 3.5.7

package/android/build.gradle

@@ -18,7 +18,7 @@ android {
         minSdkVersion 16
         targetSdkVersion 31
         versionCode 1
-        versionName '3.5.5'
+        versionName '3.5.7'
     }
     lintOptions {
         abortOnError false

package/android/src/main/java/io/radar/react/RNRadarModule.java

@@ -39,6 +39,7 @@ import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.util.EnumSet;
+import java.util.Map;
 
 public class RNRadarModule extends ReactContextBaseJavaModule implements PermissionListener {
 
@@ -78,16 +79,54 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
         Radar.setUserId(userId);
     }
 
+    @ReactMethod
+    public void getUserId(final Promise promise) {
+        if (promise == null) {
+            return;
+        }
+
+        promise.resolve(Radar.getUserId());
+    }
+
     @ReactMethod
     public void setDescription(String description) {
         Radar.setDescription(description);
     }
 
+    @ReactMethod
+    public void getDescription(final Promise promise) {
+        if (promise == null) {
+            return;
+        }
+
+        promise.resolve(Radar.getDescription());
+    }
+
     @ReactMethod
     public void setMetadata(ReadableMap metadataMap) throws JSONException {
         Radar.setMetadata(RNRadarUtils.jsonForMap(metadataMap));
     }
 
+    @ReactMethod
+    public void getMetadata(final Promise promise) throws JSONException {        
+        if (promise == null) {
+            return;
+        }
+
+        JSONObject metaJson =  Radar.getMetadata();        
+        promise.resolve(RNRadarUtils.mapForJson(metaJson));
+    }
+
+    @ReactMethod
+    public void setAnonymousTrackingEnabled(boolean enabled) {
+        Radar.setAnonymousTrackingEnabled(enabled);
+    }
+
+    @ReactMethod
+    public void setAdIdEnabled(boolean enabled) {
+        Radar.setAdIdEnabled(enabled);
+    }
+
     @ReactMethod
     public void getPermissionsStatus(final Promise promise) {
         if (promise == null) {
@@ -146,8 +185,22 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
     }
 
     @ReactMethod
-    public void getLocation(final Promise promise) {
-        Radar.getLocation(new Radar.RadarLocationCallback() {
+    public void getLocation(String desiredAccuracy, final Promise promise) {
+        
+        RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.MEDIUM;        
+        String accuracy = desiredAccuracy != null ? desiredAccuracy.toLowerCase()  : "medium";
+        
+        if (accuracy.equals("low")) {
+            accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.LOW;
+        } else if (accuracy.equals("medium")) {
+            accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.MEDIUM;
+        } else if (accuracy.equals("high")) {
+            accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.HIGH;
+        } else {
+            promise.reject(Radar.RadarStatus.ERROR_BAD_REQUEST.toString(), Radar.RadarStatus.ERROR_BAD_REQUEST.toString());
+        }
+
+        Radar.getLocation(accuracyLevel, new Radar.RadarLocationCallback() {
             @Override
             public void onComplete(@NonNull Radar.RadarStatus status, @Nullable Location location, boolean stopped) {
                 if (promise == null) {
@@ -312,6 +365,29 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
         Radar.stopTracking();
     }
 
+    @ReactMethod
+    public void isTracking(final Promise promise) {
+        if (promise == null) {
+            return;
+        }
+
+        promise.resolve(Radar.isTracking());
+    }
+
+    @ReactMethod
+    public void getTrackingOptions(final Promise promise) {
+        if (promise == null) {
+            return;
+        }
+        try {
+            RadarTrackingOptions options = Radar.getTrackingOptions();
+            promise.resolve(RNRadarUtils.mapForJson(options.toJson()));
+        } catch(JSONException e) {
+            Log.e(TAG, "JSONException", e);
+            promise.reject(Radar.RadarStatus.ERROR_SERVER.toString(), Radar.RadarStatus.ERROR_SERVER.toString());
+        }
+    }
+
     @ReactMethod
     public void setForegroundServiceOptions(ReadableMap optionsMap) {
         try {
@@ -333,6 +409,20 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
         Radar.rejectEvent(eventId);
     }
 
+    @ReactMethod
+    public void getTripOptions(final Promise promise) {
+        if (promise == null) {
+            return;
+        }
+        try {
+            RadarTripOptions options = Radar.getTripOptions();
+            promise.resolve(options != null ? RNRadarUtils.mapForJson(options.toJson()) : null);
+        } catch(JSONException e) {
+            Log.e(TAG, "JSONException", e);
+            promise.reject(Radar.RadarStatus.ERROR_SERVER.toString(), Radar.RadarStatus.ERROR_SERVER.toString());
+        }
+    }
+
     @ReactMethod
     public void startTrip(ReadableMap optionsMap, final Promise promise) {
         try {
@@ -578,6 +668,7 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
         }
         int radius = optionsMap.hasKey("radius") ? optionsMap.getInt("radius") : 1000;
         String[] chains = optionsMap.hasKey("chains") ? RNRadarUtils.stringArrayForArray(optionsMap.getArray("chains")) : null;
+        Map<String, String> chainMetadata = RNRadarUtils.stringStringMap(optionsMap.getMap("chainMetadata"));
         String[] categories = optionsMap.hasKey("categories") ? RNRadarUtils.stringArrayForArray(optionsMap.getArray("categories")) : null;
         String[] groups = optionsMap.hasKey("groups") ? RNRadarUtils.stringArrayForArray(optionsMap.getArray("groups")) : null;
         int limit = optionsMap.hasKey("limit") ? optionsMap.getInt("limit") : 10;
@@ -607,9 +698,9 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
         };
 
         if (near != null) {
-            Radar.searchPlaces(near, radius, chains, categories, groups, limit, callback);
+            Radar.searchPlaces(near, radius, chains, chainMetadata, categories, groups, limit, callback);
         } else {
-            Radar.searchPlaces(radius, chains, categories, groups, limit, callback);
+            Radar.searchPlaces(radius, chains, chainMetadata, categories, groups, limit, callback);
         }
     }
 
@@ -984,4 +1075,39 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
         });
     }
 
+    @ReactMethod
+    public void sendEvent(String customType, ReadableMap metadata, final Promise promise) throws JSONException  {
+        if (promise == null) {
+            return;
+        }
+        
+        JSONObject metadataObj = RNRadarUtils.jsonForMap(metadata);
+        Radar.sendEvent(customType, metadataObj, new Radar.RadarSendEventCallback() {
+            @Override
+            public void onComplete(@NonNull Radar.RadarStatus status, @Nullable Location location, @Nullable RadarEvent[] events, @Nullable RadarUser user) {
+                try {
+                    if (status == Radar.RadarStatus.SUCCESS) {
+                        WritableMap map = Arguments.createMap();
+                        map.putString("status", status.toString());
+                        if (location != null) {
+                            map.putMap("location", RNRadarUtils.mapForJson(Radar.jsonForLocation(location)));
+                        }
+                        if (events != null) {
+                            map.putArray("events", RNRadarUtils.arrayForJson(RadarEvent.toJson(events)));
+                        }
+                        if (user != null) {
+                            map.putMap("user", RNRadarUtils.mapForJson(user.toJson()));
+                        }
+                        promise.resolve(map);
+                    } else {
+                        promise.reject(status.toString(), status.toString());
+                    }
+                } catch (JSONException e) {
+                    Log.e(TAG, "JSONException", e);
+                    promise.reject(Radar.RadarStatus.ERROR_SERVER.toString(), Radar.RadarStatus.ERROR_SERVER.toString());
+                }
+            }
+        });
+    }
+
 }

package/android/src/main/java/io/radar/react/RNRadarUtils.java

@@ -3,6 +3,8 @@ package io.radar.react;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import java.util.Iterator;
+import java.util.Map;
+import java.util.HashMap;
 
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -148,5 +150,18 @@ class RNRadarUtils {
         }
         return arr;
     }
+    static Map<String, String> stringStringMap(ReadableMap readableMap) {
+        if (readableMap == null) {
+            return null;
+        }
+
+        Map<String, String> stringMap = new HashMap<String, String>();
+        ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            stringMap.put(key, readableMap.getString(key));
+        }
+        return stringMap;
+    }
 
 }

package/ios/RNRadar.m

@@ -111,14 +111,34 @@ RCT_EXPORT_METHOD(setUserId:(NSString *)userId) {
     [Radar setUserId:userId];
 }
 
+RCT_EXPORT_METHOD(getUserId:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    resolve([Radar getUserId]);
+}
+
 RCT_EXPORT_METHOD(setDescription:(NSString *)description) {
     [Radar setDescription:description];
 }
 
+RCT_EXPORT_METHOD(getDescription:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    resolve([Radar getDescription]);
+}
+
 RCT_EXPORT_METHOD(setMetadata:(NSDictionary *)metadataDict) {
     [Radar setMetadata:metadataDict];
 }
 
+RCT_EXPORT_METHOD(getMetadata:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    resolve([Radar getMetadata]);
+}
+
+RCT_EXPORT_METHOD(setAnonymousTrackingEnabled:(BOOL)enabled) {
+    [Radar setAnonymousTrackingEnabled:enabled];
+}
+
+RCT_EXPORT_METHOD(setAdIdEnabled:(BOOL)enabled) {
+    [Radar setAdIdEnabled:enabled];
+}
+
 RCT_REMAP_METHOD(getPermissionsStatus, getPermissionsStatusWithResolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
     CLAuthorizationStatus status = [CLLocationManager authorizationStatus];
     NSString *statusStr;
@@ -158,11 +178,29 @@ RCT_EXPORT_METHOD(requestPermissions:(BOOL)background resolve:(RCTPromiseResolve
     }
 }
 
-RCT_EXPORT_METHOD(getLocation:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(getLocation:(NSString *)desiredAccuracy resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
     __block RCTPromiseResolveBlock resolver = resolve;
     __block RCTPromiseRejectBlock rejecter = reject;
+    RadarTrackingOptionsDesiredAccuracy accuracy = RadarTrackingOptionsDesiredAccuracyMedium;
+    
+    if (desiredAccuracy) {
+        NSString *lowerAccuracy = [desiredAccuracy lowercaseString];
+        if ([lowerAccuracy isEqualToString:@"high"]) {
+            accuracy = RadarTrackingOptionsDesiredAccuracyHigh;
+        } else if ([lowerAccuracy isEqualToString:@"medium"]) {
+            accuracy = RadarTrackingOptionsDesiredAccuracyMedium;
+        } else if ([lowerAccuracy isEqualToString:@"low"]) {
+            accuracy = RadarTrackingOptionsDesiredAccuracyLow;
+        } else {
+            if (reject) {
+                reject([Radar stringForStatus:RadarStatusErrorBadRequest], [Radar stringForStatus:RadarStatusErrorBadRequest], nil);
+            }
+            
+            return;
+        }
+    }
 
-    [Radar getLocationWithCompletionHandler:^(RadarStatus status, CLLocation * _Nullable location, BOOL stopped) {
+    [Radar getLocationWithDesiredAccuracy:accuracy completionHandler:^(RadarStatus status, CLLocation * _Nullable location, BOOL stopped) {
         if (status == RadarStatusSuccess && resolver) {
             NSMutableDictionary *dict = [NSMutableDictionary new];
             [dict setObject:[Radar stringForStatus:status] forKey:@"status"];
@@ -307,6 +345,20 @@ RCT_EXPORT_METHOD(stopTracking) {
     [Radar stopTracking];
 }
 
+RCT_EXPORT_METHOD(isTracking:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    BOOL res = [Radar isTracking];
+    resolve(@(res));
+}
+
+RCT_EXPORT_METHOD(getTrackingOptions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    if (resolve == nil) {
+        return;
+    }
+    
+    RadarTrackingOptions* options = [Radar getTrackingOptions];
+    resolve([options dictionaryValue]);
+}
+
 RCT_EXPORT_METHOD(setForegroundServiceOptions) {
     // not implemented
 }
@@ -319,8 +371,20 @@ RCT_EXPORT_METHOD(rejectEvent:(NSString *)eventId) {
     [Radar rejectEventId:eventId];
 }
 
+RCT_EXPORT_METHOD(getTripOptions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    if (resolve == nil) {
+        return;
+    }
+    
+    RadarTripOptions* options = [Radar getTripOptions];
+    resolve([options dictionaryValue]);
+}
+
 RCT_EXPORT_METHOD(startTrip:(NSDictionary *)optionsDict resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
     RadarTripOptions *options = [RadarTripOptions tripOptionsFromDictionary:optionsDict];
+    if (options.scheduledArrivalAt) {
+        options.scheduledArrivalAt = [RCTConvert NSDate:options.scheduledArrivalAt];
+    }
 
     __block RCTPromiseResolveBlock resolver = resolve;
     __block RCTPromiseRejectBlock rejecter = reject;
@@ -516,6 +580,7 @@ RCT_EXPORT_METHOD(searchPlaces:(NSDictionary *)optionsDict resolve:(RCTPromiseRe
         radius = 1000;
     }
     NSArray *chains = optionsDict[@"chains"];
+    NSDictionary *chainMetadata = optionsDict[@"chainMetadata"];
     NSArray *categories = optionsDict[@"categories"];
     NSArray *groups = optionsDict[@"groups"];
     NSNumber *limitNumber = optionsDict[@"limit"];
@@ -548,9 +613,9 @@ RCT_EXPORT_METHOD(searchPlaces:(NSDictionary *)optionsDict resolve:(RCTPromiseRe
     };
 
     if (near) {
-        [Radar searchPlacesNear:near radius:radius chains:chains categories:categories groups:groups limit:limit completionHandler:completionHandler];
+        [Radar searchPlacesNear:near radius:radius chains:chains chainMetadata:chainMetadata categories:categories groups:groups limit:limit completionHandler:completionHandler];
     } else {
-        [Radar searchPlacesWithRadius:radius chains:chains categories:categories groups:groups limit:limit completionHandler:completionHandler];
+        [Radar searchPlacesWithRadius:radius chains:chains chainMetadata:chainMetadata categories:categories groups:groups limit:limit completionHandler:completionHandler];
     }
 }
 
@@ -889,4 +954,29 @@ RCT_EXPORT_METHOD(getMatrix:(NSDictionary *)optionsDict resolve:(RCTPromiseResol
     }];
 }
 
+RCT_EXPORT_METHOD(sendEvent:(NSString*) customType metadata:(NSDictionary *)metadata resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    __block RCTPromiseResolveBlock resolver = resolve;
+    __block RCTPromiseRejectBlock rejecter = reject;
+    
+    [Radar sendEvent:customType withMetadata:metadata completionHandler:^(RadarStatus status, CLLocation * _Nullable location, NSArray<RadarEvent *> * _Nullable events, RadarUser * _Nullable user) {
+        if (status == RadarStatusSuccess && resolver) {
+            NSMutableDictionary *dict = [NSMutableDictionary new];
+            [dict setObject:[Radar stringForStatus:status] forKey:@"status"];
+            if (location) {
+                [dict setObject:[Radar dictionaryForLocation:location] forKey:@"location"];
+            }
+            if (events) {
+                [dict setObject:[RadarEvent arrayForEvents:events] forKey:@"events"];
+            }
+            if (user) {
+                [dict setObject:[user dictionaryValue] forKey:@"user"];
+            }
+            resolver(dict);
+        } else if (rejecter) {
+            rejecter([Radar stringForStatus:status], [Radar stringForStatus:status], nil);
+        }
+        resolver = nil;
+        rejecter = nil;
+    }];
+}
 @end

package/js/index.js

@@ -1,184 +1,9 @@
-import { NativeEventEmitter, NativeModules } from 'react-native';
+import { Platform } from 'react-native';
 
-if (!NativeModules.RNRadar) {
-  throw new Error('NativeModules.RNRadar is undefined');
-}
+let module = {};
+if (Platform.OS === 'web')
+  module =  require('./index.web').default;
+else
+  module = require('./index.native').default;
 
-const eventEmitter = new NativeEventEmitter(NativeModules.RNRadar);
-
-const setLogLevel = (level) => {
-  NativeModules.RNRadar.setLogLevel(level);
-};
-
-const setUserId = (userId) => {
-  NativeModules.RNRadar.setUserId(userId);
-};
-
-const setDescription = (description) => {
-  NativeModules.RNRadar.setDescription(description);
-};
-
-const setMetadata = (metadata) => {
-  NativeModules.RNRadar.setMetadata(metadata);
-};
-
-const getPermissionsStatus = () => (
-  NativeModules.RNRadar.getPermissionsStatus()
-);
-
-const requestPermissions = background => (
-  NativeModules.RNRadar.requestPermissions(background)
-);
-
-const getLocation = () => (
-  NativeModules.RNRadar.getLocation()
-);
-
-const trackOnce = options => {
-  let backCompatibleOptions = options;
-  if (options && options.latitude) {
-    backCompatibleOptions = {
-      location: {
-        ...options
-      }
-    }
-  }
-  return NativeModules.RNRadar.trackOnce(backCompatibleOptions)
-};
-
-const startTrackingEfficient = () => (
-  NativeModules.RNRadar.startTrackingEfficient()
-);
-
-const startTrackingResponsive = () => (
-  NativeModules.RNRadar.startTrackingResponsive()
-);
-
-const startTrackingContinuous = () => (
-  NativeModules.RNRadar.startTrackingContinuous()
-);
-
-const startTrackingCustom = options => (
-  NativeModules.RNRadar.startTrackingCustom(options)
-);
-
-const mockTracking = options => (
-  NativeModules.RNRadar.mockTracking(options)
-);
-
-const stopTracking = () => (
-  NativeModules.RNRadar.stopTracking()
-);
-
-const setForegroundServiceOptions = options => (
-  NativeModules.RNRadar.setForegroundServiceOptions(options)
-);
-
-const startTrip = options => (
-  NativeModules.RNRadar.startTrip(options)
-);
-
-const completeTrip = () => (
-  NativeModules.RNRadar.completeTrip()
-);
-
-const cancelTrip = () => (
-  NativeModules.RNRadar.cancelTrip()
-);
-
-const updateTrip = options => (
-  NativeModules.RNRadar.updateTrip(options)
-);
-
-const acceptEvent = (eventId, verifiedPlaceId) => (
-  NativeModules.RNRadar.acceptEvent(eventId, verifiedPlaceId)
-);
-
-const rejectEvent = eventId => (
-  NativeModules.RNRadar.rejectEvent(eventId)
-);
-
-const getContext = location => (
-  NativeModules.RNRadar.getContext(location)
-);
-
-const searchPlaces = options => (
-  NativeModules.RNRadar.searchPlaces(options)
-);
-
-const searchGeofences = options => (
-  NativeModules.RNRadar.searchGeofences(options)
-);
-
-const autocomplete = options => (
-  NativeModules.RNRadar.autocomplete(options)
-);
-
-const geocode = address => (
-  NativeModules.RNRadar.geocode(address)
-);
-
-const reverseGeocode = location => (
-  NativeModules.RNRadar.reverseGeocode(location)
-);
-
-const ipGeocode = () => (
-  NativeModules.RNRadar.ipGeocode()
-);
-
-const getDistance = options => (
-  NativeModules.RNRadar.getDistance(options)
-);
-
-const getMatrix = options => (
-  NativeModules.RNRadar.getMatrix(options)
-);
-
-const on = (event, callback) => (
-  eventEmitter.addListener(event, callback)
-);
-
-const off = (event, callback) => {
-  if (callback) {
-    eventEmitter.removeListener(event, callback);
-  } else {
-    eventEmitter.removeAllListeners(event);
-  }
-};
-
-const Radar = {
-  setLogLevel,
-  setUserId,
-  setDescription,
-  setMetadata,
-  getPermissionsStatus,
-  requestPermissions,
-  getLocation,
-  trackOnce,
-  startTrackingEfficient,
-  startTrackingResponsive,
-  startTrackingContinuous,
-  startTrackingCustom,
-  mockTracking,
-  stopTracking,
-  setForegroundServiceOptions,
-  acceptEvent,
-  rejectEvent,
-  startTrip,
-  updateTrip,
-  completeTrip,
-  cancelTrip,
-  getContext,
-  searchPlaces,
-  searchGeofences,
-  autocomplete,
-  geocode,
-  reverseGeocode,
-  ipGeocode,
-  getDistance,
-  getMatrix,
-  on,
-  off,
-};
-
-export default Radar;
+export default module;

package/js/index.native.js

@@ -0,0 +1,229 @@
+import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+
+if (!NativeModules.RNRadar && (Platform.OS === 'ios' || Platform.OS === 'android')) {
+  throw new Error('NativeModules.RNRadar is undefined');
+}
+
+const eventEmitter = new NativeEventEmitter(NativeModules.RNRadar);
+
+const setLogLevel = (level) => {
+  NativeModules.RNRadar.setLogLevel(level);
+};
+
+const setUserId = (userId) => {
+  NativeModules.RNRadar.setUserId(userId);
+};
+
+const getUserId = () => (
+  NativeModules.RNRadar.getUserId()
+);
+
+const setDescription = (description) => {
+  NativeModules.RNRadar.setDescription(description);
+};
+
+const getDescription = () => (
+  NativeModules.RNRadar.getDescription()
+);
+
+const setMetadata = (metadata) => {
+  NativeModules.RNRadar.setMetadata(metadata);
+};
+
+const getMetadata = () => (
+  NativeModules.RNRadar.getMetadata()
+)
+
+const setAnonymousTrackingEnabled = (enabled) => (
+  NativeModules.RNRadar.setAnonymousTrackingEnabled(enabled)
+)
+
+const setAdIdEnabled = (enabled) => (
+  NativeModules.RNRadar.setAdIdEnabled(enabled)
+)
+
+const getPermissionsStatus = () => (
+  NativeModules.RNRadar.getPermissionsStatus()
+);
+
+const requestPermissions = background => (
+  NativeModules.RNRadar.requestPermissions(background)
+);
+
+const getLocation = desiredAccuracy => (
+  NativeModules.RNRadar.getLocation(desiredAccuracy)
+);
+
+const trackOnce = options => {
+  let backCompatibleOptions = options;
+  if (options && options.latitude) {
+    backCompatibleOptions = {
+      location: {
+        ...options
+      }
+    }
+  }
+  return NativeModules.RNRadar.trackOnce(backCompatibleOptions)
+};
+
+const startTrackingEfficient = () => (
+  NativeModules.RNRadar.startTrackingEfficient()
+);
+
+const startTrackingResponsive = () => (
+  NativeModules.RNRadar.startTrackingResponsive()
+);
+
+const startTrackingContinuous = () => (
+  NativeModules.RNRadar.startTrackingContinuous()
+);
+
+const startTrackingCustom = options => (
+  NativeModules.RNRadar.startTrackingCustom(options)
+);
+
+const mockTracking = options => (
+  NativeModules.RNRadar.mockTracking(options)
+);
+
+const stopTracking = () => (
+  NativeModules.RNRadar.stopTracking()
+);
+
+const getTrackingOptions = () => (
+  NativeModules.RNRadar.getTrackingOptions()
+)
+
+const isTracking = () => (
+  NativeModules.RNRadar.isTracking()
+)
+
+const setForegroundServiceOptions = options => (
+  NativeModules.RNRadar.setForegroundServiceOptions(options)
+);
+
+const getTripOptions = () => (
+  NativeModules.RNRadar.getTripOptions()
+)
+
+const startTrip = options => (
+  NativeModules.RNRadar.startTrip(options)
+);
+
+const completeTrip = () => (
+  NativeModules.RNRadar.completeTrip()
+);
+
+const cancelTrip = () => (
+  NativeModules.RNRadar.cancelTrip()
+);
+
+const updateTrip = options => (
+  NativeModules.RNRadar.updateTrip(options)
+);
+
+const acceptEvent = (eventId, verifiedPlaceId) => (
+  NativeModules.RNRadar.acceptEvent(eventId, verifiedPlaceId)
+);
+
+const rejectEvent = eventId => (
+  NativeModules.RNRadar.rejectEvent(eventId)
+);
+
+const getContext = location => (
+  NativeModules.RNRadar.getContext(location)
+);
+
+const searchPlaces = options => (
+  NativeModules.RNRadar.searchPlaces(options)
+);
+
+const searchGeofences = options => (
+  NativeModules.RNRadar.searchGeofences(options)
+);
+
+const autocomplete = options => (
+  NativeModules.RNRadar.autocomplete(options)
+);
+
+const geocode = address => (
+  NativeModules.RNRadar.geocode(address)
+);
+
+const reverseGeocode = location => (
+  NativeModules.RNRadar.reverseGeocode(location)
+);
+
+const ipGeocode = () => (
+  NativeModules.RNRadar.ipGeocode()
+);
+
+const getDistance = options => (
+  NativeModules.RNRadar.getDistance(options)
+);
+
+const getMatrix = options => (
+  NativeModules.RNRadar.getMatrix(options)
+);
+
+const sendEvent = (customType, metadata) => (
+  NativeModules.RNRadar.sendEvent(customType, metadata)
+)
+
+const on = (event, callback) => (
+  eventEmitter.addListener(event, callback)
+);
+
+const off = (event, callback) => {
+  if (callback) {
+    eventEmitter.removeListener(event, callback);
+  } else {
+    eventEmitter.removeAllListeners(event);
+  }
+};
+
+const Radar = {
+  setLogLevel,
+  setUserId,
+  getUserId,
+  setDescription,
+  getDescription,
+  setMetadata,
+  getMetadata,
+  setAnonymousTrackingEnabled,
+  setAdIdEnabled,
+  getPermissionsStatus,
+  requestPermissions,
+  getLocation,
+  trackOnce,
+  startTrackingEfficient,
+  startTrackingResponsive,
+  startTrackingContinuous,
+  startTrackingCustom,
+  mockTracking,
+  stopTracking,
+  isTracking,
+  getTrackingOptions,
+  setForegroundServiceOptions,
+  acceptEvent,
+  rejectEvent,
+  getTripOptions,
+  startTrip,
+  updateTrip,
+  completeTrip,
+  cancelTrip,
+  getContext,
+  searchPlaces,
+  searchGeofences,
+  autocomplete,
+  geocode,
+  reverseGeocode,
+  ipGeocode,
+  getDistance,
+  getMatrix,
+  sendEvent,
+  on,
+  off,
+};
+
+export default Radar;

package/js/index.web.js

@@ -0,0 +1,400 @@
+import RadarJS from 'radar-sdk-js';
+
+const initialize = (publishableKey) => {
+  RadarJS.initialize(publishableKey);
+}
+
+const setLogLevel = (level) => {
+  // not implemented
+};
+
+const setUserId = (userId) => {
+  RadarJS.setUserId(userId);
+};
+
+const setDeviceId = (deviceId, installId) => {
+  RadarJS.setDeviceId(deviceId, installId);
+}
+const setDeviceType = (deviceType) => {
+  RadarJS.setDeviceType(deviceType);
+}
+
+const setRequestHeaders = (headers) => {
+  RadarJS.setRequestHeaders(headers);
+}
+
+const setDescription = (description) => {
+  RadarJS.setDescription(description);
+};
+
+const setMetadata = (metadata) => {
+  RadarJS.setMetadata(metadata);
+};
+
+const getPermissionsStatus = () => {
+  return new Promise(resolve => {
+    const navigator = window.navigator;
+
+    if (!navigator.permissions) {
+      resolve({
+        status: 'UNKNOWN'
+      });
+    } else {
+      navigator.permissions.query({ name: 'geolocation' }).then((result) => {
+        resolve({
+          status: result.state === 'granted' ? 'GRANTED_FOREGROUND' : 'DENIED',
+        });
+      });
+    }
+  });
+};
+
+const requestPermissions = background => {
+  // not implemented
+};
+
+const getLocation = () => {
+  return new Promise((resolve, reject) => {    
+    RadarJS.getLocation((err, result) => {
+      if (err)
+        reject(err);
+      else
+        resolve(result);
+    })
+  });
+};
+
+const trackOnce = options => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { status, location, user, events }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          user,
+          events,
+        });
+      }
+    };
+
+    if (options) {
+      RadarJS.trackOnce(options.location ? options.location : options, callback);
+    } else {
+      RadarJS.trackOnce(callback);
+    }
+  });
+};
+
+const startTrackingEfficient = () => {  
+  // not implemented
+};
+
+const startTrackingResponsive = () => {
+  // not implemented
+};
+
+const startTrackingContinuous = () => {
+  // not implemented
+};
+
+const startTrackingCustom = options => {
+  // not implemented
+};
+
+const mockTracking = options => {
+  // not implemented
+};
+
+const stopTracking = () => {
+  // not implemented
+};
+
+const setForegroundServiceOptions = options => {
+  // not implemented
+};
+
+const startTrip = options => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+
+    RadarJS.startTrip(options, callback);
+  });
+};
+
+const completeTrip = () => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+    
+    RadarJS.completeTrip(callback);
+  });
+};
+
+const cancelTrip = () => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+    
+    RadarJS.cancelTrip(callback);
+  });
+};
+
+const updateTrip = (tripOptions) => {  
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+    
+    RadarJS.updateTrip(tripOptions.options, tripOptions.status, callback);
+  });
+};
+
+const acceptEvent = (eventId, verifiedPlaceId) => {
+  // not implemented
+};
+
+const rejectEvent = eventId => {
+  // not implemented
+};
+
+const getContext = options => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { status, location, context }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          context,
+        });
+      }
+    };
+
+    if (options) {
+      RadarJS.getContext(options, callback);
+    } else {
+      RadarJS.getContext(callback);
+    }
+  });
+};
+
+const searchPlaces = options => {
+  return new Promise((resolve, reject) => {
+    RadarJS.searchPlaces(options, (err, { status, location, places }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          places,
+        });
+      }
+    });
+  });
+};
+
+const searchGeofences = options => {
+  return new Promise((resolve, reject) => {
+    RadarJS.searchGeofences(options, (err, { status, location, geofences }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          geofences,
+        });
+      }
+    });
+  });
+};
+
+const autocomplete = options => {
+  return new Promise((resolve, reject) => {
+    RadarJS.autocomplete(options, (err, { status, addresses }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          addresses,
+        });
+      }
+    });
+  });
+};
+
+const geocode = options => {
+  return new Promise((resolve, reject) => {
+    let newOptions = options;
+    if (typeof options === 'string')
+      newOptions = {
+        query: options
+      };
+    
+    RadarJS.geocode(newOptions, (err, { status, addresses }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          addresses,
+        });
+      }
+    });
+  });
+};
+
+const reverseGeocode = options => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { status, addresses }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          addresses,
+        });
+      }
+    };
+
+    if (options) {
+      RadarJS.reverseGeocode(options, callback);
+    } else {
+      RadarJS.reverseGeocode(callback);
+    }
+  });
+};
+
+const ipGeocode = () => {
+  return new Promise((resolve, reject) => {
+    RadarJS.ipGeocode((err, { status, address }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          address,
+        });
+      }
+    });
+  });
+};
+
+const getDistance = options => {
+  return new Promise((resolve, reject) => {
+    RadarJS.getDistance(options, (err, { status, routes }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          routes,
+        });
+      }
+    });
+  });
+};
+
+const getMatrix = options => {
+  return new Promise((resolve, reject) => {
+    RadarJS.getMatrix(options, (err, { origins, destinations, matrix, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          origins,
+          destinations,
+          matrix,
+          status,
+        });
+      }
+    });
+  });
+};
+
+const on = (event, callback) => {
+  // not implemented
+};
+
+const off = (event, callback) => {
+  // not implemented
+};
+
+const Radar = {
+  initialize,
+  setLogLevel,
+  setUserId,
+  setDescription,
+  setMetadata,
+  getPermissionsStatus,
+  requestPermissions,
+  getLocation,
+  trackOnce,
+  startTrackingEfficient,
+  startTrackingResponsive,
+  startTrackingContinuous,
+  startTrackingCustom,
+  mockTracking,
+  stopTracking,
+  setForegroundServiceOptions,
+  acceptEvent,
+  rejectEvent,
+  startTrip,
+  updateTrip,
+  completeTrip,
+  cancelTrip,
+  getContext,
+  searchPlaces,
+  searchGeofences,
+  autocomplete,
+  geocode,
+  reverseGeocode,
+  ipGeocode,
+  getDistance,
+  getMatrix,
+  on,
+  off,
+};
+
+export default Radar;

package/package.json

@@ -3,7 +3,7 @@
   "description": "React Native module for Radar, the leading geofencing and location tracking platform",
   "homepage": "https://radar.com",
   "license": "Apache-2.0",
-  "version": "3.5.5",
+  "version": "3.5.7",
   "main": "js/index.js",
   "files": [
     "android",
@@ -48,7 +48,8 @@
     "metro-react-native-babel-preset": "^0.51.1",
     "npm-run-all": "^4.1.5",
     "react": "16.8.6",
-    "react-native": "0.60.0"
+    "react-native": "0.60.0",
+    "radar-sdk-js": "^3.3.0"
   },
   "bugs": {
     "url": "https://github.com/radarlabs/react-native-radar/issues"