@josuelmm/cordova-background-geolocation 3.1.1 → 4.2.0

package/ios/common/BackgroundGeolocation/MAURSensorFusionDetector.h

@@ -0,0 +1,41 @@
+//
+//  MAURSensorFusionDetector.h
+//  BackgroundGeolocation
+//
+//  v4.2 Phase 8 — Real sensor fusion detector for iOS.
+//  Uses CMMotionManager to sample userAcceleration (gravity removed) and rotationRate.
+//  Refines possibleCrash via accelerometer impact and detects phoneUsageWhileDriving.
+//
+
+#ifndef MAURSensorFusionDetector_h
+#define MAURSensorFusionDetector_h
+
+#import <Foundation/Foundation.h>
+
+@class MAURLocation;
+
+@protocol MAURSensorFusionListener <NSObject>
+- (void)onSensorCrashWithImpactG:(double)impactG location:(MAURLocation *)location;
+- (void)onPhoneUsageWhileDriving:(MAURLocation *)location;
+@end
+
+@interface MAURSensorFusionDetector : NSObject
+
+@property (nonatomic, weak)   id<MAURSensorFusionListener> listener;
+@property (nonatomic, assign) BOOL enabled;
+@property (nonatomic, assign) double crashImpactG;       // default 3.0
+@property (nonatomic, assign) NSTimeInterval crashCooldownMs;        // default 10000
+@property (nonatomic, assign) NSTimeInterval phoneUsageWindowMs;     // default 4000
+@property (nonatomic, assign) NSTimeInterval phoneUsageCooldownMs;   // default 60000
+
+@property (nonatomic, assign) BOOL tripActive;
+@property (nonatomic, strong) MAURLocation *lastLocation;
+
+- (instancetype)init;
+- (BOOL)isAvailable;
+- (void)start;
+- (void)stop;
+
+@end
+
+#endif /* MAURSensorFusionDetector_h */

package/ios/common/BackgroundGeolocation/MAURSensorFusionDetector.m

