Offline ramp up

RadarSDK.podspec

@@ -6,11 +6,12 @@ Pod::Spec.new do |s|
   s.author                = { 'Radar Labs, Inc.' => 'support@radar.com' }
   s.platform              = :ios
   s.source                = { :git => 'https://github.com/radarlabs/radar-sdk-ios.git', :tag => s.version.to_s }
-  s.source_files          = ["RadarSDK/*.{h,m}", "RadarSDK/Internal/*.{h,m}", "RadarSDK/Include/*.h"]
+  s.source_files          = ["RadarSDK/*.{h,m,swift}", "RadarSDK/Internal/*.{h,m}", "RadarSDK/Include/*.h"]
   s.module_name           = 'RadarSDK'
   s.ios.deployment_target = '10.0'
   s.frameworks            = 'CoreLocation'
   s.requires_arc          = true
   s.license               = { :type => 'Apache-2.0' }
   s.resource_bundles      = {'RadarSDK' => ['RadarSDK/PrivacyInfo.xcprivacy']}
+  s.swift_version         = '5.0'
 end

RadarSDK/Include/RadarTrackingOptions.h

@@ -182,6 +182,7 @@ typedef NS_ENUM(NSInteger, RadarTrackingOptionsSyncLocations) {
 + (NSString *)stringForSyncLocations:(RadarTrackingOptionsSyncLocations)syncLocations;
 + (RadarTrackingOptionsSyncLocations)syncLocationsForString:(NSString *)str;
 + (RadarTrackingOptions *_Nullable)trackingOptionsFromDictionary:(NSDictionary *_Nonnull)dictionary;
++ (RadarTrackingOptions *_Nullable)trackingOptionsFromObject:(NSObject *_Nonnull)object;
 - (NSDictionary *)dictionaryValue;
 
 @end

RadarSDK/Radar.m

@@ -271,15 +271,15 @@ + (void)trackOnceWithLocation:(CLLocation *)location completionHandler:(RadarTra
                                                beacons:nil
                                      completionHandler:^(RadarStatus status, NSDictionary *_Nullable res, NSArray<RadarEvent *> *_Nullable events, RadarUser *_Nullable user,
                                                          NSArray<RadarGeofence *> *_Nullable nearbyGeofences, RadarConfig *_Nullable config, RadarVerifiedLocationToken *_Nullable token) {
-                                        if (status == RadarStatusSuccess && config != nil) {                                    
+                                        if (config != nil) {                                    
                                             [[RadarLocationManager sharedInstance] updateTrackingFromMeta:config.meta];                                            
                                         }
-                                         if (completionHandler) {
-                                             [RadarUtils runOnMainThread:^{
-                                                 completionHandler(status, location, events, user);
-                                             }];
-                                         }
-                                     }];
+                                        if (completionHandler) {
+                                            [RadarUtils runOnMainThread:^{
+                                                completionHandler(status, location, events, user);
+                                            }];
+                                        }
+                                    }];
 }
 
 + (void)trackVerifiedWithCompletionHandler:(RadarTrackVerifiedCompletionHandler)completionHandler {

RadarSDK/RadarAPIClient.m

@@ -34,6 +34,7 @@
 #import "RadarVerificationManager.h"
 #import "RadarVerifiedLocationToken+Internal.h"
 #import <os/log.h>
+#import "RadarOfflineManager.h"
 
 @implementation RadarAPIClient
 
@@ -216,6 +217,7 @@ - (void)trackWithLocation:(CLLocation *_Nonnull)location
     params[@"anonymous"] = @(anonymous);
     if (anonymous) {
         params[@"deviceId"] = @"anonymous";
+        // this can be updated by offline event detection, which feels correct, not going to address right now for simplicity
         params[@"geofenceIds"] = [RadarState geofenceIds];
         params[@"placeId"] = [RadarState placeId];
         params[@"regionIds"] = [RadarState regionIds];
@@ -427,9 +429,15 @@ - (void)trackWithLocation:(CLLocation *_Nonnull)location
 
                                 [[RadarDelegateHolder sharedInstance] didFailWithStatus:status];
 
-                                return completionHandler(status, nil, nil, nil, nil, nil, nil);
-                            }
+                                // this is where we need to perform the offline detection
+                                // in essence, we want to replace what the server would had done
+                                // we also need to update the tracking, we do this by syncing some states and ensuring that radarsetting returns the ramp up value
+                                return [RadarOfflineManager contextualizeLocation:location completionHandler:^(RadarConfig * _Nullable config) {
+                                    return completionHandler(status, nil, nil, nil, nil, config, nil);
+                                }];
 
+                            }
+                            // since we had a successful track, the do we need to clear anything here?
                             [[RadarReplayBuffer sharedInstance] clearBuffer];
                             [RadarState setLastFailedStoppedLocation:nil];
                             [Radar flushLogs];

