@josuelmm/capacitor-background-geolocation 1.0.0

package/ios/common/BackgroundGeolocation/FMDBLogger.h

@@ -0,0 +1,42 @@
+#import <Foundation/Foundation.h>
+#import "CocoaLumberjack.h"
+
+@class FMDatabase;
+
+
+@interface FMDBLogger : DDAbstractDatabaseLogger <DDLogger>
+{
+@private
+    NSString *logDirectory;
+    NSMutableArray *pendingLogEntries;
+    
+    FMDatabase *database;
+}
+
+/**
+ * Initializes an instance set to save it's sqlite file to the given directory.
+ * If the directory doesn't already exist, it is automatically created.
+ **/
+- (id)initWithLogDirectory:(NSString *)logDirectory;
+
+//
+// This class inherits from DDAbstractDatabaseLogger.
+//
+// So there are a bunch of options such as:
+//
+// @property (assign, readwrite) NSUInteger saveThreshold;
+// @property (assign, readwrite) NSTimeInterval saveInterval;
+//
+// @property (assign, readwrite) NSTimeInterval maxAge;
+// @property (assign, readwrite) NSTimeInterval deleteInterval;
+// @property (assign, readwrite) BOOL deleteOnEverySave;
+//
+// And methods such as:
+//
+// - (void)savePendingLogEntries;
+// - (void)deleteOldLogEntries;
+//
+// These options and methods are documented extensively in DDAbstractDatabaseLogger.h
+//
+
+@end

package/ios/common/BackgroundGeolocation/FMDBLogger.m