@@ -0,0 +1,137 @@
+//
+//  MAURSensorFusionDetector.m
+//  BackgroundGeolocation
+//
+//  v4.2 Phase 8 — sensor fusion detector implementation.
+//
+
+#import "MAURSensorFusionDetector.h"
+#import <CoreMotion/CoreMotion.h>
+#import <UIKit/UIKit.h>
+
+static const double kJitterGyroRadS  = 0.7;   // ~40 deg/s
+static const double kJitterAccelMps2 = 0.5;
+
+@interface MAURSensorFusionDetector ()
+@property (nonatomic, strong) CMMotionManager *motion;
+@property (nonatomic, strong) NSOperationQueue *queue;
+@property (nonatomic, assign) BOOL started;
+@property (nonatomic, assign) NSTimeInterval lastCrashAt;
+@property (nonatomic, assign) NSTimeInterval lastPhoneUsageAt;
+@property (nonatomic, assign) NSTimeInterval jitterAboveSince;
+@end
+
+@implementation MAURSensorFusionDetector
+
+- (instancetype)init {
+    if ((self = [super init])) {
+        _motion = [[CMMotionManager alloc] init];
+        _motion.deviceMotionUpdateInterval = 1.0 / 50.0; // 50 Hz
+        _queue = [[NSOperationQueue alloc] init];
+        _queue.name = @"MAURSensorFusionQueue";
+        _queue.maxConcurrentOperationCount = 1;
+        _enabled = NO;
+        _crashImpactG = 3.0;
+        _crashCooldownMs = 10000;
+        _phoneUsageWindowMs = 4000;
+        _phoneUsageCooldownMs = 60000;
+        _started = NO;
+        _lastCrashAt = 0;
+        _lastPhoneUsageAt = 0;
+        _jitterAboveSince = 0;
+    }
+    return self;
+}
+
+- (BOOL)isAvailable {
+    return self.motion.isDeviceMotionAvailable;
+}
+
+- (void)start {
+    @synchronized (self) {
+        if (self.started || !self.enabled) return;
+        if (![self.motion isDeviceMotionAvailable]) return;
+        __weak typeof(self) weakSelf = self;
+        [self.motion startDeviceMotionUpdatesToQueue:self.queue
+                                          withHandler:^(CMDeviceMotion * _Nullable motion, NSError * _Nullable error) {
+            if (!motion || error) return;
+            [weakSelf processMotion:motion];
+        }];
+        self.started = YES;
+    }
+}
+
+- (void)stop {
+    @synchronized (self) {
+        if (!self.started) return;
+        [self.motion stopDeviceMotionUpdates];
+        self.started = NO;
+        self.jitterAboveSince = 0;
+    }
+}
+
+- (void)processMotion:(CMDeviceMotion *)motion {
+    if (!self.enabled) return;
+    NSTimeInterval nowMs = [[NSDate date] timeIntervalSince1970] * 1000.0;
+
+    // userAcceleration is in g (gravity removed); convert magnitude to g and to m/s².
+    double ax = motion.userAcceleration.x;
+    double ay = motion.userAcceleration.y;
+    double az = motion.userAcceleration.z;
+    double accelMagG  = sqrt(ax*ax + ay*ay + az*az);            // g
+    double accelMagMs = accelMagG * 9.80665;                    // m/s²
+
+    double gx = motion.rotationRate.x;
+    double gy = motion.rotationRate.y;
+    double gz = motion.rotationRate.z;
+    double gyroMag = sqrt(gx*gx + gy*gy + gz*gz);               // rad/s
+
+    BOOL tripActiveNow = self.tripActive;
+    MAURLocation *loc = self.lastLocation;
+    id<MAURSensorFusionListener> l = self.listener;
+
+    // Crash detection
+    if (tripActiveNow && self.crashImpactG > 0 && accelMagG >= self.crashImpactG
+            && (nowMs - self.lastCrashAt) >= self.crashCooldownMs) {
+        self.lastCrashAt = nowMs;
+        if ([l respondsToSelector:@selector(onSensorCrashWithImpactG:location:)]) {
+            [l onSensorCrashWithImpactG:accelMagG location:loc];
+        }
+    }
+
+    // phoneUsageWhileDriving
+    if (!tripActiveNow) { self.jitterAboveSince = 0; return; }
+    BOOL screenOn = [self isScreenOnApprox];
+    if (!screenOn) { self.jitterAboveSince = 0; return; }
+
+    BOOL above = (accelMagMs >= kJitterAccelMps2) || (gyroMag >= kJitterGyroRadS);
+    if (above) {
+        if (self.jitterAboveSince == 0) self.jitterAboveSince = nowMs;
+        if ((nowMs - self.jitterAboveSince) >= self.phoneUsageWindowMs
+                && (nowMs - self.lastPhoneUsageAt) >= self.phoneUsageCooldownMs) {
+            self.lastPhoneUsageAt = nowMs;
+            self.jitterAboveSince = 0;
+            if ([l respondsToSelector:@selector(onPhoneUsageWhileDriving:)]) {
+                [l onPhoneUsageWhileDriving:loc];
+            }
+        }
+    } else {
+        self.jitterAboveSince = 0;
+    }
+}
+
+- (BOOL)isScreenOnApprox {
+    // Heuristic: app is foreground active => screen is on. Background sampling does
+    // not constitute phone usage while driving (passenger may have screen off too).
+    __block UIApplicationState state = UIApplicationStateBackground;
+    if ([NSThread isMainThread]) {
+        state = [UIApplication sharedApplication].applicationState;
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            state = [UIApplication sharedApplication].applicationState;
+        });
+    }
+    return state == UIApplicationStateActive;
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURSessionLocationContract.h

@@ -0,0 +1,29 @@
+//
+//  MAURSessionLocationContract.h
+//  BackgroundGeolocation
+//
+//  Session table for current recording route. Independent of sync; cleared on startSession/clearSession.
+//
+
+#ifndef MAURSessionLocationContract_h
+#define MAURSessionLocationContract_h
+
+#define LSC_TABLE_NAME "location_session"
+#define LSC_COLUMN_NAME_ID "id"
+#define LSC_COLUMN_NAME_TIME "time"
+#define LSC_COLUMN_NAME_ACCURACY "accuracy"
+#define LSC_COLUMN_NAME_SPEED "speed"
+#define LSC_COLUMN_NAME_BEARING "bearing"
+#define LSC_COLUMN_NAME_ALTITUDE "altitude"
+#define LSC_COLUMN_NAME_LATITUDE "latitude"
+#define LSC_COLUMN_NAME_LONGITUDE "longitude"
+#define LSC_COLUMN_NAME_PROVIDER "provider"
+#define LSC_COLUMN_NAME_LOCATION_PROVIDER "service_provider"
+#define LSC_COLUMN_NAME_STATUS "valid"
+#define LSC_COLUMN_NAME_RECORDED_AT "recorded_at"
+
+@interface MAURSessionLocationContract : NSObject
++ (NSString*) createTableSQL;
+@end
+
+#endif /* MAURSessionLocationContract_h */

