@josuelmm/cordova-background-geolocation 4.2.3 → 4.5.2

package/android/common/src/main/java/com/marianhello/bgloc/sync/BatchManager.java

@@ -188,12 +188,22 @@ public class BatchManager {
         }
 
         private void writeValue(Object value) throws IOException {
-            if (value instanceof String ) {
+            if (value == null || value == JSONObject.NULL) {
+                writer.nullValue();
+            } else if (value instanceof String ) {
                 writer.value((String) value);
             } else if (value instanceof Map) {
                 writeMap((Map) value);
             } else if (value instanceof List) {
                 writeList((List) value);
+            // v4.5.1 — handle JSONArray / JSONObject so that placeholders that resolve to
+            // structured data (@events → JSONArray of events) are written as real JSON arrays /
+            // objects, not as escaped strings. Without this, a fix coming out of the sync queue
+            // serialised "events" as "[{\"type\":\"hardBrake\"}]" literal.
+            } else if (value instanceof org.json.JSONArray) {
+                writeJsonArray((org.json.JSONArray) value);
+            } else if (value instanceof org.json.JSONObject) {
+                writeJsonObject((org.json.JSONObject) value);
             } else if (Integer.class.isInstance(value)) {
                 writer.value((Integer) value);
             } else if (Double.class.isInstance(value)) {
@@ -204,13 +214,44 @@ public class BatchManager {
                 writer.value((Long) value);
             } else if (Boolean.class.isInstance(value)) {
                 writer.value((Boolean) value);
-            } else if (value == JSONObject.NULL) {
-                writer.nullValue();
             } else {
                 writer.value(String.valueOf(value));
             }
         }
 
+        private void writeJsonArray(org.json.JSONArray arr) throws IOException {
+            writer.beginArray();
+            for (int i = 0; i < arr.length(); i++) {
+                Object v = arr.opt(i);
+                writeValue(v == null ? JSONObject.NULL : v);
+            }
+            writer.endArray();
+        }
+
+        private void writeJsonObject(org.json.JSONObject obj) throws IOException {
+            writer.beginObject();
+            Iterator<String> keys = obj.keys();
+            while (keys.hasNext()) {
+                String k = keys.next();
+                writer.name(k);
+                writeValue(obj.opt(k));
+            }
+            writer.endObject();
+        }
+
+        /** v4.5.1 — resolve a template string. If it is a placeholder ("@foo") and the location
+         *  has no value, return JSONObject.NULL so the writer emits `null` instead of the literal
+         *  "@foo" string. */
+        private Object resolveTemplateValue(Object value) {
+            if (value instanceof String) {
+                String s = (String) value;
+                Object resolved = location.getValueForKey(s);
+                if (resolved != null) return resolved;
+                if (s.startsWith("@")) return JSONObject.NULL;
+            }
+            return value;
+        }
+
         public void writeMap(Map values) throws IOException {
             writer.beginObject();
             Iterator<?> it = values.entrySet().iterator();
@@ -218,12 +259,8 @@ public class BatchManager {
                 Map.Entry<String, Object> pair = (Map.Entry) it.next();
                 String key = pair.getKey();
                 Object value = pair.getValue();
-                Object locationValue = null;
-                if (value instanceof String) {
-                    locationValue = location.getValueForKey((String)value);
-                }
                 writer.name(key);
-                writeValue(locationValue != null ? locationValue : value);
+                writeValue(resolveTemplateValue(value));
             }
             writer.endObject();
         }
@@ -233,11 +270,7 @@ public class BatchManager {
             Iterator<?> it = values.iterator();
             while (it.hasNext()) {
                 Object value = it.next();
-                Object locationValue = null;
-                if (value instanceof  String) {
-                    locationValue = location.getValueForKey((String) value);
-                }
-                writeValue(locationValue != null ? locationValue : value);
+                writeValue(resolveTemplateValue(value));
             }
             writer.endArray();
         }

package/ios/CDVBackgroundGeolocation/CDVBackgroundGeolocation.m

@@ -135,6 +135,28 @@ static NSString * const TAG = @"CDVBackgroundGeolocation";
                                 callbackId:command.callbackId];
 }
 
