@josuelmm/capacitor-background-geolocation 1.0.0

package/ios/common/BackgroundGeolocation/MAURBackgroundSync.h

@@ -0,0 +1,46 @@
+//
+//  MAURBackgroundSync.h
+//
+//  Created by Marian Hello on 07/07/16.
+//  Copyright © 2016 mauron85. All rights reserved.
+//
+
+#ifndef MAURBackgroundSync_h
+#define MAURBackgroundSync_h
+
+#import <Foundation/Foundation.h>
+
+@class MAURBackgroundSync;
+
+// v3.5 Phase 4: notification names for sync events. The plugin layer observes them
+// via NSNotificationCenter to forward into JS as syncStart / syncSuccess / syncError / syncProgress.
+extern NSString * _Nonnull const MAURBackgroundSyncDidStartNotification;
+extern NSString * _Nonnull const MAURBackgroundSyncDidSucceedNotification;
+extern NSString * _Nonnull const MAURBackgroundSyncDidFailNotification;
+extern NSString * _Nonnull const MAURBackgroundSyncDidProgressNotification;
+
+@protocol MAURBackgroundSyncDelegate <NSObject>
+
+@optional
+- (void)backgroundSyncRequestedAbortUpdates:(MAURBackgroundSync * _Nonnull)task;
+- (void)backgroundSyncHttpAuthorizationUpdates:(MAURBackgroundSync * _Nonnull)task;
+// v3.5 Phase 4
+- (void)backgroundSyncStarted:(MAURBackgroundSync * _Nonnull)task;
+- (void)backgroundSyncSucceeded:(MAURBackgroundSync * _Nonnull)task locationsSent:(NSInteger)locationsSent;
+- (void)backgroundSyncFailed:(MAURBackgroundSync * _Nonnull)task httpStatus:(NSInteger)httpStatus message:(NSString * _Nullable)message;
+
+@end
+
+@interface MAURBackgroundSync : NSObject
+
+@property (nonatomic, weak) id<MAURBackgroundSyncDelegate> _Nullable delegate;
+
+- (instancetype) init;
+- (NSString*) status;
+- (void) sync:(NSString * _Nonnull)url withTemplate:(id)locationTemplate withHttpHeaders:(NSMutableDictionary * _Nullable)httpHeaders;
+- (void) sync:(NSString * _Nonnull)url withTemplate:(id)locationTemplate withHttpHeaders:(NSMutableDictionary * _Nullable)httpHeaders withMethod:(NSString * _Nullable)method;
+- (void) cancel;
+
+@end
+
+#endif /* MAURBackgroundSync_h */

package/ios/common/BackgroundGeolocation/MAURBackgroundSync.m