package/ios/common/BackgroundGeolocation/MAURSessionLocationContract.m

@@ -0,0 +1,31 @@
+//
+//  MAURSessionLocationContract.m
+//  BackgroundGeolocation
+//
+
+#import <Foundation/Foundation.h>
+#import "MAURSQLiteHelper.h"
+#import "MAURSessionLocationContract.h"
+
+@implementation MAURSessionLocationContract
+
++ (NSString*) createTableSQL
+{
+    NSArray *columns = @[
+        @{ @"name": @LSC_COLUMN_NAME_ID, @"type": [SQLPrimaryKeyAutoIncColumnType sqlColumnWithType: kInteger]},
+        @{ @"name": @LSC_COLUMN_NAME_TIME, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_ACCURACY, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_SPEED, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_BEARING, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_ALTITUDE, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_LATITUDE, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_LONGITUDE, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_PROVIDER, @"type": [SQLColumnType sqlColumnWithType: kText]},
+        @{ @"name": @LSC_COLUMN_NAME_LOCATION_PROVIDER, @"type": [SQLColumnType sqlColumnWithType: kText]},
+        @{ @"name": @LSC_COLUMN_NAME_STATUS, @"type": [SQLColumnType sqlColumnWithType: kInteger]},
+        @{ @"name": @LSC_COLUMN_NAME_RECORDED_AT, @"type": [SQLColumnType sqlColumnWithType: kInteger]}
+    ];
+    return [MAURSQLiteHelper createTableSqlStatement:@LSC_TABLE_NAME columns:columns];
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURSessionLocationDAO.h

@@ -0,0 +1,25 @@
+//
+//  MAURSessionLocationDAO.h
+//  BackgroundGeolocation
+//
+//  Session storage for current route. Cleared on startSession/clearSession; not cleared by sync.
+//
+
+#ifndef MAURSessionLocationDAO_h
+#define MAURSessionLocationDAO_h
+
+#import <Foundation/Foundation.h>
+#import "MAURLocation.h"
+
+@interface MAURSessionLocationDAO : NSObject
++ (instancetype) sharedInstance;
+- (id) init NS_UNAVAILABLE;
+- (void) startSession;
+- (void) clearSession;
+- (BOOL) isSessionActive;
+- (void) persistSessionLocation:(MAURLocation*)location;
+- (NSArray<MAURLocation*>*) getSessionLocations;
+- (NSInteger) getSessionLocationsCount;
+@end
+
+#endif /* MAURSessionLocationDAO_h */

package/ios/common/BackgroundGeolocation/MAURSessionLocationDAO.m

@@ -0,0 +1,153 @@
+//
+//  MAURSessionLocationDAO.m
+//  BackgroundGeolocation
+//
+
+#import <Foundation/Foundation.h>
+#import "MAURGeolocationOpenHelper.h"
+#import "MAURSessionLocationContract.h"
+#import "MAURSessionLocationDAO.h"
+#import "MAURLocation.h"
+#import "FMDB.h"
+
+static NSString *const kSessionActiveKey = @"bgloc_session_active";
+
+@interface MAURSessionLocationDAO ()
+- (instancetype)initPrivate;
+@end
+
+@implementation MAURSessionLocationDAO {
+    FMDatabaseQueue* queue;
+    MAURGeolocationOpenHelper *helper;
+}
+
++ (instancetype) sharedInstance
+{
+    static MAURSessionLocationDAO *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[self alloc] initPrivate];
+    });
+    return instance;
+}
+
+- (instancetype) initPrivate
+{
+    if (self = [super init]) {
+        helper = [[MAURGeolocationOpenHelper alloc] init];
+        queue = [helper getWritableDatabase];
+    }
+    return self;
+}
+
+- (void) startSession
+{
+    [queue inDatabase:^(FMDatabase *database) {
+        NSString *sql = [NSString stringWithFormat:@"DELETE FROM %@", @LSC_TABLE_NAME];
+        [database executeUpdate:sql];
+    }];
+    [[NSUserDefaults standardUserDefaults] setBool:YES forKey:kSessionActiveKey];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+- (void) clearSession
+{
+    [queue inDatabase:^(FMDatabase *database) {
+        NSString *sql = [NSString stringWithFormat:@"DELETE FROM %@", @LSC_TABLE_NAME];
+        [database executeUpdate:sql];
+    }];
+    [[NSUserDefaults standardUserDefaults] setBool:NO forKey:kSessionActiveKey];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+- (BOOL) isSessionActive
+{
+    return [[NSUserDefaults standardUserDefaults] boolForKey:kSessionActiveKey];
+}
+
+- (void) persistSessionLocation:(MAURLocation*)location
+{
+    if (![self isSessionActive]) return;
+    if (!location || !location.time) return;
+    NSTimeInterval timestamp = [[NSDate date] timeIntervalSince1970];
+    NSNumber *recordedAt = [NSNumber numberWithDouble:timestamp];
+
+    NSString *sql = @"INSERT INTO " @LSC_TABLE_NAME @" ("
+        @LSC_COLUMN_NAME_TIME @"," @LSC_COLUMN_NAME_ACCURACY @"," @LSC_COLUMN_NAME_SPEED @","
+        @LSC_COLUMN_NAME_BEARING @"," @LSC_COLUMN_NAME_ALTITUDE @"," @LSC_COLUMN_NAME_LATITUDE @","
+        @LSC_COLUMN_NAME_LONGITUDE @"," @LSC_COLUMN_NAME_PROVIDER @"," @LSC_COLUMN_NAME_LOCATION_PROVIDER @","
+        @LSC_COLUMN_NAME_STATUS @"," @LSC_COLUMN_NAME_RECORDED_AT
+        @") VALUES (?,?,?,?,?,?,?,?,?,?,?)";
+
+    [queue inDatabase:^(FMDatabase *database) {
+        [database executeUpdate:sql,
+            [NSNumber numberWithDouble:[location.time timeIntervalSince1970]],
+            location.accuracy ?: @0,
+            location.speed ?: @0,
+            location.heading ?: @0,
+            location.altitude ?: @0,
+            location.latitude ?: @0,
+            location.longitude ?: @0,
+            location.provider ?: [NSNull null],
+            location.locationProvider ? [NSString stringWithFormat:@"%@", location.locationProvider] : [NSNull null],
+            @(1),
+            recordedAt
+        ];
+    }];
+}
+
+- (NSArray<MAURLocation*>*) getSessionLocations
+{
+    __block NSMutableArray* locations = [[NSMutableArray alloc] init];
+    NSString *sql = @"SELECT " @LSC_COLUMN_NAME_ID @"," @LSC_COLUMN_NAME_TIME @"," @LSC_COLUMN_NAME_ACCURACY @","
+        @LSC_COLUMN_NAME_SPEED @"," @LSC_COLUMN_NAME_BEARING @"," @LSC_COLUMN_NAME_ALTITUDE @","
+        @LSC_COLUMN_NAME_LATITUDE @"," @LSC_COLUMN_NAME_LONGITUDE @"," @LSC_COLUMN_NAME_PROVIDER @","
+        @LSC_COLUMN_NAME_LOCATION_PROVIDER @"," @LSC_COLUMN_NAME_STATUS @"," @LSC_COLUMN_NAME_RECORDED_AT
+        @" FROM " @LSC_TABLE_NAME @" ORDER BY " @LSC_COLUMN_NAME_RECORDED_AT;
+
+    [queue inDatabase:^(FMDatabase *database) {
+        FMResultSet *rs = [database executeQuery:sql];
+        while ([rs next]) {
+            MAURLocation *loc = [self convertToLocation:rs];
+            [locations addObject:loc];
+        }
+        [rs close];
+    }];
+    return locations;
+}
+
+- (NSInteger) getSessionLocationsCount
+{
+    __block NSInteger count = 0;
+    NSString *sql = [NSString stringWithFormat:@"SELECT COUNT(*) FROM %@", @LSC_TABLE_NAME];
+    [queue inDatabase:^(FMDatabase *database) {
+        FMResultSet *rs = [database executeQuery:sql];
+        if ([rs next]) {
+            count = [rs intForColumnIndex:0];
+        }
+        [rs close];
+    }];
+    return count;
+}
+
+- (MAURLocation*) convertToLocation:(FMResultSet*)rs
+{
+    MAURLocation *location = [[MAURLocation alloc] init];
+    location.locationId = [NSNumber numberWithLongLong:[rs longLongIntForColumnIndex:0]];
+    NSTimeInterval timestamp = [rs doubleForColumnIndex:1];
+    location.time = [NSDate dateWithTimeIntervalSince1970:timestamp];
+    location.accuracy = [NSNumber numberWithDouble:[rs doubleForColumnIndex:2]];
+    location.speed = [NSNumber numberWithDouble:[rs doubleForColumnIndex:3]];
+    location.heading = [NSNumber numberWithDouble:[rs doubleForColumnIndex:4]];
+    location.altitude = [NSNumber numberWithDouble:[rs doubleForColumnIndex:5]];
+    location.latitude = [NSNumber numberWithDouble:[rs doubleForColumnIndex:6]];
+    location.longitude = [NSNumber numberWithDouble:[rs doubleForColumnIndex:7]];
+    location.provider = [rs stringForColumnIndex:8];
+    location.locationProvider = [NSNumber numberWithInt:[rs intForColumnIndex:9]];
+    location.isValid = [rs intForColumnIndex:10] == 1 ? YES : NO;
+    NSTimeInterval recordedAt = [rs longForColumnIndex:11];
+    location.recordedAt = [NSDate dateWithTimeIntervalSince1970:recordedAt];
+    return location;
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURUrlTemplateResolver.h

@@ -0,0 +1,31 @@
+//
+//  MAURUrlTemplateResolver.h
+//  BackgroundGeolocation
+//
+//  Resolves placeholders like {lat}, {lon}, {timestamp_iso}, {device_id}, ...
+//  in a URL template using a single MAURLocation and an optional queryParams dictionary.
+//
+//  Placeholders not found in the location/queryParams are left as-is so partial templates
+//  (e.g. only static keys for batch mode) keep working.
+//
+
+#ifndef MAURUrlTemplateResolver_h
+#define MAURUrlTemplateResolver_h
+
+#import <Foundation/Foundation.h>
+
+@class MAURLocation;
+
+@interface MAURUrlTemplateResolver : NSObject
+
+/**
+ * Resolve placeholders in `template` using values from `location` and `queryParams`.
+ * Either may be nil. Returns the resolved URL (or the original template if no placeholders).
+ */
++ (NSString *)resolve:(NSString *)urlTemplate
+             location:(MAURLocation *)location
+          queryParams:(NSDictionary *)queryParams;
+
+@end
+
+#endif /* MAURUrlTemplateResolver_h */

package/ios/common/BackgroundGeolocation/MAURUrlTemplateResolver.m

@@ -0,0 +1,107 @@
+//
+//  MAURUrlTemplateResolver.m
+//  BackgroundGeolocation
+//
+
+#import "MAURUrlTemplateResolver.h"
+#import "MAURLocation.h"
+
+@implementation MAURUrlTemplateResolver
+
++ (NSString *)resolve:(NSString *)urlTemplate
+             location:(MAURLocation *)location
+          queryParams:(NSDictionary *)queryParams
+{
+    if (urlTemplate == nil || urlTemplate.length == 0) return urlTemplate;
+
+    NSDictionary *ctx = [self buildContext:location queryParams:queryParams];
+
+    NSError *error = nil;
+    NSRegularExpression *regex = [NSRegularExpression
+        regularExpressionWithPattern:@"\\{([a-zA-Z0-9_]+)\\}"
+        options:0
+        error:&error];
+    if (regex == nil) return urlTemplate;
+
+    NSMutableString *result = [NSMutableString stringWithString:urlTemplate];
+    NSArray *matches = [regex matchesInString:urlTemplate
+                                      options:0
+                                        range:NSMakeRange(0, urlTemplate.length)];
+
+    // Iterate in reverse so ranges don't shift.
+    for (NSTextCheckingResult *match in [matches reverseObjectEnumerator]) {
+        NSString *key = [urlTemplate substringWithRange:[match rangeAtIndex:1]];
+        NSString *value = ctx[key];
+        if (value != nil) {
+            NSString *encoded = [self urlEncode:value];
+            [result replaceCharactersInRange:[match range] withString:encoded];
+        }
+        // else: leave the placeholder as-is.
+    }
+    return result;
+}
+
++ (NSDictionary *)buildContext:(MAURLocation *)loc queryParams:(NSDictionary *)queryParams
+{
+    NSMutableDictionary *ctx = [NSMutableDictionary dictionary];
+
+    // queryParams first; location-derived values can override below.
+    if (queryParams != nil) {
+        for (id key in queryParams) {
+            id value = queryParams[key];
+            if (value != nil && value != [NSNull null]) {
+                ctx[key] = [NSString stringWithFormat:@"%@", value];
+            }
+        }
+    }
+
+    if (loc != nil) {
+        if (loc.latitude != nil) {
+            ctx[@"latitude"] = [loc.latitude stringValue];
+            ctx[@"lat"] = [loc.latitude stringValue];
+        }
+        if (loc.longitude != nil) {
+            ctx[@"longitude"] = [loc.longitude stringValue];
+            ctx[@"lon"] = [loc.longitude stringValue];
+        }
+        if (loc.time != nil) {
+            long long ms = (long long)([loc.time timeIntervalSince1970] * 1000.0);
+            ctx[@"time"] = [NSString stringWithFormat:@"%lld", ms];
+            ctx[@"timestamp"] = [NSString stringWithFormat:@"%lld", ms];
+            ctx[@"timestamp_iso"] = [self isoUtc:loc.time];
+        }
+        if (loc.speed != nil) ctx[@"speed"] = [loc.speed stringValue];
+        if (loc.altitude != nil) ctx[@"altitude"] = [loc.altitude stringValue];
+        if (loc.heading != nil) ctx[@"bearing"] = [loc.heading stringValue];
+        if (loc.accuracy != nil) ctx[@"accuracy"] = [loc.accuracy stringValue];
+        if (loc.provider != nil) ctx[@"provider"] = loc.provider;
+    }
+
+    return ctx;
+}
+
++ (NSString *)urlEncode:(NSString *)s
+{
+    if (s == nil) return @"";
+    NSCharacterSet *allowed = [NSCharacterSet URLQueryAllowedCharacterSet];
+    NSString *enc = [s stringByAddingPercentEncodingWithAllowedCharacters:allowed];
+    // URLQueryAllowedCharacterSet leaves "+" and "&" unescaped which is unsafe in values.
+    enc = [enc stringByReplacingOccurrencesOfString:@"&" withString:@"%26"];
+    enc = [enc stringByReplacingOccurrencesOfString:@"+" withString:@"%2B"];
+    return enc != nil ? enc : s;
+}
+
++ (NSString *)isoUtc:(NSDate *)date
+{
+    static NSDateFormatter *fmt = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        fmt = [[NSDateFormatter alloc] init];
+        fmt.dateFormat = @"yyyy-MM-dd'T'HH:mm:ss'Z'";
+        fmt.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"UTC"];
+        fmt.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+    });
+    return [fmt stringFromDate:date];
+}
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josuelmm/cordova-background-geolocation",
-  "version": "3.1.1",
+  "version": "4.2.0",
   "description": "Cordova Background Geolocation (fork actualizado)",
   "main": "./www/BackgroundGeolocation.js",
   "types": "./www/BackgroundGeolocation.d.ts",