+// v4.5: runtime permission helpers — paridad de API con Android. iOS no expone gates
+// separados para background location / activity recognition / notifications, así que
+// resolvemos siempre con notRequired:YES.
+- (void) requestBackgroundLocationPermission:(CDVInvokedUrlCommand *)command
+{
+    [self sendNotRequiredPermissionResult:command];
+}
+- (void) requestActivityRecognitionPermission:(CDVInvokedUrlCommand *)command
+{
+    [self sendNotRequiredPermissionResult:command];
+}
+- (void) requestNotificationPermission:(CDVInvokedUrlCommand *)command
+{
+    [self sendNotRequiredPermissionResult:command];
+}
+- (void) sendNotRequiredPermissionResult:(CDVInvokedUrlCommand *)command
+{
+    NSDictionary *r = @{ @"granted": @YES, @"notRequired": @YES };
+    [self.commandDelegate sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:r]
+                                callbackId:command.callbackId];
+}
+
 // v4.1 GPS-derived sensor-like events
 - (void) sendDrivingEventN:(NSString *)name note:(NSNotification *)note
 {
@@ -513,7 +535,7 @@ static NSString * const TAG = @"CDVBackgroundGeolocation";
 - (void) getPluginVersion:(CDVInvokedUrlCommand*)command
 {
     NSLog(@"%@ #%@", TAG, @"getPluginVersion");
-    NSString *version = @"4.2.3"; // keep in sync with plugin.xml and Android PLUGIN_VERSION
+    NSString *version = @"4.5.2"; // keep in sync with plugin.xml and Android PLUGIN_VERSION
     CDVPluginResult *result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:version];
     [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
 }

package/ios/common/BackgroundGeolocation/MAURActivityLocationProvider.m

@@ -5,43 +5,59 @@
 //  Created by Marian Hello on 14/09/2016.
 //  Copyright © 2016 mauron85. All rights reserved.
 //
+//  v4.5.2 — refactored to use CoreMotion's CMMotionActivityManager directly.
+//  The SOMotionDetector dependency (sources + plugin.xml entries) was removed
+//  in this version.
+//
 
 #import <Foundation/Foundation.h>
+#import <CoreMotion/CoreMotion.h>
 #import "MAURActivityLocationProvider.h"
 #import "MAURActivity.h"
-#import "SOMotionDetector.h"
 #import "MAURLocationManager.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)
-
 static NSString * const TAG = @"ActivityLocationProvider";
 static NSString * const Domain = @"com.marianhello";
 
-@interface MAURActivityLocationProvider () <SOMotionDetectorDelegate>
-@end
+// Local motion-type enum (replaces the legacy SOMotionType used previously).
+typedef NS_ENUM(NSUInteger, MAURMotionType) {
+    MAURMotionTypeUnknown = 0,
+    MAURMotionTypeNotMoving,
+    MAURMotionTypeWalking,
+    MAURMotionTypeRunning,
+    MAURMotionTypeAutomotive,
+    MAURMotionTypeCycling
+};
 
 @implementation MAURActivityLocationProvider {
     BOOL isStarted;
     BOOL isTracking;
-    SOMotionType lastMotionType;
+    BOOL motionAvailable;
+    BOOL motionPermissionErrorEmitted;
+    MAURMotionType lastMotionType;
 
     MAURLocationManager *locationManager;
+    CMMotionActivityManager *activityManager;
+    NSOperationQueue *activityQueue;
+
+    // v4.5.2: cache of active config so motion callbacks can read
+    // activityConfidenceThreshold without re-fetching.
+    MAURConfig *currentConfig;
 }
 
 - (instancetype) init
 {
     self = [super init];
-    
+
     if (self) {
         isStarted = NO;
         isTracking = NO;
+        motionAvailable = NO;
+        motionPermissionErrorEmitted = NO;
+        lastMotionType = MAURMotionTypeUnknown;
     }
-    
+
     return self;
 }
 
@@ -49,52 +65,197 @@ static NSString * const Domain = @"com.marianhello";
     locationManager = [MAURLocationManager sharedInstance];
     locationManager.delegate = self;
 
-    SOMotionDetector *motionDetector = [SOMotionDetector sharedInstance];
-    motionDetector.delegate = self;
-    if (SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(@"7.0")) {
-        motionDetector.useM7IfAvailable = YES; //Use M7 chip if available, otherwise use lib's algorithm
+    // v4.5.2 — CoreMotion direct. Without CMMotionActivityManager support the
+    // provider cannot drive STILL/ACTIVE transitions; emit a clear error so the
+    // host app knows to fall back to DISTANCE_FILTER or RAW.
+    motionAvailable = [CMMotionActivityManager isActivityAvailable];
+    if (!motionAvailable) {
+        DDLogError(@"%@ CMMotionActivityManager unavailable on this device; ACTIVITY_PROVIDER will be inert.", TAG);
+        NSError *err = [NSError errorWithDomain:Domain
+                                           code:MAURBGServiceError
+                                       userInfo:@{ NSLocalizedDescriptionKey: @"CMMotionActivityManager unavailable on this device." }];
+        if (self.delegate && [self.delegate respondsToSelector:@selector(onError:)]) {
+            [self.delegate onError:err];
+        }
+        return;
     }
+
+    activityManager = [[CMMotionActivityManager alloc] init];
+    activityQueue = [[NSOperationQueue alloc] init];
+    activityQueue.name = @"MAURActivityRecognitionQueue";
+    activityQueue.maxConcurrentOperationCount = 1;
 }
 
 - (BOOL) onConfigure:(MAURConfig*)config error:(NSError * __autoreleasing *)outError
 {
     DDLogVerbose(@"%@ configure", TAG);
-    
+
+    currentConfig = config;
+
     locationManager.pausesLocationUpdatesAutomatically = [config pauseLocationUpdates];
     locationManager.activityType = [config decodeActivityType];
     locationManager.distanceFilter = config.distanceFilter.integerValue; // meters
     locationManager.desiredAccuracy = [config decodeDesiredAccuracy];
-    [SOMotionDetector sharedInstance].activityDetectionInterval = config.activitiesInterval.intValue / 1000;
-    
+
     return YES;
 }
 
 - (BOOL) onStart:(NSError * __autoreleasing *)outError
 {
     DDLogInfo(@"%@ will start", TAG);
-    
-    if (!isStarted) {
-        [[SOMotionDetector sharedInstance] startDetection];
+
+    if (isStarted) {
+        return YES;
+    }
+
+    if (!motionAvailable || activityManager == nil) {
+        // No motion service: degrade gracefully — keep emitting raw location
+        // changes via the manager, but the STILL/ACTIVE state machine is off.
         [self startTracking];
         isStarted = YES;
+        return YES;
+    }
+
+    // iOS 11+: surface motion-permission denial up-front so the host app can
+    // re-prompt. Older iOS versions deliver permission errors via the handler.
+    if (@available(iOS 11.0, *)) {
+        CMAuthorizationStatus authStatus = [CMMotionActivityManager authorizationStatus];
+        if (authStatus == CMAuthorizationStatusDenied || authStatus == CMAuthorizationStatusRestricted) {
+            if (!motionPermissionErrorEmitted) {
+                NSError *err = [NSError errorWithDomain:Domain
+                                                   code:MAURBGServiceError
+                                               userInfo:@{ NSLocalizedDescriptionKey: @"Motion & Fitness permission denied; ACTIVITY_PROVIDER cannot detect STILL/ACTIVE." }];
+                if (self.delegate && [self.delegate respondsToSelector:@selector(onError:)]) {
+                    [self.delegate onError:err];
+                }
+                motionPermissionErrorEmitted = YES;
+            }
+            // Still start raw tracking so locations flow.
+            [self startTracking];
+            isStarted = YES;
+            return YES;
+        }
     }
-    
+
+    __weak typeof(self) weakSelf = self;
+    [activityManager startActivityUpdatesToQueue:activityQueue
+                                     withHandler:^(CMMotionActivity * _Nullable activity) {
+        typeof(self) strongSelf = weakSelf;
+        if (strongSelf == nil || activity == nil) return;
+        [strongSelf handleActivityUpdate:activity];
+    }];
+
+    // v4.5.2 — start tracking immediately. Without this, if the user opens the
+    // app while already still, CoreMotion fires STILL first and `handleActivityUpdate`
+    // never calls startTracking (its rule is "ACTIVE → start"), so no fix is ever
+    // produced and the initial stationary is never emitted. Mirrors the legacy
+    // SOMotionDetector behavior. If CoreMotion subsequently confirms STILL, the
+    // first incoming fix will trigger `onStationaryChanged` + `stopTracking`, so
+    // battery cost stays bounded.
+    [self startTracking];
+
+    isStarted = YES;
     return YES;
 }
 
 - (BOOL) onStop:(NSError * __autoreleasing *)outError
 {
     DDLogInfo(@"%@ will stop", TAG);
-    
-    if (isStarted) {
-        [[SOMotionDetector sharedInstance] stopDetection];
-        [self stopTracking];
-        isStarted = NO;
+
+    if (!isStarted) {
+        return YES;
+    }
+
+    if (activityManager != nil) {
+        [activityManager stopActivityUpdates];
     }
-    
+    [self stopTracking];
+    isStarted = NO;
+
     return YES;
 }
 
+#pragma mark - CMMotionActivity → MAURActivity bridge
+
+- (void) handleActivityUpdate:(CMMotionActivity *)activity
+{
+    // CMMotionActivityConfidence: Low=0, Medium=1, High=2 → normalize to 0-100
+    // so activityConfidenceThreshold means the same thing as on Android.
+    int confidence;
+    switch (activity.confidence) {
+        case CMMotionActivityConfidenceLow:    confidence = 20; break;
+        case CMMotionActivityConfidenceMedium: confidence = 40; break;
+        case CMMotionActivityConfidenceHigh:   confidence = 80; break;
+        default:                               confidence = 0;  break;
+    }
+
+    NSNumber *thresholdN = currentConfig.activityConfidenceThreshold;
+    if (thresholdN != nil && confidence < thresholdN.intValue) {
+        DDLogDebug(@"%@ ignoring low-confidence activity confidence=%d threshold=%@", TAG, confidence, thresholdN);
+        return;
+    }
+
+    MAURMotionType motionType;
+    NSString *typeStr;
+    if (activity.automotive) {
+        motionType = MAURMotionTypeAutomotive;
+        typeStr = @"IN_VEHICLE";
+    } else if (activity.cycling) {
+        motionType = MAURMotionTypeCycling;
+        typeStr = @"ON_BICYCLE";
+    } else if (activity.running) {
+        motionType = MAURMotionTypeRunning;
+        typeStr = @"RUNNING";
+    } else if (activity.walking) {
+        motionType = MAURMotionTypeWalking;
+        typeStr = @"WALKING";
+    } else if (activity.stationary) {
+        motionType = MAURMotionTypeNotMoving;
+        typeStr = @"STILL";
+    } else {
+        // CoreMotion fired "unknown" or no specific motion flag set. Do NOT
+        // collapse this to NotMoving — under uncertainty we keep the current
+        // tracking state (legacy behavior was to stop on UNKNOWN, which paused
+        // GPS unexpectedly during low-confidence motion gaps).
+        motionType = MAURMotionTypeUnknown;
+        typeStr = @"UNKNOWN";
+    }
+
+    // Hop to main queue: location manager + delegate are main-thread-affine.
+    dispatch_async(dispatch_get_main_queue(), ^{
+        // UNKNOWN must not perturb the state machine: no emit, no lastMotionType
+        // mutation, no tracking change. Otherwise a sequence STILL → UNKNOWN
+        // would lose the STILL state and the next fix would be delivered as a
+        // regular location instead of stationary.
+        if (motionType == MAURMotionTypeUnknown) {
+            DDLogDebug(@"%@ ignoring UNKNOWN activity (state preserved, confidence=%d)", TAG, confidence);
+            return;
+        }
+
+        BOOL changed = (motionType != self->lastMotionType);
+        self->lastMotionType = motionType;
+
+        if (changed) {
+            DDLogDebug(@"%@ activityTypeChanged: %@ confidence=%d", TAG, typeStr, confidence);
+            MAURActivity *act = [[MAURActivity alloc] init];
+            act.type = typeStr;
+            act.confidence = [NSNumber numberWithInt:confidence];
+            if (super.delegate && [super.delegate respondsToSelector:@selector(onActivityChanged:)]) {
+                [super.delegate onActivityChanged:act];
+            }
+        }
+
+        // Tracking control:
+        // - ACTIVE motion (walking, running, automotive, cycling) → ensure tracking is on.
+        // - STILL → leave tracking running; it will be stopped after the next fix (legacy).
+        if (motionType != MAURMotionTypeNotMoving) {
+            [self startTracking];
+        }
+    });
+}
+
+#pragma mark - Location plumbing
+
 - (void) startTracking
 {
     if (isTracking) {
@@ -105,7 +266,9 @@ static NSString * const Domain = @"com.marianhello";
     if ([locationManager start:&error]) {
         isTracking = YES;
     } else {
-        [self.delegate onError:error];
+        if (self.delegate && [self.delegate respondsToSelector:@selector(onError:)]) {
+            [self.delegate onError:error];
+        }
     }
 }
 
@@ -129,9 +292,13 @@ static NSString * const Domain = @"com.marianhello";
 
 - (void) onLocationsChanged:(NSArray*)locations
 {
-    if (lastMotionType == MotionTypeNotMoving) {
+    // v4.5.2: while NotMoving we only emit the stationary fix; the previous
+    // code fell through and also delivered each location as onLocationChanged,
+    // which produced phantom "moving" rows during a STILL window.
+    if (lastMotionType == MAURMotionTypeNotMoving) {
         [self stopTracking];
         [self.delegate onStationaryChanged:[MAURLocation fromCLLocation:[locations lastObject]]];
+        return;
     }
 
     for (CLLocation *location in locations) {
@@ -140,45 +307,6 @@ static NSString * const Domain = @"com.marianhello";
     }
 }
 
-- (void)motionDetector:(SOMotionDetector *)motionDetector activityTypeChanged:(SOMotionActivity *)motionActivity;
-{
-    int confidence = motionActivity.confidence;
-    SOMotionType motionType = motionActivity.motionType;
-    lastMotionType = motionType;
-
-    if (motionType != MotionTypeNotMoving) {
-        [self startTracking];
-    } else {
-        // we delay tracking stop after location is found
-    }
-
-    NSString *type;
-    switch (motionType) {
-        case MotionTypeNotMoving:
-            type = @"STILL";
-            break;
-        case MotionTypeWalking:
-            type = @"WALKING";
-            break;
-        case MotionTypeRunning:
-            type = @"RUNNING";
-            break;
-        case MotionTypeAutomotive:
-            type = @"IN_VEHICLE";
-            break;
-        case MotionTypeUnknown:
-            type = @"UNKNOWN";
-            break;
-    }
-    
-    DDLogDebug(@"%@ activityTypeChanged: %@", TAG, type);
-    MAURActivity *activity = [[MAURActivity alloc] init];
-    activity.type = type;
-    activity.confidence = [NSNumber numberWithInt:confidence];
-    
-    [super.delegate onActivityChanged:activity];
-}
-
 - (void) onError:(NSError*)error
 {
     [self.delegate onError:error];
@@ -197,6 +325,16 @@ static NSString * const Domain = @"com.marianhello";
 - (void) onDestroy {
     DDLogInfo(@"Destroying %@ ", TAG);
     [self onStop:nil];
+
+    // v4.5.2: MAURLocationManager is a singleton shared with the other providers
+    // (RAW, DISTANCE). Release the delegate slot so a subsequent provider swap
+    // does not leave this destroyed instance as the active delegate.
+    if (locationManager != nil && locationManager.delegate == self) {
+        locationManager.delegate = nil;
+    }
+
+    activityManager = nil;
+    activityQueue = nil;
 }
 
 @end