@@ -0,0 +1,283 @@
+//
+//  MAURBackgroundSync.m
+//
+//  Created by Marian Hello on 07/07/16.
+//  Copyright © 2016 mauron85. All rights reserved.
+//
+
+#import "UIKit/UIKit.h"
+#import "MAURLogging.h"
+#import "MAURBackgroundSync.h"
+#import "MAURSQLiteLocationDAO.h"
+#import <objc/runtime.h>
+
+NSString * const MAURBackgroundSyncDidStartNotification    = @"MAURBackgroundSyncDidStart";
+NSString * const MAURBackgroundSyncDidSucceedNotification  = @"MAURBackgroundSyncDidSucceed";
+NSString * const MAURBackgroundSyncDidFailNotification     = @"MAURBackgroundSyncDidFail";
+NSString * const MAURBackgroundSyncDidProgressNotification = @"MAURBackgroundSyncDidProgress";
+
+@interface MAURBackgroundSync ()  <NSURLSessionDelegate, NSURLSessionTaskDelegate>
+{
+    NSURLSession *urlSession;
+    NSMutableArray *tasks;
+}
+@end
+
+@implementation MAURBackgroundSync
+
+- (instancetype) init
+{
+    if(!(self = [super init])) return nil;
+
+    // v3.5 Phase 4: previously `tasks` was never allocated; addObject/removeObject/cancel/status
+    // silently no-op'd on nil. Allocate now so cancel and status actually work.
+    tasks = [[NSMutableArray alloc] init];
+
+    NSURLSessionConfiguration *conf = [NSURLSessionConfiguration backgroundSessionConfiguration:@"com.marianhello.session"];
+    conf.allowsCellularAccess = YES;
+    urlSession = [NSURLSession sessionWithConfiguration:conf delegate:self delegateQueue:[NSOperationQueue mainQueue]];
+
+    return self;
+}
+
+- (void)start
+{
+    __block UIBackgroundTaskIdentifier bgTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
+        [[UIApplication sharedApplication] endBackgroundTask:bgTask];
+    }];    
+    
+    [urlSession getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
+        for(NSURLSessionUploadTask *task in uploadTasks) {
+            DDLogInfo(@"Restored upload task %zu for %@", (unsigned long)task.taskIdentifier, task.originalRequest.URL);
+            [tasks addObject:task];
+            [task resume];
+        }
+        
+        [[UIApplication sharedApplication] endBackgroundTask:bgTask];
+    }];
+}
+
+- (void)cancel
+{
+    for(NSURLSessionTask *task in tasks) {
+        [task cancel];
+    }
+}
+
+- (void) sync:(NSString * _Nonnull)url withTemplate:(id)locationTemplate withHttpHeaders:(NSMutableDictionary * _Nullable)httpHeaders
+{
+    [self sync:url withTemplate:locationTemplate withHttpHeaders:httpHeaders withMethod:@"POST"];
+}
+
+- (void) sync:(NSString * _Nonnull)url withTemplate:(id)locationTemplate withHttpHeaders:(NSMutableDictionary * _Nullable)httpHeaders withMethod:(NSString * _Nullable)method
+{
+    MAURSQLiteLocationDAO* locationDAO = [MAURSQLiteLocationDAO sharedInstance];
+    NSArray *locations = [locationDAO getLocationsForSync];
+    
+    NSMutableArray *jsonArray = [[NSMutableArray alloc] initWithCapacity:[locations count]];
+    for (MAURLocation *location in locations) {
+        [jsonArray addObject:[location toResultFromTemplate:locationTemplate]];
+    }
+    
+    NSError *error = nil;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:jsonArray options:0 error:&error];
+    
+    NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];
+    dateFormatter.locale = [[NSLocale alloc] initWithLocaleIdentifier:@"en_US_POSIX"];
+    dateFormatter.dateFormat = @"yyyyMMdd_HHmms";
+    dateFormatter.timeZone = [NSTimeZone timeZoneForSecondsFromGMT:0];
+    NSString *fileName = [NSString stringWithFormat:@"locations_%@.json", [dateFormatter stringFromDate:[NSDate date]]];
+    NSURL *jsonUrl = [NSURL fileURLWithPath:[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0] stringByAppendingPathComponent:fileName]];
+    [jsonData writeToFile:jsonUrl.path atomically:NO];
+    uint64_t bytesTotalForThisFile = [[[NSFileManager defaultManager] attributesOfItemAtPath:jsonUrl.path error:nil] fileSize];
+    
+    NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:url]];
+    NSString *resolvedMethod = (method != nil && method.length > 0) ? [method uppercaseString] : @"POST";
+    [request setHTTPMethod:resolvedMethod];
+    [request setTimeoutInterval:120]; // Prevents sync from hanging indefinitely if server does not respond
+    [request setValue:[NSString stringWithFormat:@"%llu", bytesTotalForThisFile] forHTTPHeaderField:@"Content-Length"];
+    [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
+    
+    if (httpHeaders != nil) {
+        for(id key in httpHeaders) {
+            id value = [httpHeaders objectForKey:key];
+            [request addValue:value forHTTPHeaderField:key];
+        }
+    }
+    NSURLSessionTask *task = [urlSession uploadTaskWithRequest:request fromFile:jsonUrl];
+    task.taskDescription = fileName;
+    [tasks addObject:task];
+    DDLogInfo(@"Started upload for %@ as task %zu/%@/%@", jsonUrl.lastPathComponent, (unsigned long)task.taskIdentifier, task.taskDescription, task);
+
+    // v3.5 Phase 4: emit syncStart now that we are about to push to the server.
+    if (self.delegate && [self.delegate respondsToSelector:@selector(backgroundSyncStarted:)]) {
+        [self.delegate backgroundSyncStarted:self];
+    }
+    [[NSNotificationCenter defaultCenter] postNotificationName:MAURBackgroundSyncDidStartNotification object:self];
+
+    // Stash count so didCompleteWithError can report it as syncSuccess payload.
+    objc_setAssociatedObject(task, "locationsSent", @([jsonArray count]), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    // v4.5.1: capture cutoff timestamp NOW so on success we delete only the rows that existed
+    // before the upload started. Locations persisted DURING the upload are preserved.
+    objc_setAssociatedObject(task, "uploadCutoff",
+        @([[NSDate date] timeIntervalSince1970]), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+    [task resume];
+
+}
+
+// http://stackoverflow.com/a/572623/48125
+NSString *stringFromFileSize(unsigned long long theSize)
+{
+    double floatSize = theSize;
+    if (theSize<1023)
+        return([NSString stringWithFormat:@"%lli bytes",theSize]);
+    floatSize = floatSize / 1024;
+    if (floatSize<1023)
+        return([NSString stringWithFormat:@"%1.1f KB",floatSize]);
+    floatSize = floatSize / 1024;
+    if (floatSize<1023)
+        return([NSString stringWithFormat:@"%1.1f MB",floatSize]);
+    floatSize = floatSize / 1024;
+    
+    return([NSString stringWithFormat:@"%1.1f GB",floatSize]);
+}
+
+- (NSString*)status
+{
+    int64_t sent = 0, toSend = 0;
+    for(NSURLSessionUploadTask *task in tasks) {
+        sent += task.countOfBytesSent;
+        toSend += task.countOfBytesExpectedToSend;
+    }
+    return [NSString stringWithFormat:@"%@ being uploaded (%@ of %@)\nFiles on disk: %@",
+        [tasks valueForKeyPath:@"taskDescription"],
+        stringFromFileSize(sent),
+        stringFromFileSize(toSend),
+
+        [[NSFileManager defaultManager]
+         contentsOfDirectoryAtPath:NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0]
+         error:NULL]
+    ];
+}
+
+
+#pragma mark -
+// v3.5 Phase 4: forward upload progress as syncProgress (0..100).
+- (void)URLSession:(NSURLSession *)session
+              task:(NSURLSessionTask *)task
+   didSendBodyData:(int64_t)bytesSent
+    totalBytesSent:(int64_t)totalBytesSent
+totalBytesExpectedToSend:(int64_t)totalBytesExpectedToSend
+{
+    if (totalBytesExpectedToSend <= 0) return;
+    NSInteger progress = (NSInteger)((totalBytesSent * 100) / totalBytesExpectedToSend);
+    if (progress < 0) progress = 0;
+    if (progress > 100) progress = 100;
+    [[NSNotificationCenter defaultCenter]
+        postNotificationName:MAURBackgroundSyncDidProgressNotification
+                      object:self
+                    userInfo:@{@"progress": @(progress)}];
+}
+
+- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(nullable NSError *)error
+{
+    NSInteger statusCode = [(NSHTTPURLResponse *)task.response statusCode];
+    
+    DDLogInfo(@"Finished uploading task %zu %@: %@ %@, HTTP %ld", (unsigned long)[task taskIdentifier], task.originalRequest.URL, error ?: @"Success", task.response, (long)statusCode);
+    
+    [tasks removeObject:task];
+    NSURL *fullPath = [NSURL fileURLWithPath:[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0] stringByAppendingPathComponent:task.taskDescription]];
+    [[NSFileManager defaultManager] removeItemAtURL:fullPath error:NULL];
+    
+    if (statusCode == 285)
+    {
+        // Okay, but we don't need to continue sending these
+        DDLogDebug(@"Locations were uploaded to the server, and received an \"HTTP 285 Updates Not Required\"");
+        
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (_delegate && [_delegate respondsToSelector:@selector(backgroundSyncRequestedAbortUpdates:)])
+            {
+                [_delegate backgroundSyncRequestedAbortUpdates:self];
+            }
+        });
+    }
+
+    if (statusCode == 401)
+    {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (_delegate && [_delegate respondsToSelector:@selector(backgroundSyncHttpAuthorizationUpdates:)])
+            {
+                [_delegate backgroundSyncHttpAuthorizationUpdates:self];
+            }
+        });
+    }
+
+    // v3.5 Phase 4: emit syncSuccess / syncError.
+    NSNumber *sentNum = objc_getAssociatedObject(task, "locationsSent");
+    NSInteger locationsSent = sentNum != nil ? [sentNum integerValue] : 0;
+    BOOL isStatusOkay = (statusCode >= 200 && statusCode < 300);
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+        if (error != nil) {
+            // v4.5.1 — restore SyncPending → PostPending so the failed locations get retried
+            // on the next sync window. Without this, a single network drop loses everything.
+            NSError *restErr = nil;
+            [[MAURSQLiteLocationDAO sharedInstance] restoreFailedSyncLocations:&restErr];
+            NSString *msg = error.localizedDescription ?: @"";
+            if (_delegate && [_delegate respondsToSelector:@selector(backgroundSyncFailed:httpStatus:message:)]) {
+                [_delegate backgroundSyncFailed:self httpStatus:0 message:msg];
+            }
+            [[NSNotificationCenter defaultCenter]
+                postNotificationName:MAURBackgroundSyncDidFailNotification
+                              object:self
+                            userInfo:@{@"httpStatus": @0, @"message": msg}];
+        } else if (!isStatusOkay) {
+            // v4.5.1 — server-side failure (5xx, 4xx other than 285/401): also restore the rows.
+            NSError *restErr = nil;
+            [[MAURSQLiteLocationDAO sharedInstance] restoreFailedSyncLocations:&restErr];
+            NSString *msg = [NSString stringWithFormat:@"HTTP %ld", (long)statusCode];
+            if (_delegate && [_delegate respondsToSelector:@selector(backgroundSyncFailed:httpStatus:message:)]) {
+                [_delegate backgroundSyncFailed:self httpStatus:statusCode message:msg];
+            }
+            [[NSNotificationCenter defaultCenter]
+                postNotificationName:MAURBackgroundSyncDidFailNotification
+                              object:self
+                            userInfo:@{@"httpStatus": @(statusCode), @"message": msg}];
+        } else {
+            // v4.5.1: drop SYNC_PENDING locations whose recorded_at is <= the captured upload-start
+            // cutoff. This preserves any new locations persisted DURING the upload (race window).
+            NSNumber *cutoffNum = objc_getAssociatedObject(task, "uploadCutoff");
+            NSTimeInterval cutoff = cutoffNum != nil ? [cutoffNum doubleValue] : [[NSDate date] timeIntervalSince1970];
+            NSError *delErr = nil;
+            BOOL deleted = [[MAURSQLiteLocationDAO sharedInstance] deleteSyncedLocationsBefore:cutoff error:&delErr];
+            if (!deleted) {
+                NSLog(@"deleteSyncedLocationsBefore after success failed: %@", delErr.localizedDescription ?: @"unknown");
+            }
+            if (_delegate && [_delegate respondsToSelector:@selector(backgroundSyncSucceeded:locationsSent:)]) {
+                [_delegate backgroundSyncSucceeded:self locationsSent:locationsSent];
+            }
+            [[NSNotificationCenter defaultCenter]
+                postNotificationName:MAURBackgroundSyncDidSucceedNotification
+                              object:self
+                            userInfo:@{@"sent": @(locationsSent)}];
+        }
+    });
+}
+
+- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
+{
+    DDLogInfo(@"Response:: %@", [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
+}
+
+- (void)URLSession:(NSURLSession *)session didBecomeInvalidWithError:(nullable NSError *)error
+{
+    DDLogError(@"Autosync failed :( %@", error);
+}
+
+- (void)URLSessionDidFinishEventsForBackgroundURLSession:(NSURLSession *)session
+{
+    DDLogInfo(@"finished events for bg session");
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURBackgroundTaskManager.h

@@ -0,0 +1,25 @@
+//
+//  MAURBackgroundTaskManager.h
+//  BackgroundGeolocation
+//
+//  Created by Joel and Vomako (http://stackoverflow.com/a/27664620)
+//
+
+#ifndef MAURBackgroundTaskManager_h
+#define MAURBackgroundTaskManager_h
+
+
+#endif /* MAURBackgroundTaskManager_h */
+
+typedef void (^CompletionBlock)(void);
+
+
+@interface MAURBackgroundTaskManager : NSObject
+
++ (id) sharedTasks;
+
+- (NSUInteger)beginTask;
+- (NSUInteger)beginTaskWithCompletionHandler:(CompletionBlock)_completion;
+- (void)endTaskWithKey:(NSUInteger)_key;
+
+@end

package/ios/common/BackgroundGeolocation/MAURBackgroundTaskManager.m

@@ -0,0 +1,105 @@
+//
+//  MAURBackgroundTaskManager.m
+//  BackgroundGeolocation
+//
+//  Created by Joel and Vomako (http://stackoverflow.com/a/27664620)
+//
+
+#import <UIKit/UIKit.h>
+#import "MAURBackgroundTaskManager.h"
+
+@interface MAURBackgroundTaskManager()
+
+@property NSUInteger taskKeyCounter;
+@property NSMutableDictionary *dictTaskIdentifiers;
+@property NSMutableDictionary *dictTaskCompletionBlocks;
+
+@end
+
+@implementation MAURBackgroundTaskManager
+
++ (id)sharedTasks {
+    static MAURBackgroundTaskManager *sharedTasks = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        sharedTasks = [[self alloc] init];
+    });
+    return sharedTasks;
+}
+
+- (id)init
+{
+    self = [super init];
+    if (self) {
+        
+        [self setTaskKeyCounter:0];
+        [self setDictTaskIdentifiers:[NSMutableDictionary dictionary]];
+        [self setDictTaskCompletionBlocks:[NSMutableDictionary dictionary]];
+    }
+    return self;
+}
+
+- (NSUInteger)beginTask
+{
+    return [self beginTaskWithCompletionHandler:nil];
+}
+
+- (NSUInteger)beginTaskWithCompletionHandler:(CompletionBlock)_completion;
+{
+    //read the counter and increment it
+    NSUInteger taskKey;
+    @synchronized(self) {
+        
+        taskKey = self.taskKeyCounter;
+        self.taskKeyCounter++;
+        
+    }
+    
+    //tell the OS to start a task that should continue in the background if needed
+    NSUInteger taskId = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
+        [self endTaskWithKey:taskKey];
+    }];
+    
+    //add this task identifier to the active task dictionary
+    [self.dictTaskIdentifiers setObject:[NSNumber numberWithUnsignedLong:taskId] forKey:[NSNumber numberWithUnsignedLong:taskKey]];
+    
+    //store the completion block (if any)
+    if (_completion) [self.dictTaskCompletionBlocks setObject:_completion forKey:[NSNumber numberWithUnsignedLong:taskKey]];
+    
+    //return the dictionary key
+    return taskKey;
+}
+
+- (void)endTaskWithKey:(NSUInteger)_key
+{
+    @synchronized(self.dictTaskCompletionBlocks) {
+        
+        //see if this task has a completion block
+        CompletionBlock completion = [self.dictTaskCompletionBlocks objectForKey:[NSNumber numberWithUnsignedLong:_key]];
+        if (completion) {
+            
+            //run the completion block and remove it from the completion block dictionary
+            completion();
+            [self.dictTaskCompletionBlocks removeObjectForKey:[NSNumber numberWithUnsignedLong:_key]];
+            
+        }
+        
+    }
+    
+    @synchronized(self.dictTaskIdentifiers) {
+        
+        //see if this task has been ended yet
+        NSNumber *taskId = [self.dictTaskIdentifiers objectForKey:[NSNumber numberWithUnsignedLong:_key]];
+        if (taskId) {
+            
+            //end the task and remove it from the active task dictionary
+            [[UIApplication sharedApplication] endBackgroundTask:[taskId unsignedLongValue]];
+            [self.dictTaskIdentifiers removeObjectForKey:[NSNumber numberWithUnsignedLong:_key]];
+            
+            NSLog(@"Task ended");
+        }
+        
+    }
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURConfig.h

@@ -0,0 +1,99 @@
+//
+//  MAURConfig.h
+//  BackgroundGeolocation
+//
+//  Created by Marian Hello on 11/06/16.
+//
+
+#ifndef MAURConfig_h
+#define MAURConfig_h
+
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+enum {
+    DISTANCE_FILTER_PROVIDER = 0,
+    ACTIVITY_PROVIDER = 1,
+    RAW_PROVIDER = 2
+};
+
+@interface MAURConfig : NSObject <NSCopying>
+
+@property NSNumber *stationaryRadius;
+@property NSNumber *distanceFilter;
+@property NSNumber *desiredAccuracy;
+@property NSNumber *_debug;
+@property NSString *activityType;
+@property NSNumber *activitiesInterval;
+@property NSNumber *_stopOnTerminate;
+@property NSString *url;
+@property NSString *syncUrl;
+@property NSNumber *syncThreshold;
+@property NSNumber *syncEnabled;
+@property NSMutableDictionary* httpHeaders;
+// v3.3 Phase 2: backend-agnostic HTTP transport
+@property NSString *httpMethod;        // POST | GET | PUT | PATCH (default POST)
+@property NSString *syncHttpMethod;    // POST | GET | PUT | PATCH (default POST)
+@property NSString *httpMode;          // batch | single (default batch)
+@property NSString *syncMode;          // batch | single (default batch)
+@property NSMutableDictionary* queryParams; // static placeholder values for URL templating
+// v3.4 Phase 3: location API modernization
+@property NSNumber *_showsBackgroundLocationIndicator; // iOS 11+: show blue bar when app uses location in background
+// v3.5 Phase 4: diagnostics
+@property NSNumber *heartbeatInterval;        // ms; 0 disables (default)
+@property NSString *mockLocationPolicy;       // allow | flag | drop (default allow)
+// v4.0 Phase 6: driver insights — passed through as a dictionary; the facade reads keys at runtime.
+@property NSDictionary *drivingEvents;
+// v4.4: stamp battery percentage + charging state onto every location (default ON).
+@property NSNumber *includeBattery;
+// v4.5.2: provider hardening
+/** 0-100. Activity-recognition transitions below this confidence are ignored. Default 50. */
+@property NSNumber *activityConfidenceThreshold;
+/** Discard fixes whose accuracy (m) is worse than this. nil = no filter. */
+@property NSNumber *maxAcceptedAccuracy;
+@property NSNumber *_saveBatteryOnBackground;
+@property NSNumber *maxLocations;
+@property NSNumber *_pauseLocationUpdates;
+@property NSNumber *locationProvider;
+@property NSObject *_template;
+
+- (instancetype) initWithDefaults;
++ (instancetype) fromDictionary:(NSDictionary*)config;
++ (instancetype) merge:(MAURConfig*)config withConfig:(MAURConfig*)newConfig;
++ (NSDictionary*) getDefaultTemplate;
+
+- (BOOL) hasStationaryRadius;
+- (BOOL) hasDistanceFilter;
+- (BOOL) hasDesiredAccuracy;
+- (BOOL) hasDebug;
+- (BOOL) hasActivityType;
+- (BOOL) hasStopOnTerminate;
+- (BOOL) hasUrl;
+- (BOOL) hasValidUrl;
+- (BOOL) hasSyncUrl;
+- (BOOL) hasValidSyncUrl;
+- (BOOL) hasSyncThreshold;
+- (BOOL) hasSyncEnabled;
+- (BOOL) syncEnabled;
+- (BOOL) hasHttpHeaders;
+- (BOOL) hasSaveBatteryOnBackground;
+- (BOOL) hasShowsBackgroundLocationIndicator;
+- (BOOL) showsBackgroundLocationIndicator;
+- (BOOL) hasMaxLocations;
+- (BOOL) hasPauseLocationUpdates;
+- (BOOL) hasLocationProvider;
+- (BOOL) hasTemplate;
+- (BOOL) hasActivitiesInterval;
+- (BOOL) isDebugging;
+- (BOOL) stopOnTerminate;
+- (BOOL) saveBatteryOnBackground;
+- (BOOL) pauseLocationUpdates;
+- (CLActivityType) decodeActivityType;
+- (NSInteger) decodeDesiredAccuracy;
+- (NSString*) getHttpHeadersAsString:(NSError * __autoreleasing *)outError;
+- (NSString*) getTemplateAsString:(NSError * __autoreleasing *)outError;
+- (NSDictionary*) toDictionary;
+
+@end;
+
+#endif /* MAURConfig_h */