@@ -64,6 +64,41 @@
         "cordova": ">=8.0.0",
         "cordova-android": ">=8.0.0",
         "cordova-ios": ">=6.0.0"
+      },
+      "3.3.0": {
+        "cordova": ">=10.0.0",
+        "cordova-android": ">=12.0.0",
+        "cordova-ios": ">=6.0.0"
+      },
+      "3.4.0": {
+        "cordova": ">=10.0.0",
+        "cordova-android": ">=12.0.0",
+        "cordova-ios": ">=6.2.0"
+      },
+      "3.5.0": {
+        "cordova": ">=10.0.0",
+        "cordova-android": ">=12.0.0",
+        "cordova-ios": ">=6.2.0"
+      },
+      "3.6.0": {
+        "cordova": ">=10.0.0",
+        "cordova-android": ">=12.0.0",
+        "cordova-ios": ">=6.2.0"
+      },
+      "4.0.0": {
+        "cordova": ">=10.0.0",
+        "cordova-android": ">=12.0.0",
+        "cordova-ios": ">=6.2.0"
+      },
+      "4.1.0": {
+        "cordova": ">=10.0.0",
+        "cordova-android": ">=12.0.0",
+        "cordova-ios": ">=6.2.0"
+      },
+      "4.2.0": {
+        "cordova": ">=10.0.0",
+        "cordova-android": ">=12.0.0",
+        "cordova-ios": ">=6.2.0"
       }
     }
   },