@@ -0,0 +1,264 @@
+#import "FMDBLogger.h"
+#import "FMDB.h"
+
+
+@interface FMDBLogger ()
+- (void)validateLogDirectory;
+- (void)openDatabase;
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@interface FMDBLogEntry : NSObject {
+@public
+    NSNumber * context;
+    NSNumber * level;
+    NSString * message;
+    NSDate   * timestamp;
+}
+
+- (id)initWithLogMessage:(DDLogMessage *)logMessage;
+
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@implementation FMDBLogEntry
+
+- (id)initWithLogMessage:(DDLogMessage *)logMessage
+{
+    if ((self = [super init]))
+    {
+        context   = @(logMessage->_context);
+        level     = @(logMessage->_flag);
+        message   = logMessage->_message;
+        timestamp = logMessage->_timestamp;
+    }
+    return self;
+}
+
+
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@implementation FMDBLogger
+
+- (id)initWithLogDirectory:(NSString *)aLogDirectory
+{
+    if ((self = [super init]))
+    {
+        logDirectory = [aLogDirectory copy];
+        
+        pendingLogEntries = [[NSMutableArray alloc] initWithCapacity:_saveThreshold];
+        
+        [self validateLogDirectory];
+        [self openDatabase];
+    }
+    
+    return self;
+}
+
+
+- (void)validateLogDirectory
+{
+    // Validate log directory exists or create the directory.
+    
+    BOOL isDirectory;
+    if ([[NSFileManager defaultManager] fileExistsAtPath:logDirectory isDirectory:&isDirectory])
+    {
+        if (!isDirectory)
+        {
+            NSLog(@"%@: %@ - logDirectory(%@) is a file!", [self class], THIS_METHOD, logDirectory);
+            
+            logDirectory = nil;
+        }
+    }
+    else
+    {
+        NSError *error = nil;
+        
+        BOOL result = [[NSFileManager defaultManager] createDirectoryAtPath:logDirectory
+                                                withIntermediateDirectories:YES
+                                                                 attributes:nil
+                                                                      error:&error];
+        if (!result)
+        {
+            NSLog(@"%@: %@ - Unable to create logDirectory(%@) due to error: %@",
+                  [self class], THIS_METHOD, logDirectory, error);
+            
+            logDirectory = nil;
+        }
+    }
+}
+
+- (void)openDatabase
+{
+    if (logDirectory == nil)
+    {
+        return;
+    }
+    
+    NSString *path = [logDirectory stringByAppendingPathComponent:@"log.sqlite"];
+    
+    database = [[FMDatabase alloc] initWithPath:path];
+    
+    if (![database open])
+    {
+        NSLog(@"%@: Failed opening database!", [self class]);
+        
+        database = nil;
+        
+        return;
+    }
+    
+    NSString *cmd1 = @"CREATE TABLE IF NOT EXISTS logs (context integer, "
+                                                       "level integer, "
+                                                       "message text, "
+                                                       "timestamp double)";
+    [database executeUpdate:cmd1];
+    if ([database hadError])
+    {
+        NSLog(@"%@: Error creating table: code(%d): %@",
+              [self class], [database lastErrorCode], [database lastErrorMessage]);
+        
+        database = nil;
+    }
+    
+    NSString *cmd2 = @"CREATE INDEX IF NOT EXISTS timestamp ON logs (timestamp)";
+    
+    [database executeUpdate:cmd2];
+    if ([database hadError])
+    {
+        NSLog(@"%@: Error creating index: code(%d): %@",
+              [self class], [database lastErrorCode], [database lastErrorMessage]);
+        
+        database = nil;
+    }
+    
+    [database setShouldCacheStatements:YES];
+}
+
+#pragma mark AbstractDatabaseLogger Overrides
+
+- (BOOL)db_log:(DDLogMessage *)logMessage
+{
+    // You may be wondering, how come we don't just do the insert here and be done with it?
+    // Is the buffering really needed?
+    // 
+    // From the SQLite FAQ:
+    // 
+    // (19) INSERT is really slow - I can only do few dozen INSERTs per second
+    // 
+    // Actually, SQLite will easily do 50,000 or more INSERT statements per second on an average desktop computer.
+    // But it will only do a few dozen transactions per second. Transaction speed is limited by the rotational
+    // speed of your disk drive. A transaction normally requires two complete rotations of the disk platter, which
+    // on a 7200RPM disk drive limits you to about 60 transactions per second.
+    // 
+    // Transaction speed is limited by disk drive speed because (by default) SQLite actually waits until the data
+    // really is safely stored on the disk surface before the transaction is complete. That way, if you suddenly
+    // lose power or if your OS crashes, your data is still safe. For details, read about atomic commit in SQLite.
+    // 
+    // By default, each INSERT statement is its own transaction. But if you surround multiple INSERT statements
+    // with BEGIN...COMMIT then all the inserts are grouped into a single transaction. The time needed to commit
+    // the transaction is amortized over all the enclosed insert statements and so the time per insert statement
+    // is greatly reduced.
+    
+    FMDBLogEntry *logEntry = [[FMDBLogEntry alloc] initWithLogMessage:logMessage];
+    
+    [pendingLogEntries addObject:logEntry];
+    
+    // Return YES if an item was added to the buffer.
+    // Return NO if the logMessage was ignored.
+    
+    return YES;
+}
+
+- (void)db_save
+{
+    if ([pendingLogEntries count] == 0)
+    {
+        // Nothing to save.
+        // The superclass won't likely call us if this is the case, but we're being cautious.
+        return;
+    }
+    
+    BOOL saveOnlyTransaction = ![database inTransaction];
+    
+    if (saveOnlyTransaction)
+    {
+        [database beginTransaction];
+    }
+    
+    NSString *cmd = @"INSERT INTO logs (context, level, message, timestamp) VALUES (?, ?, ?, ?)";
+    
+    for (FMDBLogEntry *logEntry in pendingLogEntries)
+    {
+        [database executeUpdate:cmd, logEntry->context,
+                                     logEntry->level,
+                                     logEntry->message,
+                                     logEntry->timestamp];
+    }
+    
+    [pendingLogEntries removeAllObjects];
+    
+    if (saveOnlyTransaction)
+    {
+        [database commit];
+        
+        if ([database hadError])
+        {
+            NSLog(@"%@: Error inserting log entries: code(%d): %@",
+                  [self class], [database lastErrorCode], [database lastErrorMessage]);
+        }
+    }
+}
+
+- (void)db_delete
+{
+    if (_maxAge <= 0.0)
+    {
+        // Deleting old log entries is disabled.
+        // The superclass won't likely call us if this is the case, but we're being cautious.
+        return;
+    }
+    
+    BOOL deleteOnlyTransaction = ![database inTransaction];
+    
+    NSDate *maxDate = [NSDate dateWithTimeIntervalSinceNow:(-1.0 * _maxAge)];
+    
+    [database executeUpdate:@"DELETE FROM logs WHERE timestamp < ?", maxDate];
+    
+    if (deleteOnlyTransaction)
+    {
+        if ([database hadError])
+        {
+            NSLog(@"%@: Error deleting log entries: code(%d): %@",
+                  [self class], [database lastErrorCode], [database lastErrorMessage]);
+        }
+    }
+}
+
+- (void)db_saveAndDelete
+{
+    [database beginTransaction];
+    
+    [self db_delete];
+    [self db_save];
+    
+    [database commit];
+    
+    if ([database hadError])
+    {
+        NSLog(@"%@: Error: code(%d): %@",
+              [self class], [database lastErrorCode], [database lastErrorMessage]);
+    }
+}
+
+@end