RadarSDK/RadarGeofence.m

@@ -228,7 +228,7 @@ - (NSDictionary *)dictionaryValue {
         RadarCircleGeometry *circleGeometry = (RadarCircleGeometry *)self.geometry;
         [dict setValue:@(circleGeometry.radius) forKey:@"geometryRadius"];
         [dict setValue:[circleGeometry.center dictionaryValue] forKey:@"geometryCenter"];
-        [dict setValue:@"Circle" forKey:@"type"];
+        [dict setValue:@"circle" forKey:@"type"];
     } else if ([self.geometry isKindOfClass:[RadarPolygonGeometry class]]) {
         RadarPolygonGeometry *polygonGeometry = (RadarPolygonGeometry *)self.geometry;
         [dict setValue:@(polygonGeometry.radius) forKey:@"geometryRadius"];
@@ -237,7 +237,7 @@ - (NSDictionary *)dictionaryValue {
             // Nest coordinate array; Per GeoJSON spec: for type "Polygon", the "coordinates" member must be an array of LinearRing coordinate arrays.
             [dict setValue:@[[RadarGeofence arrayForGeometryCoordinates:polygonGeometry._coordinates]] forKey:@"coordinates"];
         }
-        [dict setValue:@"Polygon" forKey:@"type"];
+        [dict setValue:@"polygon" forKey:@"type"];
     }
 
     return dict;

RadarSDK/RadarLocationManager.m

@@ -519,6 +519,8 @@ - (void)replaceSyncedGeofences:(NSArray<RadarGeofence *> *)geofences {
         return;
     }
 
+    [RadarState setNearbyGeofences:geofences];
+
     RadarTrackingOptions *options = [Radar getTrackingOptions];
     NSUInteger numGeofences = MIN(geofences.count, options.beacons ? 9 : 19);
     NSMutableArray *requests = [NSMutableArray array]; 
@@ -585,10 +587,11 @@ - (void)replaceSyncedGeofences:(NSArray<RadarGeofence *> *)geofences {
             }
         }
     }
-
-    [RadarNotificationHelper removePendingNotificationsWithCompletionHandler: ^{
-        [RadarNotificationHelper addOnPremiseNotificationRequests:requests];
-    }];
+    if (NSClassFromString(@"XCTestCase") == nil) {
+        [RadarNotificationHelper removePendingNotificationsWithCompletionHandler: ^{
+            [RadarNotificationHelper addOnPremiseNotificationRequests:requests];
+        }];
+    }
 }
 
 - (void)removeSyncedGeofences {
@@ -889,8 +892,15 @@ - (void)sendLocation:(CLLocation *)location stopped:(BOOL)stopped source:(RadarL
                                              completionHandler:^(RadarStatus status, NSDictionary *_Nullable res, NSArray<RadarEvent *> *_Nullable events, RadarUser *_Nullable user,
                                                                  NSArray<RadarGeofence *> *_Nullable nearbyGeofences, RadarConfig *_Nullable config, RadarVerifiedLocationToken *_Nullable token) {
                 self.sending = NO;
-
-                [self updateTrackingFromMeta:config.meta];
+
+                if (config != nil) {
+                    [self updateTrackingFromMeta:config.meta];
+                }
+
+                if (status != RadarStatusSuccess || !config) {
+                    return;
+                }
+
                 [self replaceSyncedGeofences:nearbyGeofences];
             }];
         };
