@josuelmm/capacitor-background-geolocation 1.0.0

package/ios/common/BackgroundGeolocation/MAURLocationManager.h

@@ -0,0 +1,53 @@
+//
+//  MAURLocationManager.h
+//
+//  Created by Jinru on 12/19/09.
+//  Copyright 2009 Arizona State University. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+#import <CoreLocation/CoreLocation.h>
+#import "MAURProviderDelegate.h"
+
+// protocol for sending location updates to another view controller
+@protocol MAURLocationManagerDelegate
+@required
+- (void) onAuthorizationChanged:(MAURLocationAuthorizationStatus)authStatus;
+- (void) onLocationsChanged:(NSArray*)locations;
+- (void) onError:(NSError*)error;
+- (void) onLocationPause:(CLLocationManager*)manager;
+- (void) onLocationResume:(CLLocationManager*)manager;
+- (void) onRegionExit:(CLRegion*)region;
+@end
+
+@interface MAURLocationManager : NSObject <CLLocationManagerDelegate>  {
+    
+    CLLocationManager* locationManager;
+    __weak id delegate;
+}
+
+@property (nonatomic, strong) CLLocationManager* locationManager;
+@property (nonatomic, weak) id  delegate;
+
+- (BOOL) start:(NSError * __autoreleasing *)outError;
+- (BOOL) stop:(NSError * __autoreleasing *)outError;
+- (BOOL) startMonitoringSignificantLocationChanges;
+- (BOOL) stopMonitoringSignificantLocationChanges;
+- (void) startMonitoringForRegion:(CLRegion*)region;
+- (void) stopMonitoringForRegion:(CLRegion*)region;
+- (void) stopMonitoringForRegionIdentifier:(NSString*)identifier;
+- (void) stopMonitoringAllRegions;
+- (NSSet<__kindof CLRegion *>*) monitoredRegions;
+- (void) setShowsBackgroundLocationIndicator:(BOOL)shows;
+- (void) setPausesLocationUpdatesAutomatically:(BOOL)newPausesLocationsUpdatesAutomatically;
+- (BOOL) pausesLocationUpdatesAutomatically;
+- (void) setDistanceFilter:(CLLocationDistance)newDistanceFiler;
+- (CLLocationDistance) distanceFilter;
+- (void) setActivityType:(CLActivityType)newActivityType;
+- (CLActivityType) activityType;
+- (void) setDesiredAccuracy:(CLLocationAccuracy)newDesiredAccuracy;
+- (CLLocationAccuracy) desiredAccuracy;
+
++ (MAURLocationManager*)sharedInstance; // Singleton method
+
+@end

package/ios/common/BackgroundGeolocation/MAURLocationManager.m