package/ios/common/BackgroundGeolocation/INTULocationManager/INTUHeadingRequest.h

@@ -0,0 +1,41 @@
+//
+//  INTUHeadingRequest.h
+//
+//  Copyright (c) 2014-2017 Intuit Inc.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be
+//  included in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#import "INTULocationRequestDefines.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface INTUHeadingRequest : NSObject
+
+/** The request ID for this heading request (set during initialization). */
+@property (nonatomic, readonly) INTUHeadingRequestID requestID;
+/** Whether this is a recurring heading request (all heading requests are assumed to be for now). */
+@property (nonatomic, readonly) BOOL isRecurring;
+/** The block to execute when the heading request completes. */
+@property (nonatomic, copy, nullable) INTUHeadingRequestBlock block;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/common/BackgroundGeolocation/INTULocationManager/INTUHeadingRequest.m

@@ -0,0 +1,68 @@
+//
+//  INTUHeadingRequest.m
+//
+//  Copyright (c) 2014-2017 Intuit Inc.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be
+//  included in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#import "INTUHeadingRequest.h"
+#import "INTURequestIDGenerator.h"
+
+@implementation INTUHeadingRequest
+
+/**
+ Designated initializer. Initializes and returns a newly allocated heading request.
+ */
+- (instancetype)init
+{
+    if (self = [super init]) {
+        _requestID = [INTURequestIDGenerator getUniqueRequestID];
+        _isRecurring = YES;
+    }
+    return self;
+}
+
+/**
+ Two heading requests are considered equal if their request IDs match.
+ */
+- (BOOL)isEqual:(id)object
+{
+    if (object == self) {
+        return YES;
+    }
+    if (!object || ![object isKindOfClass:[self class]]) {
+        return NO;
+    }
+    if (((INTUHeadingRequest *)object).requestID == self.requestID) {
+        return YES;
+    }
+    return NO;
+}
+
+/**
+ Return a hash based on the string representation of the request ID.
+ */
+- (NSUInteger)hash
+{
+    return [[NSString stringWithFormat:@"%ld", (long)self.requestID] hash];
+}
+
+@end

package/ios/common/BackgroundGeolocation/INTULocationManager/INTULocationManager+Internal.h

@@ -0,0 +1,33 @@
+//
+//  INTULocationManager+Internal.h
+//
+//  Copyright (c) 2014-2017 Intuit Inc.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be
+//  included in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#import "INTULocationManager.h"
+
+/**
+ A category that exposes the internal (private) methods of INTULocationManager.
+ */
+@interface INTULocationManager (Internal) <CLLocationManagerDelegate>
+
+@end

package/ios/common/BackgroundGeolocation/INTULocationManager/INTULocationManager.h

