react-native-radar 3.4.0 → 3.5.4

package/android/build.gradle

@@ -18,7 +18,7 @@ android {
         minSdkVersion 16
         targetSdkVersion 31
         versionCode 1
-        versionName '3.2.3'
+        versionName '3.5.4'
     }
     lintOptions {
         abortOnError false
@@ -45,5 +45,5 @@ repositories {
 
 dependencies {
     api 'com.facebook.react:react-native:+'
-    api 'io.radar:sdk:3.4.5'
+    api 'io.radar:sdk:3.5.4'
 }

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

@@ -23,6 +23,7 @@ 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.model.RadarAddress;
 import io.radar.sdk.model.RadarContext;
@@ -174,56 +175,41 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
     }
 
     @ReactMethod
-    public void trackOnce(final Promise promise) {
-        Radar.trackOnce(new Radar.RadarTrackCallback() {
-            @Override
-            public void onComplete(@NonNull Radar.RadarStatus status, @Nullable Location location, @Nullable RadarEvent[] events, @Nullable RadarUser user) {
-                if (promise == null) {
-                    return;
-                }
-
-                if (status == Radar.RadarStatus.SUCCESS) {
-                    try {
-                        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);
-                    } catch (JSONException e) {
-                        Log.e(TAG, "JSONException", e);
-                        promise.reject(Radar.RadarStatus.ERROR_SERVER.toString(), Radar.RadarStatus.ERROR_SERVER.toString());
-                    }
-                } else {
-                    promise.reject(status.toString(), status.toString());
+    public void trackOnce(ReadableMap optionsMap, final Promise promise) {
+        
+        Location location = null;
+        RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.MEDIUM;
+        boolean beaconsTrackingOption = false;
+
+        if (optionsMap != null) {
+            if (optionsMap.hasKey("location")) {
+                ReadableMap locationMap = optionsMap.getMap("location");
+                location = new Location("RNRadarModule");
+                double latitude = locationMap.getDouble("latitude");
+                double longitude = locationMap.getDouble("longitude");
+                float accuracy = (float)locationMap.getDouble("accuracy");
+                location.setLatitude(latitude);
+                location.setLongitude(longitude);
+                location.setAccuracy(accuracy);
+            }
+            if (optionsMap.hasKey("accuracy")) {
+                String accuracy = optionsMap.getString("accuracy").toLowerCase();
+                if (accuracy.equals("none")) {
+                    accuracyLevel = RadarTrackingOptions.RadarTrackingOptionsDesiredAccuracy.NONE;
+                } else 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;
                 }
             }
-        });
-    }
-
-    @ReactMethod
-    public void trackOnce(ReadableMap locationMap, final Promise promise) {
-        if (locationMap == null) {
-            this.trackOnce(promise);
-
-            return;
+            if (optionsMap.hasKey("beacons")) {
+                beaconsTrackingOption = optionsMap.getBoolean("beacons");
+            }
         }
 
-        double latitude = locationMap.getDouble("latitude");
-        double longitude = locationMap.getDouble("longitude");
-        float accuracy = (float)locationMap.getDouble("accuracy");
-        Location location = new Location("RNRadarModule");
-        location.setLatitude(latitude);
-        location.setLongitude(longitude);
-        location.setAccuracy(accuracy);
-
-        Radar.trackOnce(location, new Radar.RadarTrackCallback() {
+        Radar.RadarTrackCallback trackCallback = new Radar.RadarTrackCallback() {
             @Override
             public void onComplete(@NonNull Radar.RadarStatus status, @Nullable Location location, @Nullable RadarEvent[] events, @Nullable RadarUser user) {
                 if (promise == null) {
@@ -252,7 +238,13 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
                     promise.reject(Radar.RadarStatus.ERROR_SERVER.toString(), Radar.RadarStatus.ERROR_SERVER.toString());
                 }
             }
-        });
+        };
+
+        if (location != null) {
+            Radar.trackOnce(location, trackCallback);
+        } else {
+            Radar.trackOnce(accuracyLevel, beaconsTrackingOption, trackCallback);
+        }
     }
 
     @ReactMethod
@@ -320,6 +312,17 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
         Radar.stopTracking();
     }
 
+    @ReactMethod
+    public void setForegroundServiceOptions(ReadableMap optionsMap) {
+        try {
+            JSONObject optionsObj = RNRadarUtils.jsonForMap(optionsMap);
+            RadarTrackingOptionsForegroundService options = RadarTrackingOptionsForegroundService.fromJson(optionsObj);
+            Radar.setForegroundServiceOptions(options);
+        } catch (JSONException e) {
+            Log.e(TAG, "JSONException", e);
+        }
+    }
+
     @ReactMethod
     public void acceptEvent(String eventId, String verifiedPlaceId) {
         Radar.acceptEvent(eventId, verifiedPlaceId);

package/ios/Cartfile.resolved

@@ -1 +1 @@
-github "radarlabs/radar-sdk-ios" "3.4.3"
+github "radarlabs/radar-sdk-ios" "3.5.4"

package/ios/RNRadar.m

@@ -179,44 +179,25 @@ RCT_EXPORT_METHOD(getLocation:(RCTPromiseResolveBlock)resolve reject:(RCTPromise
     }];
 }
 
-RCT_EXPORT_METHOD(trackOnce:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(trackOnce:(NSDictionary *)optionsDict resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    RadarTrackingOptionsDesiredAccuracy desiredAccuracy;
+    BOOL beaconsTrackingOption = NO;
+    desiredAccuracy = RadarTrackingOptionsDesiredAccuracyMedium;
+
     __block RCTPromiseResolveBlock resolver = resolve;
     __block RCTPromiseRejectBlock rejecter = reject;
 
-    [Radar trackOnceWithCompletionHandler:^(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;
-    }];
-}
+    NSDictionary *locationDict = optionsDict[@"location"];
 
-RCT_EXPORT_METHOD(trackOnce:(NSDictionary *)locationDict resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
     CLLocation *location;
     if (locationDict != nil && [locationDict isKindOfClass:[NSDictionary class]]) {
         double latitude = [RCTConvert double:locationDict[@"latitude"]];
         double longitude = [RCTConvert double:locationDict[@"longitude"]];
+        double accuracy = [RCTConvert double:locationDict[@"accuracy"]];
         NSDate *timestamp = [NSDate new];
-        location = [[CLLocation alloc] initWithCoordinate:CLLocationCoordinate2DMake(latitude, longitude) altitude:-1 horizontalAccuracy:5 verticalAccuracy:-1 timestamp:timestamp];
+        location = [[CLLocation alloc] initWithCoordinate:CLLocationCoordinate2DMake(latitude, longitude) altitude:-1 horizontalAccuracy:accuracy verticalAccuracy:-1 timestamp:timestamp];
     }
 
-    __block RCTPromiseResolveBlock resolver = resolve;
-    __block RCTPromiseRejectBlock rejecter = reject;
-
     RadarTrackCompletionHandler completionHandler = ^(RadarStatus status, CLLocation * _Nullable location, NSArray<RadarEvent *> * _Nullable events, RadarUser * _Nullable user) {
         if (status == RadarStatusSuccess && resolver) {
             NSMutableDictionary *dict = [NSMutableDictionary new];
@@ -238,13 +219,33 @@ RCT_EXPORT_METHOD(trackOnce:(NSDictionary *)locationDict resolve:(RCTPromiseReso
         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 {
-        [Radar trackOnceWithCompletionHandler:completionHandler];
+        BOOL beacons = optionsDict[@"beacons"];
+
+        if (beacons) {
+            beaconsTrackingOption = beacons;
+        }
+        
+        [Radar trackOnceWithDesiredAccuracy:desiredAccuracy beacons:beaconsTrackingOption completionHandler:completionHandler];
     }
 }
 
+
 RCT_EXPORT_METHOD(startTrackingEfficient) {
     [Radar startTrackingWithOptions:RadarTrackingOptions.presetEfficient];
 }
@@ -306,6 +307,10 @@ RCT_EXPORT_METHOD(stopTracking) {
     [Radar stopTracking];
 }
 
+RCT_EXPORT_METHOD(setForegroundServiceOptions) {
+    // not implemented
+}
+
 RCT_EXPORT_METHOD(acceptEvent:(NSString *)eventId verifiedPlaceId:(NSString *)verifiedPlaceId) {
     [Radar acceptEventId:eventId verifiedPlaceId:verifiedPlaceId];
 }

package/js/index.js

@@ -34,9 +34,17 @@ const getLocation = () => (
   NativeModules.RNRadar.getLocation()
 );
 
-const trackOnce = location => (
-  NativeModules.RNRadar.trackOnce(location)
-);
+const trackOnce = options => {
+  let backCompatibleOptions = options;
+  if (options && options.latitude) {
+    backCompatibleOptions = {
+      location: {
+        ...options
+      }
+    }
+  }
+  return NativeModules.RNRadar.trackOnce(backCompatibleOptions)
+};
 
 const startTrackingEfficient = () => (
   NativeModules.RNRadar.startTrackingEfficient()
@@ -62,6 +70,10 @@ const stopTracking = () => (
   NativeModules.RNRadar.stopTracking()
 );
 
+const setForegroundServiceOptions = options => (
+  NativeModules.RNRadar.setForegroundServiceOptions(options)
+);
+
 const startTrip = options => (
   NativeModules.RNRadar.startTrip(options)
 );
@@ -149,6 +161,7 @@ const Radar = {
   startTrackingCustom,
   mockTracking,
   stopTracking,
+  setForegroundServiceOptions,
   acceptEvent,
   rejectEvent,
   startTrip,

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.4.0",
+  "version": "3.5.4",
   "main": "js/index.js",
   "files": [
     "android",

package/react-native-radar.podspec

@@ -15,5 +15,5 @@ Pod::Spec.new do |s|
   s.platform = :ios, "10.0"
 
   s.dependency "React"
-  s.dependency "RadarSDK", "~> 3.4.3"
+  s.dependency "RadarSDK", "~> 3.5.4"
 end