@@ -970,13 +980,16 @@ - (void)sendLocation:(CLLocation *)location stopped:(BOOL)stopped source:(RadarL
                                                    beacons:beacons
                                          completionHandler:^(RadarStatus status, NSDictionary *_Nullable res, NSArray<RadarEvent *> *_Nullable events, RadarUser *_Nullable user,
                                                              NSArray<RadarGeofence *> *_Nullable nearbyGeofences, RadarConfig *_Nullable config, RadarVerifiedLocationToken *_Nullable token) {
-                                             self.sending = NO;
-                                             if (status != RadarStatusSuccess || !config) {
-                                                 return;
-                                             }
+                                            self.sending = NO;
+
+                                            if (config != nil) {
+                                                [self updateTrackingFromMeta:config.meta];
+                                            }
+                                            if (status != RadarStatusSuccess || !config) {
+                                                return;
+                                            }
 
-                                             [self updateTrackingFromMeta:config.meta];
-                                             [self replaceSyncedGeofences:nearbyGeofences];
+                                            [self replaceSyncedGeofences:nearbyGeofences];
                                          }];
     }
 }

RadarSDK/RadarOfflineManager.h

@@ -0,0 +1,20 @@
+//
+//  Header.h
+//  RadarSDK
+//
+//  Created by Kenny Hu on 10/16/24.
+//  Copyright © 2024 Radar Labs, Inc. All rights reserved.
+//
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+#import "RadarConfig.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RadarOfflineManager : NSObject
+
++ (void)contextualizeLocation:(CLLocation *)location completionHandler:(void (^)(RadarConfig *))completionHandler;
+
+@end
+
+NS_ASSUME_NONNULL_END

RadarSDK/RadarOfflineManager.swift

@@ -0,0 +1,81 @@
+//
+//  File.swift
+//  RadarSDK
+//
+//  Created by Kenny Hu on 10/16/24.
+//  Copyright © 2024 Radar Labs, Inc. All rights reserved.
+//
+
+import Foundation
+import CoreLocation
+
+@objc(RadarOfflineManager) class RadarOfflineManager: NSObject {
+    @objc public static func contextualizeLocation(_ location: CLLocation, completionHandler: @escaping (RadarConfig?) -> Void) {
+        var newGeofenceIds = [String]()
+        var newGeofenceTags = [String]()
+        // get all the nearby geofences
+        let nearbyGeofences = RadarState.nearbyGeofences()
+        if (nearbyGeofences == nil) {
+            return completionHandler(nil)
+        }
+        // for each of the nearby geofences, check if the location is inside the geofence
+        for geofence in nearbyGeofences! {
+            var center: RadarCoordinate?
+            var radius: Double = 100
+
+            if let geometry = geofence.geometry as? RadarCircleGeometry {
+                center = geometry.center
+                radius = geometry.radius
+            } else if let geometry = geofence.geometry as? RadarPolygonGeometry {
+                center = geometry.center
+                radius = geometry.radius
+            } else {
+                // something went wrong with the geofence geometry
+                continue
+            }
+            if (isPointInsideCircle(center: center!.coordinate, radius: radius, point: location)) {
+                newGeofenceIds.append(geofence._id)
+                if (geofence.tag != nil) {
+                    newGeofenceTags.append(geofence.tag!)
+                }
+            }    
+        }
+        RadarState.setGeofenceIds(newGeofenceIds)
+        // if there are no rampup geofence tags, we never had ramped up so we do not need to ramp down (reason a little more about this)
+        let rampUpGeofenceTagsOptional = RadarSettings.sdkConfiguration()?.inGeofenceTrackingOptionsTags
+        if let rampUpGeofenceTags = rampUpGeofenceTagsOptional {
+            let inRampedUpGeofence = !Set(rampUpGeofenceTags).isDisjoint(with: Set(newGeofenceTags))
+            let sdkConfig = RadarSettings.sdkConfiguration()
+            var newTrackingOptions: RadarTrackingOptions? = nil
+
+            if inRampedUpGeofence {
+                // ramp up
+                newTrackingOptions = sdkConfig?.inGeofenceTrackingOptions
+            } else {
+                // ramp down if needed
+                if let onTripOptions = sdkConfig?.onTripTrackingOptions,
+                   let _ = Radar.getTripOptions() {
+                    newTrackingOptions = onTripOptions
+                } else {
+                    newTrackingOptions = sdkConfig?.defaultTrackingOptions
+                }
+            }
+            if (newTrackingOptions != nil) {
+                let metaDict: [String: Any] = ["trackingOptions": newTrackingOptions?.dictionaryValue() as Any]
+                let configDict: [String: Any] = ["meta": metaDict]
+                if let radarConfig = RadarConfig.fromDictionary(configDict) {
+                        completionHandler(radarConfig)
+                }
+            }
+        }
+        return completionHandler(nil)
+    }
+
+    private static func isPointInsideCircle(center: CLLocationCoordinate2D, radius: Double, point: CLLocation) -> Bool {
+        let centerLocation = CLLocation(latitude: center.latitude, longitude: center.longitude)
+
+        let distance = centerLocation.distance(from: point)
+
+        return distance <= radius
+    }
+}