@@ -0,0 +1,178 @@
+//
+//  INTULocationManager.h
+//
+//  Copyright (c) 2014-2017 Intuit Inc.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining
+//  a copy of this software and associated documentation files (the
+//  "Software"), to deal in the Software without restriction, including
+//  without limitation the rights to use, copy, modify, merge, publish,
+//  distribute, sublicense, and/or sell copies of the Software, and to
+//  permit persons to whom the Software is furnished to do so, subject to
+//  the following conditions:
+//
+//  The above copyright notice and this permission notice shall be
+//  included in all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+//  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+//  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+//  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#import "INTULocationRequestDefines.h"
+
+//! Project version number for INTULocationManager.
+FOUNDATION_EXPORT double INTULocationManagerVersionNumber;
+
+//! Project version string for INTULocationManager.
+FOUNDATION_EXPORT const unsigned char INTULocationManagerVersionString[];
+
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ An abstraction around CLLocationManager that provides a block-based asynchronous API for obtaining the device's location.
+ INTULocationManager automatically starts and stops system location services as needed to minimize battery drain.
+ */
+@interface INTULocationManager : NSObject
+
+/** Returns the current state of location services for this app, based on the system settings and user authorization status. */
++ (INTULocationServicesState)locationServicesState;
+
+/** Returns the current state of heading services for this device. */
++ (INTUHeadingServicesState)headingServicesState;
+
+/** Returns the singleton instance of this class. */
++ (instancetype)sharedInstance;
+
+#pragma mark Location Requests
+
+/**
+ Asynchronously requests the current location of the device using location services.
+ 
+ @param desiredAccuracy The accuracy level desired (refers to the accuracy and recency of the location).
+ @param timeout         The maximum amount of time (in seconds) to wait for a location with the desired accuracy before completing. If 
+                        this value is 0.0, no timeout will be set (will wait indefinitely for success, unless request is force completed or canceled).
+ @param block           The block to execute upon success, failure, or timeout.
+ 
+ @return The location request ID, which can be used to force early completion or cancel the request while it is in progress.
+ */
+- (INTULocationRequestID)requestLocationWithDesiredAccuracy:(INTULocationAccuracy)desiredAccuracy
+                                                    timeout:(NSTimeInterval)timeout
+                                                      block:(INTULocationRequestBlock)block;
+
+/**
+ Asynchronously requests the current location of the device using location services, optionally delaying the timeout countdown until the user has
+ responded to the dialog requesting permission for this app to access location services.
+ 
+ @param desiredAccuracy      The accuracy level desired (refers to the accuracy and recency of the location).
+ @param timeout              The maximum amount of time (in seconds) to wait for a location with the desired accuracy before completing. If
+                             this value is 0.0, no timeout will be set (will wait indefinitely for success, unless request is force completed or canceled).
+ @param delayUntilAuthorized A flag specifying whether the timeout should only take effect after the user responds to the system prompt requesting
+                             permission for this app to access location services. If YES, the timeout countdown will not begin until after the
+                             app receives location services permissions. If NO, the timeout countdown begins immediately when calling this method.
+ @param block                The block to execute upon success, failure, or timeout.
+ 
+ @return The location request ID, which can be used to force early completion or cancel the request while it is in progress.
+ */
+- (INTULocationRequestID)requestLocationWithDesiredAccuracy:(INTULocationAccuracy)desiredAccuracy
+                                                    timeout:(NSTimeInterval)timeout
+                                       delayUntilAuthorized:(BOOL)delayUntilAuthorized
+                                                      block:(INTULocationRequestBlock)block;
+
+/**
+ Creates a subscription for location updates that will execute the block once per update indefinitely (until canceled), regardless of the accuracy of each location.
+ This method instructs location services to use the highest accuracy available (which also requires the most power).
+ If an error occurs, the block will execute with a status other than INTULocationStatusSuccess, and the subscription will be canceled automatically.
+ 
+ @param block The block to execute every time an updated location is available. 
+              The status will be INTULocationStatusSuccess unless an error occurred; it will never be INTULocationStatusTimedOut.
+ 
+ @return The location request ID, which can be used to cancel the subscription of location updates to this block.
+ */
+- (INTULocationRequestID)subscribeToLocationUpdatesWithBlock:(INTULocationRequestBlock)block;
+
+/**
+ Creates a subscription for location updates that will execute the block once per update indefinitely (until canceled), regardless of the accuracy of each location.
+ The specified desired accuracy is passed along to location services, and controls how much power is used, with higher accuracies using more power.
+ If an error occurs, the block will execute with a status other than INTULocationStatusSuccess, and the subscription will be canceled automatically.
+ 
+ @param desiredAccuracy The accuracy level desired, which controls how much power is used by the device's location services.
+ @param block           The block to execute every time an updated location is available. Note that this block runs for every update, regardless of
+                        whether the achievedAccuracy is at least the desiredAccuracy.
+                        The status will be INTULocationStatusSuccess unless an error occurred; it will never be INTULocationStatusTimedOut.
+ 
+ @return The location request ID, which can be used to cancel the subscription of location updates to this block.
+ */
+- (INTULocationRequestID)subscribeToLocationUpdatesWithDesiredAccuracy:(INTULocationAccuracy)desiredAccuracy
+                                                                 block:(INTULocationRequestBlock)block;
+
+/**
+ Creates a subscription for significant location changes that will execute the block once per change indefinitely (until canceled).
+ If an error occurs, the block will execute with a status other than INTULocationStatusSuccess, and the subscription will be canceled automatically.
+ 
+ @param block The block to execute every time an updated location is available.
+              The status will be INTULocationStatusSuccess unless an error occurred; it will never be INTULocationStatusTimedOut.
+ 
+ @return The location request ID, which can be used to cancel the subscription of significant location changes to this block.
+ */
+- (INTULocationRequestID)subscribeToSignificantLocationChangesWithBlock:(INTULocationRequestBlock)block;
+
+/** Immediately forces completion of the location request with the given requestID (if it exists), and executes the original request block with the results.
+    For one-time location requests, this is effectively a manual timeout, and will result in the request completing with status INTULocationStatusTimedOut.
+    If the requestID corresponds to a subscription, then the subscription will simply be canceled. */
+- (void)forceCompleteLocationRequest:(INTULocationRequestID)requestID;
+
+/** Immediately cancels the location request (or subscription) with the given requestID (if it exists), without executing the original request block. */
+- (void)cancelLocationRequest:(INTULocationRequestID)requestID;
+
+#pragma mark Heading Requests
+
+/**
+ Creates a subscription for heading updates that will execute the block once per update indefinitely (until canceled), assuming the heading update exceeded the heading filter threshold.
+ If an error occurs, the block will execute with a status other than INTUHeadingStatusSuccess, and the subscription will be canceled automatically.
+
+ @param block           The block to execute every time an updated heading is available. The status will be INTUHeadingStatusSuccess unless an error occurred.
+
+ @return The heading request ID, which can be used to cancel the subscription of heading updates to this block.
+ */
+- (INTUHeadingRequestID)subscribeToHeadingUpdatesWithBlock:(INTUHeadingRequestBlock)block;
+
+/** Immediately cancels the heading subscription request with the given requestID (if it exists), without executing the original request block. */
+- (void)cancelHeadingRequest:(INTUHeadingRequestID)requestID;
+
+#pragma mark - Additions
+
+/** It is possible to force enable background location fetch even if your set any kind of Authorizations */
+- (void)setBackgroundLocationUpdate:(BOOL) enabled;
+
+/**
+ Sets a Boolean indicating whether the status bar changes its appearance when location services
+ are used in the background.
+ 
+ This property affects only apps that received always authorization. When such an app moves to the background,
+ the system uses this property to determine whether to change the status bar appearance to indicate that
+ location services are in use. Displaying a modified status bar gives the user a quick way to return to your app.
+ The default value of this property is false.
+ 
+ For apps with when-in-use authorization, the system always changes the status bar appearance when
+ the app uses location services in the background.
+ 
+ @param shows           Boolean indicating whether the status bar changes its appearance when location services are used in the background.
+ */
+- (void)setShowsBackgroundLocationIndicator:(BOOL) shows;
+
+/**
+ Sets a Boolean value indicating whether the location manager object may pause location updates.
+ 
+ @param pauses           Boolean value indicating whether the location manager object may pause location updates.
+ */
+- (void)setPausesLocationUpdatesAutomatically:(BOOL) pauses;
+
+@end
+
+NS_ASSUME_NONNULL_END