@@ -0,0 +1,305 @@
+//
+//  MAURLocationManager.m
+//
+//  Created by Jinru on 12/19/09.
+//  Copyright 2009 Arizona State University. All rights reserved.
+//
+
+#import "MAURLocation.h"
+#import "MAURLocationManager.h"
+
+#define SYSTEM_VERSION_EQUAL_TO(v)                  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedSame)
+#define SYSTEM_VERSION_GREATER_THAN(v)              ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedDescending)
+#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)
+#define SYSTEM_VERSION_LESS_THAN(v)                 ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)
+#define SYSTEM_VERSION_LESS_THAN_OR_EQUAL_TO(v)     ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedDescending)
+
+#define LOCATION_DENIED         "User denied use of location services."
+#define LOCATION_RESTRICTED     "Application's use of location services is restricted."
+#define LOCATION_NOT_DETERMINED "User undecided on application's use of location services."
+
+static MAURLocationManager* sharedCLDelegate = nil;
+static NSString *const TAG = @"MAURLocationManager";
+static NSString *const Domain = @"com.marianhello";
+
+@implementation MAURLocationManager
+@synthesize locationManager, delegate;
+
+- (id)init
+{
+    self = [super init];
+    if (self != nil) {
+        locationManager = [[CLLocationManager alloc] init];
+
+        if (SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"9.0")) {
+            locationManager.allowsBackgroundLocationUpdates = YES;
+        }
+
+        locationManager.delegate = self;
+        locationManager.desiredAccuracy = kCLLocationAccuracyBest;
+    }
+    return self;
+}
+
+- (BOOL) start:(NSError * __autoreleasing *)outError
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+
+    NSUInteger authStatus;
+    
+    if ([CLLocationManager respondsToSelector:@selector(authorizationStatus)]) { // iOS 4.2+
+        authStatus = [CLLocationManager authorizationStatus];
+        
+        if (authStatus == kCLAuthorizationStatusDenied) {
+            if (outError != NULL) {
+                NSDictionary *errorDictionary = @{
+                                                  NSLocalizedDescriptionKey: NSLocalizedString(@LOCATION_DENIED, nil)
+                                                  };
+
+                *outError = [NSError errorWithDomain:Domain code:MAURBGPermissionDenied userInfo:errorDictionary];
+            }
+            
+            return NO;
+        }
+        
+        if (authStatus == kCLAuthorizationStatusRestricted) {
+            if (outError != NULL) {
+                NSDictionary *errorDictionary = @{
+                                                  NSLocalizedDescriptionKey: NSLocalizedString(@LOCATION_RESTRICTED, nil)
+                                                  };
+                *outError = [NSError errorWithDomain:Domain code:MAURBGPermissionDenied userInfo:errorDictionary];
+            }
+            
+            return NO;
+        }
+        
+#ifdef __IPHONE_8_0
+        // we do startUpdatingLocation even though we might not get permissions granted
+        // we can stop later on when recieved callback on user denial
+        // it's neccessary to start call startUpdatingLocation in iOS < 8.0 to show user prompt!
+        
+        if (authStatus == kCLAuthorizationStatusNotDetermined) {
+            if ([locationManager respondsToSelector:@selector(requestAlwaysAuthorization)]) {  //iOS 8.0+
+                [locationManager requestAlwaysAuthorization];
+            }
+        }
+#endif
+    }
+    
+    [locationManager startUpdatingLocation];
+    return YES;
+}
+
+- (BOOL) stop:(NSError * __autoreleasing *)outError
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+    [locationManager stopUpdatingLocation];
+    return YES;
+}
+
+- (BOOL) startMonitoringSignificantLocationChanges
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+    [locationManager startMonitoringSignificantLocationChanges];
+    return YES;
+}
+
+- (BOOL) stopMonitoringSignificantLocationChanges
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+    [locationManager stopMonitoringSignificantLocationChanges];
+    return YES;
+}
+
+- (void) startMonitoringForRegion:(CLRegion*)region
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+    [locationManager startMonitoringForRegion:region];
+}
+
+- (void) stopMonitoringForRegion:(CLRegion*)region
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+    [locationManager stopMonitoringForRegion:region];
+}
+
+- (void) stopMonitoringForRegionIdentifier:(NSString*)identifier
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+    for (CLRegion *region in [locationManager monitoredRegions]){
+        if([region.identifier isEqualToString:identifier]){
+            [locationManager stopMonitoringForRegion:region];
+        }
+    }
+}
+
+- (void) stopMonitoringAllRegions
+{
+    NSAssert([NSThread isMainThread], @"%@ %@", TAG, @"should only be called from the main thread.");
+    for (CLRegion *region in [locationManager monitoredRegions]) {
+        [locationManager stopMonitoringForRegion:region];
+    }
+}
+
+- (NSSet<__kindof CLRegion *>*) monitoredRegions
+{
+    return locationManager.monitoredRegions;
+}
+
+- (void) setShowsBackgroundLocationIndicator:(BOOL)shows
+{
+    if (@available(iOS 11, *)) {
+        locationManager.showsBackgroundLocationIndicator = shows;
+    }
+}
+
+- (void) setPausesLocationUpdatesAutomatically:(BOOL)newPausesLocationsUpdatesAutomatically
+{
+    locationManager.pausesLocationUpdatesAutomatically = newPausesLocationsUpdatesAutomatically;
+}
+
+- (BOOL) pausesLocationUpdatesAutomatically
+{
+    return locationManager.pausesLocationUpdatesAutomatically;
+}
+
+- (void) setDistanceFilter:(CLLocationDistance)newDistanceFiler
+{
+    locationManager.distanceFilter = newDistanceFiler;
+}
+
+- (CLLocationDistance) distanceFilter
+{
+    return locationManager.distanceFilter;
+}
+
+- (void) setActivityType:(CLActivityType)newActivityType
+{
+    locationManager.activityType = newActivityType;
+}
+
+- (CLActivityType) activityType
+{
+    return locationManager.activityType;
+}
+
+- (void) setDesiredAccuracy:(CLLocationAccuracy)newDesiredAccuracy
+{
+    locationManager.desiredAccuracy = newDesiredAccuracy;
+}
+
+- (CLLocationAccuracy) desiredAccuracy
+{
+    return locationManager.desiredAccuracy;
+}
+
+
+#pragma mark -
+#pragma mark CLLocationManagerDelegate Methods
+- (void) locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray *)locations
+{
+    [self.delegate onLocationsChanged:locations];
+}
+
+- (void) locationManager:(CLLocationManager *)manager didFailWithError:(NSError *)error
+{
+    if (self.delegate && [self.delegate respondsToSelector:@selector(onError:)]) {
+        NSDictionary *errorDictionary = @{
+                                          NSUnderlyingErrorKey : error
+                                          };
+        NSError *outError = [NSError errorWithDomain:Domain code:MAURBGServiceError userInfo:errorDictionary];
+
+        [self.delegate onError:outError];
+    }
+}
+
+// v4.5.2: iOS 14+ delegate callback. The legacy
+// `locationManager:didChangeAuthorizationStatus:` is deprecated in iOS 14 but
+// still delivered alongside this one, so we ignore the legacy variant when
+// running on iOS 14+ to avoid double-notifying delegates (RAW + ACTIVITY
+// providers go through this MAURLocationManager singleton).
+- (void) locationManagerDidChangeAuthorization:(CLLocationManager *)manager API_AVAILABLE(ios(14.0))
+{
+    [self maurDispatchAuthorizationStatus:manager.authorizationStatus];
+}
+
+- (void) locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status
+{
+    if (@available(iOS 14.0, *)) {
+        return; // delivered by locationManagerDidChangeAuthorization: above
+    }
+    [self maurDispatchAuthorizationStatus:status];
+}
+
+- (void) maurDispatchAuthorizationStatus:(CLAuthorizationStatus)status
+{
+    MAURLocationAuthorizationStatus authStatus;
+
+    switch(status) {
+        case kCLAuthorizationStatusRestricted:
+        case kCLAuthorizationStatusDenied:
+            authStatus = MAURLocationAuthorizationDenied;
+            break;
+        case kCLAuthorizationStatusAuthorizedAlways:
+            authStatus = MAURLocationAuthorizationAlways;
+            break;
+        case kCLAuthorizationStatusAuthorizedWhenInUse:
+            authStatus = MAURLocationAuthorizationForeground;
+            break;
+        default:
+            return;
+    }
+
+    if (self.delegate && [self.delegate respondsToSelector:@selector(onAuthorizationChanged:)]) {
+        [self.delegate onAuthorizationChanged:authStatus];
+    }
+}
+
+- (void) locationManagerDidPauseLocationUpdates:(CLLocationManager *)manager
+{
+    if (self.delegate && [self.delegate respondsToSelector:@selector(onLocationPause:)]) {
+        [self.delegate onLocationPause:manager];
+    }
+}
+
+- (void) locationManagerDidResumeLocationUpdates:(CLLocationManager *)manager
+{
+    if (self.delegate && [self.delegate respondsToSelector:@selector(onLocationResume:)]) {
+        [self.delegate onLocationResume:manager];
+    }
+}
+
+- (void) locationManager:(CLLocationManager *)manager didExitRegion:(CLRegion *)region
+{
+    if (self.delegate && [self.delegate respondsToSelector:@selector(onRegionExit:)]) {
+        [self.delegate onRegionExit:region];
+    }
+}
+
+#pragma mark - Singleton implementation in ARC
++ (MAURLocationManager *)sharedInstance
+{
+    static MAURLocationManager *sharedLocationControllerInstance = nil;
+    static dispatch_once_t predicate;
+    dispatch_once(&predicate, ^{
+        sharedLocationControllerInstance = [[self alloc] init];
+    });
+    return sharedLocationControllerInstance;
+}
+
++ (id)allocWithZone:(NSZone *)zone {
+    @synchronized(self) {
+        if (sharedCLDelegate == nil) {
+            sharedCLDelegate = [super allocWithZone:zone];
+            return sharedCLDelegate;  // assignment and return on first allocation
+        }
+    }
+    return nil; // on subsequent allocation attempts return nil
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+    return self;
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURLogReader.h

@@ -0,0 +1,26 @@
+//
+//  MAURLogReader.h
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 02/07/16.
+//  Copyright © 2016 mauron85. All rights reserved.
+//
+
+#ifndef MAURLogReader_h
+#define MAURLogReader_h
+
+#import "MAURLogging.h"
+
+@interface MAURLogReader : NSObject {
+@private
+    NSString *logDirectory;
+}
+
+- (id)initWithLogDirectory:(NSString *)aLogDirectory;
+- (NSString*) prepareSQL:(NSInteger)limit fromLogEntryId:(NSInteger)entryId minLogLevel:(NSInteger)minLogLevel;
+- (NSArray*) getEntries:(NSInteger)limit fromLogEntryId:(NSInteger)entryId minLogLevel:(DDLogFlag)minLogLevel;
+- (NSArray*) getLogEntries:(NSInteger)limit fromLogEntryId:(NSInteger)offset minLogLevelAsString:(NSString *)minLogLevel;
+
+@end
+
+#endif /* MAURLogReader_h */

package/ios/common/BackgroundGeolocation/MAURLogReader.m

@@ -0,0 +1,122 @@
+//
+//  MAURLogReader.m
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 02/07/16.
+//  Copyright © 2016 mauron85. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <sqlite3.h>
+#import "FMDB.h"
+#import "ZIMSqlSelectStatement.h"
+#import "MAURLogReader.h"
+
+// Convert DDLogFlag to string
+static NSString* logFlag_toString(DDLogFlag logFlag)
+{
+    switch (logFlag) {
+        case DDLogFlagVerbose:
+            return @"TRACE";
+        case DDLogFlagDebug:
+            return @"DEBUG";
+        case DDLogFlagInfo:
+            return @"INFO";
+        case DDLogFlagWarning:
+            return @"WARN";
+        case DDLogFlagError:
+            return @"ERROR";
+    }
+    return @"N/A";
+}
+
+static DDLogFlag string_toLogFlag(NSString *logFlag)
+{
+    if ([@"TRACE" isEqualToString:logFlag]) {
+        return DDLogFlagVerbose;
+    }
+    if ([@"DEBUG" isEqualToString:logFlag]) {
+        return DDLogFlagDebug;
+    }
+    if ([@"INFO" isEqualToString:logFlag]) {
+        return DDLogFlagInfo;
+    }
+    if ([@"WARN" isEqualToString:logFlag]) {
+        return DDLogFlagWarning;
+    }
+    if ([@"ERROR" isEqualToString:logFlag]) {
+        return DDLogFlagError;
+    }
+    
+    return DDLogFlagVerbose; // maybe we should throw exception instead
+}
+
+@implementation MAURLogReader : NSObject
+
+- (id)initWithLogDirectory:(NSString *)aLogDirectory
+{
+    if ((self = [super init]))
+    {
+        logDirectory = [aLogDirectory copy];
+    }
+    
+    return self;
+}
+
+- (NSString*) prepareSQL:(NSInteger)limit fromLogEntryId:(NSInteger)entryId minLogLevel:(NSInteger)minLogLevel
+{
+    ZIMSqlSelectStatement *sql = [[ZIMSqlSelectStatement alloc] init];
+    [sql column: @"rowid"];
+    [sql column: @"context"];
+    [sql column: @"level"];
+    [sql column: @"message"];
+    [sql column: @"timestamp"];
+    [sql from: @"logs"];
+    [sql where: @"level" operator: ZIMSqlOperatorLessThanOrEqualTo value: [NSNumber numberWithInteger:minLogLevel]];
+    if (entryId > 0) {
+        if (limit >= 0) {
+            [sql where: @"rowid" operator: ZIMSqlOperatorLessThan value: [NSNumber numberWithInteger:entryId]];
+        } else {
+            [sql where: @"rowid" operator: ZIMSqlOperatorGreaterThan value: [NSNumber numberWithInteger:entryId]];
+        }
+    }
+    [sql orderBy: @"timestamp" descending:limit >= 0];
+    [sql orderBy: @"rowid" descending:limit >= 0];
+    [sql limit: ABS(limit)];
+    
+    return [sql statement];
+}
+
+- (NSArray*) getLogEntries:(NSInteger)limit fromLogEntryId:(NSInteger)entryId minLogLevelAsString:(NSString *)minLogLevel;
+{
+    return [self getEntries:limit fromLogEntryId:entryId minLogLevel:string_toLogFlag(minLogLevel)];
+}
+
+- (NSArray*) getEntries:(NSInteger)limit fromLogEntryId:(NSInteger)entryId minLogLevel:(DDLogFlag)minLogLevel;
+{
+    NSMutableArray *logs = [[NSMutableArray alloc] init];
+    NSString *dbPath = [logDirectory stringByAppendingPathComponent:@"log.sqlite"];
+    FMDatabase *database = [[FMDatabase alloc] initWithPath:dbPath];
+    if (![database openWithFlags:SQLITE_OPEN_READONLY]) {
+        NSLog(@"%@: Failed opening database!", [self class]);
+        database = nil;
+        return nil;
+    }
+    
+    FMResultSet *rs = [database executeQuery:[self prepareSQL:limit fromLogEntryId:entryId minLogLevel:minLogLevel]];
+    while([rs next]) {
+        NSMutableDictionary *entry = [NSMutableDictionary dictionaryWithCapacity:4];
+        [entry setObject:[NSNumber numberWithInt:[rs intForColumnIndex:0]] forKey:@"id"];
+        [entry setObject:[NSNumber numberWithInt:[rs intForColumnIndex:1]] forKey:@"context"];
+        [entry setObject:logFlag_toString([rs intForColumnIndex:2]) forKey:@"level"];
+        [entry setObject:[rs stringForColumnIndex:3] forKey:@"message"];
+        [entry setObject:[NSNumber numberWithDouble:[rs doubleForColumnIndex:4] * 1000] forKey:@"timestamp"];
+        [logs addObject:entry];
+    }
+    [rs close];
+    [database close];
+    
+    return logs;
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURLogging.h

@@ -0,0 +1,19 @@
+//
+//  MAURLogging.h
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 10/11/2017.
+//  Copyright © 2017 mauron85. All rights reserved.
+//
+
+#ifndef MAURLogging_h
+#define MAURLogging_h
+
+#define LOG_LEVEL_DEF ddLogLevel
+#import "CocoaLumberjack.h"
+
+// we will override this global level later
+// https://github.com/CocoaLumberjack/CocoaLumberjack/issues/469
+static const DDLogLevel ddLogLevel = DDLogLevelAll;
+
+#endif /* MAURLogging_h */

package/ios/common/BackgroundGeolocation/MAURPostLocationTask.h

@@ -0,0 +1,53 @@
+//
+//  MAURPostLocationTask.h
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 27/04/2018.
+//  Copyright © 2018 mauron85. All rights reserved.
+//
+
+#ifndef MAURPostLocationTask_h
+#define MAURPostLocationTask_h
+
+#import "MAURConfig.h"
+#import "MAURLocation.h"
+
+@class MAURPostLocationTask;
+
+@protocol MAURPostLocationTaskDelegate <NSObject>
+
+@optional
+- (void)postLocationTaskRequestedAbortUpdates:(MAURPostLocationTask * _Nonnull)task;
+- (void)postLocationTaskHttpAuthorizationUpdates:(MAURPostLocationTask * _Nonnull)task;
+// v3.5 Phase 4
+- (void)postLocationTaskSyncStarted:(MAURPostLocationTask * _Nonnull)task;
+- (void)postLocationTaskSyncSucceeded:(MAURPostLocationTask * _Nonnull)task locationsSent:(NSInteger)locationsSent;
+- (void)postLocationTaskSyncFailed:(MAURPostLocationTask * _Nonnull)task httpStatus:(NSInteger)httpStatus message:(NSString * _Nullable)message;
+
+@end
+
+@interface MAURPostLocationTask : NSObject
+
+@property (nonatomic, weak) MAURConfig * _Nullable config;
+@property (nonatomic, weak) id<MAURPostLocationTaskDelegate> _Nullable delegate;
+/** v4.5.1 — pending driving events buffer owned by the facade; the task drains it onto the
+ *  post-transform location so events fired without a simultaneous fix (provider change,
+ *  sensor crash, phone usage) survive even if `locationTransform` returns a new instance.
+ *  Weak ref: if the facade is gone, no flush — by design. */
+@property (nonatomic, weak) NSMutableArray * _Nullable pendingDrivingEventsBuffer;
+/** v4.5.1 — same idea for the battery snapshot block. The facade installs a block that the
+ *  task invokes AFTER a successful transform, so even when `locationTransform` returns a
+ *  fresh instance, battery/charging fields land on what actually gets POSTed. */
+@property (nonatomic, copy) void (^ _Nullable attachBatterySnapshot)(MAURLocation * _Nonnull);
+
+- (void) add:(MAURLocation * _Nonnull)location;
+- (void) start;
+- (void) stop;
+- (void) sync;
+
++ (void) setLocationTransform:(MAURLocationTransform _Nullable)transform;
++ (MAURLocationTransform _Nullable) locationTransform;
+
+@end
+
+#endif /* MAURPostLocationTask_h */