RadarSDK/RadarSDK.h

@@ -37,3 +37,6 @@ FOUNDATION_EXPORT const unsigned char RadarSDKVersionString[];
 #import "RadarUser.h"
 #import "RadarVerifiedDelegate.h"
 #import "RadarMotionProtocol.h"
+#import "RadarConfig.h"
+#import "RadarState.h"
+#import "RadarSettings.h"

RadarSDK/RadarSDKTests-Bridging-Header.h

@@ -0,0 +1,4 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+

RadarSDK/RadarSdkConfiguration.h

@@ -34,6 +34,14 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, assign) BOOL useLocationMetadata;
 
 @property (nonatomic, assign) BOOL useOpenedAppConversion;
+
+@property (nonatomic, copy, nullable) RadarTrackingOptions *inGeofenceTrackingOptions;
+
+@property (nonatomic, copy, nullable) RadarTrackingOptions *defaultTrackingOptions;
+
+@property (nonatomic, copy, nullable) RadarTrackingOptions *onTripTrackingOptions;
+
+@property (nonatomic, copy, nullable) NSArray<NSString *> *inGeofenceTrackingOptionsTags;
 /**
  Initializes a new RadarSdkConfiguration object with given value.
  */

RadarSDK/RadarSdkConfiguration.m

@@ -74,6 +74,38 @@ - (instancetype)initWithDict:(NSDictionary *)dict {
     if (useOpenedAppConversion && [useOpenedAppConversion isKindOfClass:[NSNumber class]]) {
         _useOpenedAppConversion = [(NSNumber *)useOpenedAppConversion boolValue];
     }
+    NSObject *inGeofenceTrackingOptionsObj = dict[@"inGeofenceTrackingOptions"];
+    _inGeofenceTrackingOptions = nil;
+    if (inGeofenceTrackingOptionsObj && [inGeofenceTrackingOptionsObj isKindOfClass:[NSDictionary class]]) {
+        RadarTrackingOptions *radarTrackingOptions = [RadarTrackingOptions trackingOptionsFromObject:inGeofenceTrackingOptionsObj];
+        if (radarTrackingOptions) {
+            _inGeofenceTrackingOptions = radarTrackingOptions;
+        }
+    }
+
+    NSObject *defaultTrackingOptionsObj = dict[@"defaultTrackingOptions"];
+    _defaultTrackingOptions = nil;
+    if (defaultTrackingOptionsObj && [defaultTrackingOptionsObj isKindOfClass:[NSDictionary class]]) {
+        RadarTrackingOptions *radarTrackingOptions = [RadarTrackingOptions trackingOptionsFromObject:defaultTrackingOptionsObj];
+        if (radarTrackingOptions) {
+            _defaultTrackingOptions = radarTrackingOptions;
+        }
+    } 
+
+    NSObject *onTripTrackingOptionsObj = dict[@"onTripTrackingOptions"];
+    _onTripTrackingOptions = nil;
+    if (onTripTrackingOptionsObj && [onTripTrackingOptionsObj isKindOfClass:[NSDictionary class]]) {
+        RadarTrackingOptions *radarTrackingOptions = [RadarTrackingOptions trackingOptionsFromObject:onTripTrackingOptionsObj];
+        if (radarTrackingOptions) {
+            _onTripTrackingOptions = radarTrackingOptions;
+        }
+    } 
+
+    NSObject *inGeofenceTrackingOptionsTagsObj = dict[@"inGeofenceTrackingOptionsTags"];
+    _inGeofenceTrackingOptionsTags = nil;
+    if (inGeofenceTrackingOptionsTagsObj && [inGeofenceTrackingOptionsTagsObj isKindOfClass:[NSArray class]]) {
+        _inGeofenceTrackingOptionsTags = (NSArray *)inGeofenceTrackingOptionsTagsObj;
+    }
 
     return self;
 }
