react-native-radar 3.5.4 → 3.5.6

package/android/build.gradle

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

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

@@ -192,15 +192,15 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
                 location.setLongitude(longitude);
                 location.setAccuracy(accuracy);
             }
-            if (optionsMap.hasKey("accuracy")) {
-                String accuracy = optionsMap.getString("accuracy").toLowerCase();
-                if (accuracy.equals("none")) {
+            if (optionsMap.hasKey("desiredAccuracy")) {
+                String desiredAccuracy = optionsMap.getString("desiredAccuracy").toLowerCase();
+                if (desiredAccuracy.equals("none")) {
                     accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.NONE;
-                } else if (accuracy.equals("low")) {
+                } else if (desiredAccuracy.equals("low")) {
                     accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.LOW;
-                } else if (accuracy.equals("medium")) {
+                } else if (desiredAccuracy.equals("medium")) {
                     accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.MEDIUM;
-                } else if (accuracy.equals("high")) {
+                } else if (desiredAccuracy.equals("high")) {
                     accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.HIGH;
                 }
             }

package/ios/RNRadar.m

@@ -219,22 +219,22 @@ RCT_EXPORT_METHOD(trackOnce:(NSDictionary *)optionsDict resolve:(RCTPromiseResol
         rejecter = nil;
     };
 
-    NSString *accuracy = optionsDict[@"accuracy"];
-
-    if (accuracy != nil && [accuracy isKindOfClass:[NSString class]]) {
-        NSString *lowerAccuracy = [accuracy lowercaseString];
-        if ([lowerAccuracy isEqualToString:@"high"]) {
-            desiredAccuracy = RadarTrackingOptionsDesiredAccuracyHigh;
-        } else if ([lowerAccuracy isEqualToString:@"medium"]) {
-            desiredAccuracy = RadarTrackingOptionsDesiredAccuracyMedium;
-        } else if ([lowerAccuracy isEqualToString:@"low"]) {
-            desiredAccuracy = RadarTrackingOptionsDesiredAccuracyLow;
-        }
-    }
-
     if (location) {
         [Radar trackOnceWithLocation:location completionHandler:completionHandler];
     } else {
+        NSString *accuracy = optionsDict[@"desiredAccuracy"];
+
+        if (accuracy != nil && [accuracy isKindOfClass:[NSString class]]) {
+            NSString *lowerAccuracy = [accuracy lowercaseString];
+            if ([lowerAccuracy isEqualToString:@"high"]) {
+                desiredAccuracy = RadarTrackingOptionsDesiredAccuracyHigh;
+            } else if ([lowerAccuracy isEqualToString:@"medium"]) {
+                desiredAccuracy = RadarTrackingOptionsDesiredAccuracyMedium;
+            } else if ([lowerAccuracy isEqualToString:@"low"]) {
+                desiredAccuracy = RadarTrackingOptionsDesiredAccuracyLow;
+            }
+        }
+        
         BOOL beacons = optionsDict[@"beacons"];
 
         if (beacons) {

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,184 @@
+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 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;

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.4",
+  "version": "3.5.6",
   "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"