react-native-radar 3.2.0 → 3.2.1

package/README.md

@@ -2,15 +2,15 @@
 
 [![npm](https://img.shields.io/npm/v/react-native-radar.svg)](https://www.npmjs.com/package/react-native-radar)
 
-[Radar](https://radar.io) is the leading geofencing and location tracking platform.
+[Radar](https://radar.com) is the leading geofencing and location tracking platform.
 
 The Radar SDK abstracts away cross-platform differences between location services, allowing you to add geofencing, location tracking, trip tracking, geocoding, and search to your apps with just a few lines of code.
 
 ## Documentation
 
-See the Radar overview documentation [here](https://radar.io/documentation).
+See the Radar overview documentation [here](https://radar.com/documentation).
 
-Then, see the Radar React Native module documentation [here](https://radar.io/documentation/sdk/react-native).
+Then, see the Radar React Native module documentation [here](https://radar.com/documentation/sdk/react-native).
 
 ## Examples
 
@@ -18,4 +18,4 @@ See an example app in `example/`.
 
 ## Support
 
-Have questions? We're here to help! Email us at [support@radar.io](mailto:support@radar.io).
+Have questions? We're here to help! Email us at [support@radar.com](mailto:support@radar.com).

package/android/build.gradle

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

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

@@ -331,41 +331,165 @@ public class RNRadarModule extends ReactContextBaseJavaModule implements Permiss
     }
 
     @ReactMethod
-    public void startTrip(ReadableMap optionsMap) {
+    public void startTrip(ReadableMap optionsMap, final Promise promise) {
         try {
             JSONObject optionsObj = RNRadarUtils.jsonForMap(optionsMap);
             RadarTripOptions options = RadarTripOptions.fromJson(optionsObj);
             Radar.startTrip(options, new Radar.RadarTripCallback() {
                 @Override
                 public void onComplete(@NonNull Radar.RadarStatus status, @Nullable RadarTrip trip, @Nullable RadarEvent[] events) {
-
+                    if (promise == null) {
+                        return;
+                    }
+                    try {
+                        if (status == Radar.RadarStatus.SUCCESS) {
+                            WritableMap map = Arguments.createMap();
+                            map.putString("status", status.toString());
+                            if (trip != null) {
+                                map.putMap("trip", RNRadarUtils.mapForJson(trip.toJson()));
+                            }
+                            if (events != null) {
+                                map.putArray("events", RNRadarUtils.arrayForJson(RadarEvent.toJson(events)));
+                            }
+                            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());
+                    }
                 }
             });
         } catch (JSONException e) {
             Log.e(TAG, "JSONException", e);
+            promise.reject(Radar.RadarStatus.ERROR_BAD_REQUEST.toString(), Radar.RadarStatus.ERROR_BAD_REQUEST.toString());
         }
     }
 
     @ReactMethod
-    public void completeTrip() {
+    public void completeTrip(final Promise promise) {
         Radar.completeTrip(new Radar.RadarTripCallback() {
             @Override
             public void onComplete(@NonNull Radar.RadarStatus status, @Nullable RadarTrip trip, @Nullable RadarEvent[] events) {
-
+                if (promise == null) {
+                    return;
+                }
+                try {
+                    if (status == Radar.RadarStatus.SUCCESS) {
+                        WritableMap map = Arguments.createMap();
+                        map.putString("status", status.toString());
+                        if (trip != null) {
+                            map.putMap("trip", RNRadarUtils.mapForJson(trip.toJson()));
+                        }
+                        if (events != null) {
+                            map.putArray("events", RNRadarUtils.arrayForJson(RadarEvent.toJson(events)));
+                        }
+                        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());
+                }
             }
         });
     }
 
     @ReactMethod
-    public void cancelTrip() {
+    public void cancelTrip(final Promise promise) {
         Radar.cancelTrip(new Radar.RadarTripCallback() {
             @Override
             public void onComplete(@NonNull Radar.RadarStatus status, @Nullable RadarTrip trip, @Nullable RadarEvent[] events) {
-
+                if (promise == null) {
+                    return;
+                }
+                try {
+                    if (status == Radar.RadarStatus.SUCCESS) {
+                        WritableMap map = Arguments.createMap();
+                        map.putString("status", status.toString());
+                        if (trip != null) {
+                            map.putMap("trip", RNRadarUtils.mapForJson(trip.toJson()));
+                        }
+                        if (events != null) {
+                            map.putArray("events", RNRadarUtils.arrayForJson(RadarEvent.toJson(events)));
+                        }
+                        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());
+                }
             }
         });
     }
 
+    @ReactMethod
+    public void updateTrip(ReadableMap optionsMap, final Promise promise) {
+
+        try {
+            JSONObject optionsObj = RNRadarUtils.jsonForMap(optionsMap);
+            RadarTripOptions options = RadarTripOptions.fromJson(optionsObj.getJSONObject("options"));
+            RadarTrip.RadarTripStatus status = RadarTrip.RadarTripStatus.UNKNOWN;
+
+            if (optionsObj.has("status")) {
+                String statusStr = optionsObj.getString("status");
+                if (statusStr != null) {
+                    if (statusStr.equalsIgnoreCase("started")) {
+                        status = RadarTrip.RadarTripStatus.STARTED;
+                    } else if (statusStr.equalsIgnoreCase("approaching")) {
+                        status = RadarTrip.RadarTripStatus.APPROACHING;
+                    } else if (statusStr.equalsIgnoreCase("arrived")) {
+                        status = RadarTrip.RadarTripStatus.ARRIVED;
+                    } else if (statusStr.equalsIgnoreCase("completed")) {
+                        status = RadarTrip.RadarTripStatus.COMPLETED;
+                    } else if (statusStr.equalsIgnoreCase("canceled")) {
+                        status = RadarTrip.RadarTripStatus.CANCELED;
+                    } else if (statusStr.equalsIgnoreCase("unknown")) {
+                        status = RadarTrip.RadarTripStatus.UNKNOWN;
+                    } else {
+                        promise.reject(Radar.RadarStatus.ERROR_BAD_REQUEST.toString(), Radar.RadarStatus.ERROR_BAD_REQUEST.toString());
+                    }
+                }
+            } else {
+                promise.reject(Radar.RadarStatus.ERROR_BAD_REQUEST.toString(), Radar.RadarStatus.ERROR_BAD_REQUEST.toString());
+            }
+
+            Radar.updateTrip(options, status, new Radar.RadarTripCallback() {
+                @Override
+                public void onComplete(@NonNull Radar.RadarStatus status, @Nullable RadarTrip trip, @Nullable RadarEvent[] events) {
+                    if (promise == null) {
+                        return;
+                    }
+                    try {
+                        if (status == Radar.RadarStatus.SUCCESS) {
+                            WritableMap map = Arguments.createMap();
+                            map.putString("status", status.toString());
+                            if (trip != null) {
+                                map.putMap("trip", RNRadarUtils.mapForJson(trip.toJson()));
+                            }
+                            if (events != null) {
+                                map.putArray("events", RNRadarUtils.arrayForJson(RadarEvent.toJson(events)));
+                            }
+                            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());
+                    }
+                }
+            });
+        } catch (JSONException e) {
+            Log.e(TAG, "JSONException", e);
+            promise.reject(Radar.RadarStatus.ERROR_BAD_REQUEST.toString(), Radar.RadarStatus.ERROR_BAD_REQUEST.toString());
+        }
+    }
+
     @ReactMethod
     public void getContext(final Promise promise) {
         if (promise == null) {

package/ios/Cartfile.resolved

@@ -1 +1 @@
-github "radarlabs/radar-sdk-ios" "3.1.7"
+github "radarlabs/radar-sdk-ios" "3.2.3"

package/ios/RNRadar.m

@@ -314,17 +314,140 @@ RCT_EXPORT_METHOD(rejectEvent:(NSString *)eventId) {
     [Radar rejectEventId:eventId];
 }
 
-RCT_EXPORT_METHOD(startTrip:(NSDictionary *)optionsDict) {
+RCT_EXPORT_METHOD(startTrip:(NSDictionary *)optionsDict resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
     RadarTripOptions *options = [RadarTripOptions tripOptionsFromDictionary:optionsDict];
-    [Radar startTripWithOptions:options];
+
+    __block RCTPromiseResolveBlock resolver = resolve;
+    __block RCTPromiseRejectBlock rejecter = reject;
+
+    [Radar startTripWithOptions:options completionHandler:^(RadarStatus status, RadarTrip * _Nullable trip, NSArray<RadarEvent *> * _Nullable events) {
+
+        if (status == RadarStatusSuccess && resolver) {
+            NSMutableDictionary *dict = [NSMutableDictionary new];
+            [dict setObject:[Radar stringForStatus:status] forKey:@"status"];
+            if (trip) {
+                [dict setObject:[trip dictionaryValue] forKey:@"trip"];
+            }
+            if (events) {
+                [dict setObject:[RadarEvent arrayForEvents:events] forKey:@"events"];
+            }
+            resolver(dict);
+        } else if (rejecter) {
+            rejecter([Radar stringForStatus:status], [Radar stringForStatus:status], nil);
+        }
+        resolver = nil;
+        rejecter = nil;
+    }];
 }
 
-RCT_EXPORT_METHOD(completeTrip) {
-    [Radar completeTrip];
+RCT_EXPORT_METHOD(completeTrip:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    
+    __block RCTPromiseResolveBlock resolver = resolve;
+    __block RCTPromiseRejectBlock rejecter = reject;
+
+    [Radar completeTripWithCompletionHandler:^(RadarStatus status, RadarTrip * _Nullable trip, NSArray<RadarEvent *> * _Nullable events) {
+        if (status == RadarStatusSuccess && resolver) {
+            NSMutableDictionary *dict = [NSMutableDictionary new];
+            [dict setObject:[Radar stringForStatus:status] forKey:@"status"];
+            if (trip) {
+                [dict setObject:[trip dictionaryValue] forKey:@"trip"];
+            }
+            if (events) {
+                [dict setObject:[RadarEvent arrayForEvents:events] forKey:@"events"];
+            }
+            resolver(dict);
+        } else if (rejecter) {
+            rejecter([Radar stringForStatus:status], [Radar stringForStatus:status], nil);
+        }
+        resolver = nil;
+        rejecter = nil;
+    }];
 }
 
-RCT_EXPORT_METHOD(cancelTrip) {
-    [Radar cancelTrip];
+RCT_EXPORT_METHOD(cancelTrip:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    __block RCTPromiseResolveBlock resolver = resolve;
+    __block RCTPromiseRejectBlock rejecter = reject;
+
+    [Radar cancelTripWithCompletionHandler:^(RadarStatus status, RadarTrip * _Nullable trip, NSArray<RadarEvent *> * _Nullable events) {
+        if (status == RadarStatusSuccess && resolver) {
+            NSMutableDictionary *dict = [NSMutableDictionary new];
+            [dict setObject:[Radar stringForStatus:status] forKey:@"status"];
+            if (trip) {
+                [dict setObject:[trip dictionaryValue] forKey:@"trip"];
+            }
+            if (events) {
+                [dict setObject:[RadarEvent arrayForEvents:events] forKey:@"events"];
+            }
+            resolver(dict);
+        } else if (rejecter) {
+            rejecter([Radar stringForStatus:status], [Radar stringForStatus:status], nil);
+        }
+        resolver = nil;
+        rejecter = nil;
+    }];
+}
+
+RCT_EXPORT_METHOD(updateTrip:(NSDictionary *)optionsDict resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
+    if (optionsDict == nil) {
+        if (reject) {
+            reject([Radar stringForStatus:RadarStatusErrorBadRequest], [Radar stringForStatus:RadarStatusErrorBadRequest], nil);
+        }
+
+        return;
+    }
+
+    RadarTripOptions *options = [RadarTripOptions tripOptionsFromDictionary:optionsDict[@"options"]];
+    NSString *statusStr = optionsDict[@"status"];
+
+    RadarTripStatus status = RadarTripStatusUnknown;
+    if (statusStr) {
+        if ([statusStr isEqualToString:@"started"]) {
+            status = RadarTripStatusStarted;
+        } else if ([statusStr isEqualToString:@"approaching"]) {
+            status = RadarTripStatusApproaching;
+        } else if ([statusStr isEqualToString:@"arrived"]) {
+            status = RadarTripStatusArrived;
+        } else if ([statusStr isEqualToString:@"completed"]) {
+            status = RadarTripStatusCompleted;
+        } else if ([statusStr isEqualToString:@"canceled"]) {
+            status = RadarTripStatusCanceled;
+        } else if ([statusStr isEqualToString:@"unknown"]) {
+            status = RadarTripStatusUnknown;
+        } else {
+            if (reject) {
+                reject([Radar stringForStatus:RadarStatusErrorBadRequest], [Radar stringForStatus:RadarStatusErrorBadRequest], nil);
+            }
+
+            return;
+        }
+    } else {
+        if (reject) {
+            reject([Radar stringForStatus:RadarStatusErrorBadRequest], [Radar stringForStatus:RadarStatusErrorBadRequest], nil);
+        }
+
+        return;
+    }
+
+    __block RCTPromiseResolveBlock resolver = resolve;
+    __block RCTPromiseRejectBlock rejecter = reject;
+
+    [Radar updateTripWithOptions:options status:status completionHandler:^(RadarStatus status, RadarTrip * _Nullable trip, NSArray<RadarEvent *> * _Nullable events) {
+        if (status == RadarStatusSuccess && resolver) {
+            NSMutableDictionary *dict = [NSMutableDictionary new];
+            [dict setObject:[Radar stringForStatus:status] forKey:@"status"];
+            if (trip) {
+                [dict setObject:[trip dictionaryValue] forKey:@"trip"];
+            }
+            if (events) {
+                [dict setObject:[RadarEvent arrayForEvents:events] forKey:@"events"];
+            }
+            resolver(dict);
+        } else if (rejecter) {
+            rejecter([Radar stringForStatus:status], [Radar stringForStatus:status], nil);
+        }
+        resolver = nil;
+        rejecter = nil;
+    }];
 }
 
 RCT_EXPORT_METHOD(getContext:(NSDictionary *)locationDict resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {

package/js/index.js

@@ -74,6 +74,10 @@ const cancelTrip = () => (
   NativeModules.RNRadar.cancelTrip()
 );
 
+const updateTrip = options => (
+  NativeModules.RNRadar.updateTrip(options)
+);
+
 const acceptEvent = (eventId, verifiedPlaceId) => (
   NativeModules.RNRadar.acceptEvent(eventId, verifiedPlaceId)
 );
@@ -148,6 +152,7 @@ const Radar = {
   acceptEvent,
   rejectEvent,
   startTrip,
+  updateTrip,
   completeTrip,
   cancelTrip,
   getContext,

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "react-native-radar",
   "description": "React Native module for Radar, the leading geofencing and location tracking platform",
-  "homepage": "https://radar.io",
+  "homepage": "https://radar.com",
   "license": "Apache-2.0",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "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.2.1"
+  s.dependency "RadarSDK", "~> 3.2.3"
 end