react-native-nitro-background-geolocation 0.1.0

package/ios/common/BackgroundGeolocation/MAURDistanceFilterLocationProvider.m

@@ -0,0 +1,523 @@
+//
+//  MAURDistanceFilterLocationProvider.m
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 14/09/2016.
+//  Copyright © 2016 mauron85. All rights reserved.
+//
+
+#import "MAURDistanceFilterLocationProvider.h"
+#import "MAURLogging.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 NSString * const TAG = @"DistanceFilterLocationProvider";
+static NSString * const Domain = @"com.marianhello";
+
+static BOOL MAURShouldIgnoreLocationManagerError(NSError *error)
+{
+    switch (error.code) {
+        case kCLErrorLocationUnknown:
+        case kCLErrorNetwork:
+        case kCLErrorRegionMonitoringDenied:
+        case kCLErrorRegionMonitoringSetupDelayed:
+        case kCLErrorRegionMonitoringResponseDelayed:
+        case kCLErrorGeocodeFoundNoResult:
+        case kCLErrorGeocodeFoundPartialResult:
+        case kCLErrorGeocodeCanceled:
+            return YES;
+        default:
+            return NO;
+    }
+}
+
+
+enum {
+    maxLocationWaitTimeInSeconds = 15,
+    maxLocationAgeInSeconds = 30
+};
+
+@interface MAURDistanceFilterLocationProvider () <CLLocationManagerDelegate>
+@end
+
+@implementation MAURDistanceFilterLocationProvider {
+    BOOL isUpdatingLocation;
+    BOOL isAcquiringStationaryLocation;
+    BOOL isAcquiringSpeed;
+    BOOL isStarted;
+    
+    CLCircularRegion *stationaryRegion;
+    NSDate *stationarySince;
+
+    MAUROperationalMode operationMode;
+    NSDate *aquireStartTime;
+    
+    CLLocationManager *locationManager;
+
+    // configurable options
+    MAURConfig *_config;
+}
+
+
+- (instancetype) init
+{
+    self = [super init];
+    
+    if (self) {
+        isUpdatingLocation = NO;
+        isAcquiringStationaryLocation = NO;
+        isAcquiringSpeed = NO;
+        stationaryRegion = nil;
+        isStarted = NO;
+    }
+
+    return self;
+}
+
+- (void) onCreate {
+    locationManager = [[CLLocationManager alloc] init];
+    
+    if (SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"9.0")) {
+        DDLogDebug(@"%@ iOS9 detected", TAG);
+        locationManager.allowsBackgroundLocationUpdates = YES;
+    }
+    
+    locationManager.delegate = self;
+}
+
+/**
+ * configure provider
+ * @param {Config} configuration
+ * @param {NSError} optional error
+ */
+- (BOOL) onConfigure:(MAURConfig*)config error:(NSError * __autoreleasing *)outError
+{
+    DDLogVerbose(@"%@ configure", TAG);
+    _config = config;
+
+    locationManager.pausesLocationUpdatesAutomatically = [_config pauseLocationUpdates];
+    locationManager.activityType = [_config decodeActivityType];
+    locationManager.distanceFilter = _config.distanceFilter.integerValue; // meters
+    locationManager.desiredAccuracy = [_config decodeDesiredAccuracy];
+    
+    return YES;
+}
+
+/**
+ * Turn on background geolocation
+ */
+- (BOOL) onStart:(NSError * __autoreleasing *)outError
+{
+    DDLogInfo(@"%@ will start", TAG);
+    
+    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+
+                DDLogVerbose(@"%@ requestAlwaysAuthorization", TAG);
+                [locationManager requestAlwaysAuthorization];
+            }
+        }
+#endif
+    }
+    
+    [self switchMode:MAURForegroundMode];
+
+    isStarted = YES;
+
+    return YES;
+}
+
+/**
+ * Turn it off
+ */
+- (BOOL) onStop:(NSError * __autoreleasing *)outError
+{
+    DDLogInfo(@"%@ stop", TAG);
+    
+    [self stopUpdatingLocation];
+    [self stopMonitoringSignificantLocationChanges];
+    [self stopMonitoringForRegion];
+
+    isStarted = NO;
+
+    return YES;
+}
+
+- (void) onSwitchMode:(MAUROperationalMode)mode
+{
+    [self switchMode:mode];
+}
+
+/**
+ * toggle between foreground and background operation mode
+ */
+- (void) switchMode:(MAUROperationalMode)mode
+{
+    DDLogInfo(@"%@ switchMode %lu", TAG, (unsigned long)mode);
+    
+    operationMode = mode;
+    
+    if (operationMode == MAURForegroundMode || !_config.saveBatteryOnBackground) {
+        isAcquiringSpeed = YES;
+        isAcquiringStationaryLocation = NO;
+        [self stopMonitoringForRegion];
+        [self stopMonitoringSignificantLocationChanges];
+    } else if (operationMode == MAURBackgroundMode) {
+        isAcquiringSpeed = NO;
+        isAcquiringStationaryLocation = YES;
+        [self startMonitoringSignificantLocationChanges];
+    }
+    
+    aquireStartTime = [NSDate date];
+    
+    // Crank up the GPS power temporarily to get a good fix on our current location
+    [self stopUpdatingLocation];
+    locationManager.distanceFilter = kCLDistanceFilterNone;
+    locationManager.desiredAccuracy = kCLLocationAccuracyBestForNavigation;
+    [self startUpdatingLocation];
+}
+
+- (void) locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray *)locations
+{
+    DDLogDebug(@"%@ didUpdateLocations (operationMode: %lu)", TAG, (unsigned long)operationMode);
+    
+    MAUROperationalMode actAsInMode = operationMode;
+    
+    if (actAsInMode == MAURBackgroundMode) {
+        if ([_config saveBatteryOnBackground] == NO) actAsInMode = MAURForegroundMode;
+    }
+    
+    if (actAsInMode == MAURForegroundMode) {
+        if (!isUpdatingLocation) [self startUpdatingLocation];
+    }
+    
+    if (actAsInMode == MAURBackgroundMode) {
+        if (!isAcquiringStationaryLocation && !stationaryRegion) {
+            // Perhaps our GPS signal was interupted, re-acquire a stationaryLocation now.
+            [self switchMode:operationMode];
+        }
+    }
+    
+    
+    MAURLocation *bestLocation = nil;
+    for (CLLocation *location in locations) {
+        MAURLocation *bgloc = [MAURLocation fromCLLocation:location];
+        
+        // test the age of the location measurement to determine if the measurement is cached
+        // in most cases you will not want to rely on cached measurements
+        DDLogDebug(@"Location age %f", [bgloc locationAge]);
+        if ([bgloc locationAge] > maxLocationAgeInSeconds || ![bgloc hasAccuracy] || ![bgloc hasTime]) {
+            continue;
+        }
+        
+        if (bestLocation == nil) {
+            bestLocation = bgloc;
+            continue;
+        }
+        
+        if ([bgloc isBetterLocation:bestLocation]) {
+            DDLogInfo(@"Better location found: %@", bgloc);
+            bestLocation = bgloc;
+        }
+    }
+    
+    if (bestLocation == nil) {
+        return;
+    }
+    
+    // test the measurement to see if it is more accurate than the previous measurement
+    if (isAcquiringStationaryLocation) {
+        DDLogDebug(@"%@ acquiring stationary location, accuracy: %@", TAG, bestLocation.accuracy);
+        if ([_config isDebugging]) {
+            AudioServicesPlaySystemSound (acquiringLocationSound);
+        }
+        
+        if ([bestLocation.accuracy doubleValue] <= [_config.desiredAccuracy doubleValue]) {
+            DDLogDebug(@"%@ found most accurate stationary before timeout", TAG);
+        } else if (-[aquireStartTime timeIntervalSinceNow] < maxLocationWaitTimeInSeconds) {
+            // we still have time to aquire better location
+            return;
+        }
+        
+        isAcquiringStationaryLocation = NO;
+        [self stopUpdatingLocation]; //saving power while monitoring region
+        
+        MAURLocation *stationaryLocation = [bestLocation copy];
+        stationaryLocation.radius = _config.stationaryRadius;
+        stationaryLocation.time = stationarySince;
+        [self startMonitoringStationaryRegion:stationaryLocation];
+        // fire onStationary @event for Javascript.
+        [super.delegate onStationaryChanged:stationaryLocation];
+    } else if (isAcquiringSpeed) {
+        if ([_config isDebugging]) {
+            AudioServicesPlaySystemSound (acquiringLocationSound);
+        }
+        
+        if ([bestLocation.accuracy doubleValue] <= [_config.desiredAccuracy doubleValue]) {
+            DDLogDebug(@"%@ found most accurate location before timeout", TAG);
+        } else if (-[aquireStartTime timeIntervalSinceNow] < maxLocationWaitTimeInSeconds) {
+            // we still have time to aquire better location
+            return;
+        }
+        
+        if ([_config isDebugging]) {
+            [self notify:@"Aggressive monitoring engaged"];
+        }
+        
+        // We should have a good sample for speed now, power down our GPS as configured by user.
+        isAcquiringSpeed = NO;
+        locationManager.desiredAccuracy = _config.desiredAccuracy.integerValue;
+        locationManager.distanceFilter = [self calculateDistanceFilter:[bestLocation.speed floatValue]];
+        [self startUpdatingLocation];
+        
+    } else if (actAsInMode == MAURForegroundMode) {
+        // Adjust distanceFilter incrementally based upon current speed
+        float newDistanceFilter = [self calculateDistanceFilter:[bestLocation.speed floatValue]];
+        if (newDistanceFilter != locationManager.distanceFilter) {
+            DDLogInfo(@"%@ updated distanceFilter, new: %f, old: %f", TAG, newDistanceFilter, locationManager.distanceFilter);
+            locationManager.distanceFilter = newDistanceFilter;
+            [self startUpdatingLocation];
+        }
+    } else if ([self locationIsBeyondStationaryRegion:bestLocation]) {
+        if ([_config isDebugging]) {
+            [self notify:@"Manual stationary exit-detection"];
+        }
+        [self switchMode:operationMode];
+    }
+    
+    [super.delegate onLocationChanged:bestLocation];
+}
+
+/**
+ * Called when user exits their stationary radius (ie: they walked ~50m away from their last recorded location.
+ *
+ */
+- (void) locationManager:(CLLocationManager *)manager didExitRegion:(CLCircularRegion *)region
+{
+    CLLocationDistance radius = [region radius];
+    CLLocationCoordinate2D coordinate = [region center];
+    
+    DDLogDebug(@"%@ didExitRegion {%f,%f,%f}", TAG, coordinate.latitude, coordinate.longitude, radius);
+    if ([_config isDebugging]) {
+        AudioServicesPlaySystemSound (exitRegionSound);
+        [self notify:@"Exit stationary region"];
+    }
+    [self switchMode:operationMode];
+}
+
+- (void) locationManagerDidPauseLocationUpdates:(CLLocationManager *)manager
+{
+    DDLogDebug(@"%@ location updates paused", TAG);
+    if ([_config isDebugging]) {
+        [self notify:@"Location updates paused"];
+    }
+}
+
+- (void) locationManagerDidResumeLocationUpdates:(CLLocationManager *)manager
+{
+    DDLogDebug(@"%@ location updates resumed", TAG);
+    if ([_config isDebugging]) {
+        [self notify:@"Location updates resumed b"];
+    }
+}
+
+- (void) locationManager:(CLLocationManager *)manager didFailWithError:(NSError *)error
+{
+    DDLogError(@"%@ didFailWithError: %@", TAG, error);
+
+    if (MAURShouldIgnoreLocationManagerError(error)) {
+        DDLogWarn(@"%@ ignoring transient location error: %@", TAG, error);
+        return;
+    }
+
+    if ([_config isDebugging]) {
+        AudioServicesPlaySystemSound (locationErrorSound);
+        [self notify:[NSString stringWithFormat:@"Location error: %@", error.localizedDescription]];
+    }
+
+    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];
+    }
+}
+
+- (void) locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status
+{
+    DDLogInfo(@"LocationManager didChangeAuthorizationStatus %u", status);
+    if ([_config isDebugging]) {
+        [self notify:[NSString stringWithFormat:@"Authorization status changed %u", status]];
+    }
+    
+    switch(status) {
+        case kCLAuthorizationStatusRestricted:
+        case kCLAuthorizationStatusDenied:
+            if (self.delegate && [self.delegate respondsToSelector:@selector(onAuthorizationChanged:)]) {
+                [self.delegate onAuthorizationChanged:MAURLocationAuthorizationDenied];
+            }
+            break;
+        case kCLAuthorizationStatusAuthorizedAlways:
+            if (self.delegate && [self.delegate respondsToSelector:@selector(onAuthorizationChanged:)]) {
+                [self.delegate onAuthorizationChanged:MAURLocationAuthorizationAlways];
+            }
+            break;
+        case kCLAuthorizationStatusAuthorizedWhenInUse:
+            if (self.delegate && [self.delegate respondsToSelector:@selector(onAuthorizationChanged:)]) {
+                [self.delegate onAuthorizationChanged:MAURLocationAuthorizationForeground];
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+- (void) stopUpdatingLocation
+{
+    if (isUpdatingLocation) {
+        [locationManager stopUpdatingLocation];
+        isUpdatingLocation = NO;
+    }
+}
+
+- (void) startUpdatingLocation
+{
+    if (!isUpdatingLocation) {
+        [locationManager startUpdatingLocation];
+        isUpdatingLocation = YES;
+    }
+}
+
+- (void) onTerminate
+{
+    if (isStarted && !_config.stopOnTerminate) {
+        [locationManager startMonitoringSignificantLocationChanges];
+    }
+}
+
+- (void) startMonitoringSignificantLocationChanges
+{
+    [locationManager startMonitoringSignificantLocationChanges];
+}
+
+- (void) stopMonitoringSignificantLocationChanges
+{
+    [locationManager stopMonitoringSignificantLocationChanges];
+}
+
+/**
+ * Creates a new circle around user and region-monitors it for exit
+ */
+- (void) startMonitoringStationaryRegion:(MAURLocation*)location {
+    CLLocationCoordinate2D coord = [location coordinate];
+    DDLogDebug(@"%@ startMonitoringStationaryRegion {%f,%f,%@}", TAG, coord.latitude, coord.longitude, _config.stationaryRadius);
+    
+    if ([_config isDebugging]) {
+        AudioServicesPlaySystemSound (acquiredLocationSound);
+        [self notify:[NSString stringWithFormat:@"Monitoring region {%f,%f,%@}", location.coordinate.latitude, location.coordinate.longitude, _config.stationaryRadius]];
+    }
+    
+    [self stopMonitoringForRegion];
+    stationaryRegion = [[CLCircularRegion alloc] initWithCenter: coord radius:_config.stationaryRadius.integerValue identifier:@"DistanceFilterProvider stationary region"];
+    stationaryRegion.notifyOnExit = YES;
+    [locationManager startMonitoringForRegion:stationaryRegion];
+    stationarySince = [NSDate date];
+}
+
+- (void) stopMonitoringForRegion
+{
+    if (stationaryRegion != nil) {
+        [locationManager stopMonitoringForRegion:stationaryRegion];
+        stationaryRegion = nil;
+        stationarySince = nil;
+    }
+}
+
+/**
+ * Calculates distanceFilter by rounding speed to nearest 5 and multiplying by 10.  Clamped at 1km max.
+ */
+- (float) calculateDistanceFilter:(float)speed
+{
+    float newDistanceFilter = _config.distanceFilter.integerValue;
+    if (speed < 100) {
+        // (rounded-speed-to-nearest-5) / 2)^2
+        // eg 5.2 becomes (5/2)^2
+        newDistanceFilter = pow((5.0 * floorf(fabsf(speed) / 5.0 + 0.5f)), 2) + _config.distanceFilter.integerValue;
+    }
+    return (newDistanceFilter < 1000) ? newDistanceFilter : 1000;
+}
+
+/**
+ * Manual stationary location his-testing.  This seems to help stationary-exit detection in some places where the automatic geo-fencing doesn't
+ */
+- (BOOL) locationIsBeyondStationaryRegion:(MAURLocation*)location
+{
+    CLLocationCoordinate2D regionCenter = [stationaryRegion center];
+    BOOL containsCoordinate = [stationaryRegion containsCoordinate:[location coordinate]];
+    
+    DDLogVerbose(@"%@ location {%@,%@} region {%f,%f,%f} contains: %d",
+                 TAG,
+                 location.latitude, location.longitude, regionCenter.latitude, regionCenter.longitude,
+                 [stationaryRegion radius], containsCoordinate);
+    
+    return !containsCoordinate;
+}
+
+- (void) notify:(NSString*)message
+{
+    [super notify:message];
+}
+
+- (void) onDestroy {
+    DDLogInfo(@"Destroying %@ ", TAG);
+    [self onStop:nil];
+}
+
+- (void) dealloc
+{
+    //    locationController.delegate = nil;
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURGeolocationOpenHelper.h

@@ -0,0 +1,17 @@
+//
+//  MAURGeolocationOpenHelper.h
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 27/06/16.
+//  Copyright © 2016 mauron85. All rights reserved.
+//
+
+#ifndef MAURGeolocationOpenHelper_h
+#define MAURGeolocationOpenHelper_h
+
+#import "MAURSQLiteOpenHelper.h"
+
+@interface MAURGeolocationOpenHelper : MAURSQLiteOpenHelper
+@end
+
+#endif /* MAURGeolocationOpenHelper_h */

package/ios/common/BackgroundGeolocation/MAURGeolocationOpenHelper.m

@@ -0,0 +1,97 @@
+//
+//  MAURGeolocationOpenHelper.m
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 27/06/16.
+//  Copyright © 2016 mauron85. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "MAURGeolocationOpenHelper.h"
+#import "MAURLocationContract.h"
+#import "MAURConfigurationContract.h"
+
+@implementation MAURGeolocationOpenHelper
+
+static NSString *const kDatabaseName = @"cordova_bg_geolocation.db";
+static NSInteger const kDatabaseVersion = 3;
+
+- (instancetype)init
+{
+    self = [super init:kDatabaseName version:kDatabaseVersion];
+    return self;
+}
+
+- (void) drop:(NSString*)table inDatabase:(FMDatabase*)database
+{
+    NSString *sql = [NSString stringWithFormat: @"DROP TABLE IF EXISTS %@", table];
+    if (![database executeStatements:sql]) {
+        NSLog(@"%@ failed code: %d: message: %@", sql, [database lastErrorCode], [database lastErrorMessage]);
+    }
+}
+
+- (void) onCreate:(FMDatabaseQueue*)queue
+{
+    [queue inDatabase:^(FMDatabase *database) {
+        // because of some legacy code we have to drop table
+        [self drop:@LC_TABLE_NAME inDatabase:database];
+        
+        NSString *sql = [@[
+                           [MAURLocationContract createTableSQL],
+                           [MAURConfigurationContract createTableSQL],
+                           @"CREATE INDEX recorded_at_idx ON " @LC_TABLE_NAME @" (" @LC_COLUMN_NAME_RECORDED_AT @")"
+                           ]  componentsJoinedByString:@";"];
+        if (![database executeStatements:sql]) {
+            NSLog(@"%@ failed code: %d: message: %@", sql, [database lastErrorCode], [database lastErrorMessage]);
+        }
+    }];
+}
+
+- (void) onDowngrade:(FMDatabaseQueue*)queue fromVersion:(NSInteger)oldVersion toVersion:(NSInteger)newVersion
+{
+    NSLog(@"Downgrading geolocation db oldVersion: %ld, newVersion: %ld", oldVersion, newVersion);
+
+    NSString *sql = [@[
+         @"DROP TABLE IF EXISTS " @LC_TABLE_NAME
+    ] componentsJoinedByString:@";"];
+
+    [queue inDatabase:^(FMDatabase *database) {
+        if (![database executeStatements:sql]) {
+            NSLog(@"Db downgrade failed code: %d: message: %@", [database lastErrorCode], [database lastErrorMessage]);
+        } else {
+            [self onCreate:queue];
+        }
+    }];
+}
+
+- (void) onUpgrade:(FMDatabaseQueue*)queue fromVersion:(NSInteger)oldVersion toVersion:(NSInteger)newVersion
+{
+    NSLog(@"Upgrading geolocation db oldVersion: %ld, newVersion: %ld", oldVersion, newVersion);
+    NSMutableArray *sql = [[NSMutableArray alloc] init];
+    
+    switch (oldVersion) {
+        case 1:
+            [sql addObjectsFromArray: @[
+                @"ALTER TABLE " @LC_TABLE_NAME @" ADD COLUMN " @LC_COLUMN_NAME_RECORDED_AT @" INTEGER",
+                @"UPDATE " @LC_TABLE_NAME @" SET " @LC_COLUMN_NAME_RECORDED_AT @" =" @LC_COLUMN_NAME_TIME,
+                @"CREATE INDEX recorded_at_idx ON " @LC_TABLE_NAME @" (" @LC_COLUMN_NAME_RECORDED_AT @")",
+                @"DROP INDEX IF EXISTS time_idx"
+            ]];
+        case 2:
+            [sql addObjectsFromArray: @[
+                [MAURConfigurationContract createTableSQL]
+            ]];
+            break; // break only for previous db version (cascade statements)
+        default:
+            return;
+    }
+
+    [queue inDatabase:^(FMDatabase *database) {
+        NSString *stmt = [sql componentsJoinedByString:@";"];
+        if (![database executeStatements:stmt]) {
+            NSLog(@"Db upgrade failed code: %d: message: %@", [database lastErrorCode], [database lastErrorMessage]);
+        }
+    }];
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURLocation.h

@@ -0,0 +1,59 @@
+//
+//  MAURLocation.h
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 10/06/16.
+//
+
+#ifndef MAURLocation_h
+#define MAURLocation_h
+
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+@class MAURLocation;
+
+typedef MAURLocation * _Nullable (^ MAURLocationTransform)(MAURLocation * _Nonnull location);
+
+typedef NS_ENUM(NSInteger, MAURLocationStatus) {
+    MAURLocationDeleted = 0,
+    MAURLocationPostPending = 1,
+    MAURLocationSyncPending = 2,
+};
+
+@interface MAURLocation : NSObject <NSCopying>
+
+@property (nonatomic, retain) NSNumber *locationId;
+@property (nonatomic, retain) NSDate *time;
+@property (nonatomic, retain) NSNumber *accuracy;
+@property (nonatomic, retain) NSNumber *altitudeAccuracy;
+@property (nonatomic, retain) NSNumber *speed;
+@property (nonatomic, retain) NSNumber *heading;
+@property (nonatomic, retain) NSNumber *altitude;
+@property (nonatomic, retain) NSNumber *latitude;
+@property (nonatomic, retain) NSNumber *longitude;
+@property (nonatomic, retain) NSString *provider;
+@property (nonatomic, retain) NSNumber *locationProvider;
+@property (nonatomic, retain) NSNumber *radius; //only for stationary locations
+@property (nonatomic) BOOL isValid;
+@property (nonatomic, retain) NSDate *recordedAt;
+
++ (instancetype) fromCLLocation:(CLLocation*)location;
++ (NSTimeInterval) locationAge:(CLLocation*)location;
++ (NSMutableDictionary*) toDictionary:(CLLocation*)location;
+- (NSTimeInterval) locationAge;
+- (NSDictionary*) toDictionary;
+- (NSDictionary*) toDictionaryWithId;
+- (id) toResultFromTemplate:(id)locationTemplate;
+- (CLLocationCoordinate2D) coordinate;
+- (BOOL) hasAccuracy;
+- (BOOL) hasTime;
+- (double) distanceFromLocation:(MAURLocation*)location;
+- (BOOL) isBetterLocation:(MAURLocation*)location;
+- (BOOL) isBeyond:(MAURLocation*)location radius:(NSInteger)radius;
+- (id) copyWithZone: (NSZone *)zone;
+- (id) getValueForKey:(id)key;
+
+@end
+
+#endif /* MAURLocation_h */