@@ -90,7 +122,10 @@ - (NSDictionary *)dictionaryValue {
     dict[@"useRadarModifiedBeacon"] = @(_useRadarModifiedBeacon);
     dict[@"useLocationMetadata"] = @(_useLocationMetadata);
     dict[@"useOpenedAppConversion"] = @(_useOpenedAppConversion);
-
+    dict[@"inGeofenceTrackingOptions"] = [_inGeofenceTrackingOptions dictionaryValue];
+    dict[@"defaultTrackingOptions"] = [_defaultTrackingOptions dictionaryValue];
+    dict[@"onTripTrackingOptions"] = [_onTripTrackingOptions dictionaryValue];
+    dict[@"inGeofenceTrackingOptionsTags"] = _inGeofenceTrackingOptionsTags;
     return dict;
 }
 

RadarSDK/RadarSettings.m

@@ -33,6 +33,7 @@ @implementation RadarSettings
 static NSString *const kTrackingOptions = @"radar-trackingOptions";
 static NSString *const kPreviousTrackingOptions = @"radar-previousTrackingOptions";
 static NSString *const kRemoteTrackingOptions = @"radar-remoteTrackingOptions";
+static NSString *const kPreviousRemoteTrackingOptions = @"radar-previousRemoteTrackingOptions";
 static NSString *const kClientSdkConfiguration = @"radar-clientSdkConfiguration";
 static NSString *const kSdkConfiguration = @"radar-sdkConfiguration";
 static NSString *const kTripOptions = @"radar-tripOptions";
@@ -276,6 +277,7 @@ + (void)setBeaconUUIDs:(NSArray<NSString *> *_Nullable)beaconUUIDs {
 }
 
 + (NSString *)host {
+    //return @"https://api-kenny.radar-staging.com";
     NSString *host = [[NSUserDefaults standardUserDefaults] stringForKey:kHost];
     return host ? host : kDefaultHost;
 }

RadarSDK/RadarState.h

@@ -7,6 +7,7 @@
 
 #import <CoreLocation/CoreLocation.h>
 #import <Foundation/Foundation.h>
+#import "RadarGeofence.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -26,8 +27,8 @@ NS_ASSUME_NONNULL_BEGIN
 + (void)setCanExit:(BOOL)canExit;
 + (CLLocation *)lastFailedStoppedLocation;
 + (void)setLastFailedStoppedLocation:(CLLocation *_Nullable)lastFailedStoppedLocation;
-+ (NSArray<NSString *> *)geofenceIds;
-+ (void)setGeofenceIds:(NSArray<NSString *> *_Nullable)geofenceIds;
++ (NSArray<NSString *> *)geofenceIds NS_SWIFT_NAME(geofenceIds());
++ (void)setGeofenceIds:(NSArray<NSString *> *_Nullable)geofenceIds NS_SWIFT_NAME(setGeofenceIds(_:));
 + (NSArray<NSString *> *)placeId;
 + (void)setPlaceId:(NSString *_Nullable)placeId;
 + (NSArray<NSString *> *)regionIds;
@@ -40,6 +41,8 @@ NS_ASSUME_NONNULL_BEGIN
 + (void)setLastMotionActivityData:(NSDictionary *_Nullable)lastMotionActivityData;
 + (void)setNotificationPermissionGranted:(BOOL)granted;
 + (BOOL)notificationPermissionGranted;
++ (void)setNearbyGeofences:(NSArray<RadarGeofence *> *_Nullable)nearbyGeofences NS_SWIFT_NAME(setNearbyGeofences(_:));
++ (NSArray<RadarGeofence *> *_Nullable)nearbyGeofences NS_SWIFT_NAME(nearbyGeofences());
 
 @end