Implementing 3 new features requested by Lorin Metzger.

README.md

@@ -20,8 +20,8 @@ The plugin creates the object `window.plugins.backgroundGeoLocation` with the me
 
   `changePace(true) // engages aggressive monitoring immediately`
   
-  `onStationary(callback, fail)`
-  
+  `onChangePace(callback, fail)`
+
   `addGeofence(config, callback, fail)`
   
   `removeGeofence(identifier, callback, fail)` 
@@ -276,7 +276,14 @@ bgGeo.changePace(true);  // <-- Aggressive GPS monitoring immediately engaged.
 bgGeo.changePace(false); // <-- Disable aggressive GPS monitoring.  Engages stationary-mode.
 ```
 
-####`onStationary(callbackFn, failureFn)`
+####`onChangePace(callbackFn, failureFn)`
+Your ```callbackFn``` will be executed each time the device has changed-state between **MOVING** or **STATIONARY.  The ```callbackFn``` will be provided with a ```Location``` object as the 1st param, with the usual params (```latitude, longitude, accuracy, speed, bearing, altitude```), in addition to a ```taskId``` used to signal that your callback is finished.
+
+######@param {Boolean} isMoving `false` if entered **STATIONARY** mode; `true` if entered **MOVING** mode.
+######@param {Object} location The location at the state-change.
+######@param {Integer} taskId The taskId used to send to bgGeo.finish(taskId) in order to signal completion of your callbackFn
+
+####`onStationary(callbackFn, failureFn)` **DEPRECATED &mdash; Use `onChangePace` instead.
 Your ```callbackFn``` will be executed each time the device has entered stationary-monitoring mode.  The ```callbackFn``` will be provided with a ```Location``` object as the 1st param, with the usual params (```latitude, longitude, accuracy, speed, bearing, altitude```), in addition to a ```taskId``` used to signal that your callback is finished.
 
 ######@param {Object} location The Location data
@@ -651,13 +658,29 @@ An interval of 0 is allowed, but not recommended, since location updates may be
 
 the desired time between activity detections. Larger values will result in fewer activity detections while improving battery life. A value of 0 will result in activity detections at the fastest possible rate.
 
+####`@param {Integer millis} minimumActivityRecognitionConfidence` 
+
+Each activity-recognition-result returned by the API is tagged with a "confidence" level expressed as a %.  You can set your desired confidence to trigger a state-change.  Defaults to `80`.
+
+####`@param {String} triggerActivities`
+
+These are the comma-delimited list of [activity-names](https://developers.google.com/android/reference/com/google/android/gms/location/DetectedActivity) returned by the `ActivityRecognition` API which will trigger a state-change from **stationary** to **moving**.  By default, this list is set to all five **moving-states**:  `"in_vehicle, on_bicycle, on_foot, running, walking"`.  If you wish, you could configure the plugin to only engage **moving-mode** for vehicles by providing only `"in_vehicle"`.
+
 ####`@param {Integer minutes} stopTimeout`
 
 The number of miutes to wait before turning off the GPS after the ActivityRecognition System (ARS) detects the device is ```STILL``` (defaults to 0, no timeout).  If you don't set a value, the plugin is eager to turn off the GPS ASAP.  An example use-case for this configuration is to delay GPS OFF while in a car waiting at a traffic light.
 
-####`@param {Boolean} forceReload`
+####`@param {Boolean} forceReloadOnMotionChange`
+
+If the user closes the application while the background-tracking has been started,  location-tracking will continue on if ```stopOnTerminate: false```.  You may choose to force the foreground application to reload (since this is where your Javascript runs).  `forceReloadOnMotionChange: true` will reload the app only when a state-change occurs from **stationary -> moving** or vice-versa. (**WARNING** possibly disruptive to user).
+
+####`@param {Boolean} forceReloadOnLocationChange`
+
+If the user closes the application while the background-tracking has been started,  location-tracking will continue on if ```stopOnTerminate: false```.  You may choose to force the foreground application to reload (since this is where your Javascript runs).  `forceReloadOnLocationChange: true` will reload the app when a new location is recorded.
+
+####`@param {Boolean} forceReloadOnGeofence`
 
-If the user closes the application while the background-tracking has been started,  location-tracking will continue on if ```stopOnTerminate: false```.  You may choose to force the foreground application to reload (since this is where your Javascript runs) by setting ```foreceReload: true```.  This will guarantee that locations are always sent to your Javascript callback (**WARNING** possibly disruptive to user).
+If the user closes the application while the background-tracking has been started,  location-tracking will continue on if ```stopOnTerminate: false```.  You may choose to force the foreground application to reload (since this is where your Javascript runs).  `forceReloadOnGeolocation: true` will reload the app only when a geofence crossing event has occurred.
 
 ####`@param {Boolean} startOnBoot`
 

src/ios/CDVBackgroundGeolocation.h

@@ -14,15 +14,17 @@
 @property (nonatomic, strong) NSString* locationCallbackId;
 @property (nonatomic, strong) NSMutableArray* geofenceListeners;
 @property (nonatomic, strong) NSMutableArray* stationaryRegionListeners;
+@property (nonatomic, strong) NSMutableArray* motionChangeListeners;
 
 - (void) configure:(CDVInvokedUrlCommand*)command;
 - (void) start:(CDVInvokedUrlCommand*)command;
 - (void) stop:(CDVInvokedUrlCommand*)command;
 - (void) finish:(CDVInvokedUrlCommand*)command;
 - (void) error:(CDVInvokedUrlCommand*)command;
-- (void) onPaceChange:(CDVInvokedUrlCommand*)command;
+- (void) changePace:(CDVInvokedUrlCommand*)command;
 - (void) setConfig:(CDVInvokedUrlCommand*)command;
 - (void) addStationaryRegionListener:(CDVInvokedUrlCommand*)command;
+- (void) addMotionChangeListener:(CDVInvokedUrlCommand*)command;
 - (void) getStationaryLocation:(CDVInvokedUrlCommand *)command;
 - (void) getLocations:(CDVInvokedUrlCommand *)command;
 - (void) sync:(CDVInvokedUrlCommand *)command;

src/ios/CDVBackgroundGeolocation.m

@@ -10,14 +10,14 @@
     NSDictionary *config;
 }
 
-@synthesize syncCallbackId, syncTaskId, locationCallbackId, geofenceListeners, stationaryRegionListeners;
+@synthesize syncCallbackId, syncTaskId, locationCallbackId, geofenceListeners, stationaryRegionListeners, motionChangeListeners;
 
 - (void)pluginInitialize
 {
     bgGeo = [[TSLocationManager alloc] init];
     
     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onLocationChanged:) name:@"TSLocationManager.location" object:nil];
-    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onStationaryLocation:) name:@"TSLocationManager.stationary" object:nil];
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onMotionChange:) name:@"TSLocationManager.motionchange" object:nil];
     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onEnterGeofence:) name:@"TSLocationManager.geofence" object:nil];
     [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(onSyncComplete:) name:@"TSLocationManager.sync" object:nil];
 }
@@ -78,10 +78,10 @@
  * Change pace to moving/stopped
  * @param {Boolean} isMoving
  */
-- (void) onPaceChange:(CDVInvokedUrlCommand *)command
+- (void) changePace:(CDVInvokedUrlCommand *)command
 {
     BOOL moving = [[command.arguments objectAtIndex: 0] boolValue];
-    [bgGeo onPaceChange:moving];
+    [bgGeo changePace:moving];
 }
 
 /**
@@ -102,16 +102,35 @@
     }];
 }
 
-- (void) onStationaryLocation:(NSNotification*)notification
+
+- (void) onMotionChange:(NSNotification*)notification
 {
-    if (![self.stationaryRegionListeners count]) {
+    if (![self.stationaryRegionListeners count] && ![self.motionChangeListeners count]) {
         return;
     }
-    CLLocation *location = [notification.userInfo objectForKey:@"location"];   
-    NSDictionary *locationData = [bgGeo locationToDictionary:location];
+    BOOL isMoving               = [[notification.userInfo objectForKey:@"isMoving"] boolValue];
+    CLLocation *location        = [notification.userInfo objectForKey:@"location"];
+    NSDictionary *locationData  = [bgGeo locationToDictionary:location];
 
-    for (NSString *callbackId in self.stationaryRegionListeners) {
+    // @deprecated stationaryRegionListeners in favour of dual-function motionChangeListeners
+    if (!isMoving) {
+        for (NSString *callbackId in self.stationaryRegionListeners) {
+            NSLog(@"- CALLBACK: %@", callbackId);
+            NSDictionary *params = @{
+                @"isMoving": @(isMoving),
+                @"location": locationData,
+                @"taskId": @([bgGeo createBackgroundTask])
+            };
+            CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:params];
+            [result setKeepCallbackAsBool:YES];
+            [self.commandDelegate runInBackground:^{
+                [self.commandDelegate sendPluginResult:result callbackId:callbackId];
+            }];
+        }
+    }
+    for (NSString *callbackId in self.motionChangeListeners) {
         NSDictionary *params = @{
+            @"isMoving": @(isMoving),
             @"location": locationData,
             @"taskId": @([bgGeo createBackgroundTask])
         };
@@ -120,7 +139,6 @@
         [self.commandDelegate runInBackground:^{
             [self.commandDelegate sendPluginResult:result callbackId:callbackId];
         }];
-        
     }
 }
 
@@ -149,6 +167,9 @@
 
 - (void) onSyncComplete:(NSNotification*)notification
 {
+    if (syncCallbackId == nil) {
+        return;
+    }
     NSDictionary *params = @{
         @"locations": [notification.userInfo objectForKey:@"locations"],
         @"taskId": @(syncTaskId)
@@ -217,6 +238,14 @@
     [self.stationaryRegionListeners addObject:command.callbackId];
 }
 
+- (void) addMotionChangeListener:(CDVInvokedUrlCommand*)command
+{
+    if (self.motionChangeListeners == nil) {
+        self.motionChangeListeners = [[NSMutableArray alloc] init];
+    }
+    [self.motionChangeListeners addObject:command.callbackId];
+}
+
 - (void) addGeofence:(CDVInvokedUrlCommand*)command
 {
     NSDictionary *cfg  = [command.arguments objectAtIndex:0];

src/ios/TSLocationManager.framework/Versions/1/Headers/TSLocationManager.h

@@ -14,7 +14,7 @@
 - (UIBackgroundTaskIdentifier) createBackgroundTask;
 - (void) stopBackgroundTask:(UIBackgroundTaskIdentifier)taskId;
 - (void) error:(UIBackgroundTaskIdentifier)taskId message:(NSString*)message;
-- (void) onPaceChange:(BOOL)value;
+- (void) changePace:(BOOL)value;
 - (void) setConfig:(NSDictionary*)command;
 - (NSDictionary*) getStationaryLocation;
 - (void) onSuspend:(NSNotification *)notification;

src/ios/TSLocationManager.framework/Versions/1/Resources/_CodeSignature/CodeResources

@@ -6,7 +6,7 @@
 	<dict>
 		<key>Headers/TSLocationManager.h</key>
 		<data>
-		++tA66F/FJQ/qMup0fGBER20r9U=
+		XspAWrxbSpr4Vn4KKi6gq+GKYz4=
 		</data>
 		<key>Info.plist</key>
 		<data>
@@ -21,7 +21,7 @@
 	<dict>
 		<key>Headers/TSLocationManager.h</key>
 		<data>
-		++tA66F/FJQ/qMup0fGBER20r9U=
+		XspAWrxbSpr4Vn4KKi6gq+GKYz4=
 		</data>
 		<key>Modules/module.modulemap</key>
 		<data>

www/BackgroundGeoLocation.js

@@ -83,7 +83,7 @@ module.exports = {
         exec(success || function() {},
             failure || function() {},
             'BackgroundGeoLocation',
-            'onPaceChange',
+            'changePace',
             [isMoving]);
     },
     /**
@@ -112,6 +112,7 @@ module.exports = {
     },
     /**
     * Add a stationary-region listener.  Whenever the devices enters "stationary-mode", your #success callback will be executed with #location param containing #radius of region
+    * @deprecated in favour of dual-function #onMotionChange
     * @param {Function} success
     * @param {Function} failure [optional] NOT IMPLEMENTED
     */
@@ -136,6 +137,35 @@ module.exports = {
             'addStationaryRegionListener',
             []);
     },
+    /**
+    * Add a movement-state-change listener.  Whenever the devices enters "stationary" or "moving" mode, your #success callback will be executed with #location param containing #radius of region
+    * @param {Function} success
+    * @param {Function} failure [optional] NOT IMPLEMENTED
+    */
+    onMotionChange: function(success, failure) {
+        var me = this;
+        success = success || function(isMoving, location, taskId) {
+            me.finish(taskId);
+        };
+        var callback = function(params) {
+            var isMoving    = params.isMoving;
+            var location    = params.location;
+            var taskId      = params.taskId || 'task-id-undefined';
+            
+            if (!isMoving) {
+                me.stationaryLocation = location;
+            }
+
+            me._runBackgroundTask(taskId, function() {
+                success.call(me, isMoving, location, taskId);
+            }, failure);
+        };
+        exec(callback,
+            failure || function() {},
+            'BackgroundGeoLocation',
+            'addMotionChangeListener',
+            []);
+    },
     getLocations: function(success, failure) {
         if (typeof(success) !== 'function') {
             throw "BackgroundGeolocation#getLocations requires a success callback";