@transistorsoft/capacitor-background-geolocation 8.0.1 → 9.0.1

package/dist/plugin.cjs.js

@@ -1,62 +1,68 @@
 'use strict';
 
 var core = require('@capacitor/core');
+var backgroundGeolocationTypes = require('@transistorsoft/background-geolocation-types');
 
-var Events = {
-    BOOT: "boot",
-    TERMINATE: "terminate",
-    LOCATION: "location",
-    HTTP: "http",
-    MOTIONCHANGE: "motionchange",
-    PROVIDERCHANGE: "providerchange",
-    HEARTBEAT: "heartbeat",
-    ACTIVITYCHANGE: "activitychange",
-    GEOFENCE: "geofence",
-    GEOFENCESCHANGE: "geofenceschange",
-    SCHEDULE: "schedule",
-    CONNECTIVITYCHANGE: "connectivitychange",
-    ENABLEDCHANGE: "enabledchange",
-    POWERSAVECHANGE: "powersavechange",
-    NOTIFICATIONACTION: "notificationaction",
-    AUTHORIZATION: "authorization",
-};
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
 
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : undefined, done: true };
-    }
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+  return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+      function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+  function verb(n) { return function (v) { return step([n, v]); }; }
+  function step(op) {
+      if (f) throw new TypeError("Generator is already executing.");
+      while (g && (g = 0, op[0] && (_ = 0)), _) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+              case 0: case 1: t = op; break;
+              case 4: _.label++; return { value: op[1], done: false };
+              case 5: _.label++; y = op[1]; op = [0]; continue;
+              case 7: op = _.ops.pop(); _.trys.pop(); continue;
+              default:
+                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                  if (t[2]) _.ops.pop();
+                  _.trys.pop(); continue;
+          }
+          op = body.call(thisArg, _);
+      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : undefined, done: true };
+  }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
+
 var NativeModule = core.registerPlugin('BackgroundGeolocation');
 /**
  * Logger
@@ -213,7 +219,10 @@ var TransistorAuthorizationToken = /** @class */ (function () {
             return config;
         var token = config.transistorAuthorizationToken;
         delete config.transistorAuthorizationToken;
-        config.url = token.url + LOCATIONS_PATH;
+        if (!config.http) {
+            config.http = {};
+        }
+        config.http.url = token.url + LOCATIONS_PATH;
         config.authorization = {
             strategy: 'JWT',
             accessToken: token.accessToken,
@@ -232,8 +241,10 @@ var TransistorAuthorizationToken = /** @class */ (function () {
 var IGNORE_BATTERY_OPTIMIZATIONS = "IGNORE_BATTERY_OPTIMIZATIONS";
 var POWER_MANAGER = "POWER_MANAGER";
 var resolveSettingsRequest = function (resolve, request) {
-    if (request.lastSeenAt > 0) {
-        request.lastSeenAt = new Date(request.lastSeenAt);
+    // lastSeenAt arrives from the native bridge as a unix timestamp (number); convert to Date.
+    var lastSeenAt = request.lastSeenAt;
+    if (lastSeenAt > 0) {
+        request.lastSeenAt = new Date(lastSeenAt);
     }
     resolve(request);
 };
@@ -284,8 +295,8 @@ var DeviceSettings = /** @class */ (function () {
 var TAG = "TSLocationManager";
 /// Container for event-subscriptions.
 var EVENT_SUBSCRIPTIONS = [];
-/// Container for watchPostion subscriptions.
-var WATCH_POSITION_SUBSCRIPTIONS = [];
+/// Container for watchPosition subscriptions, keyed by watchId.
+var WATCH_POSITION_SUBSCRIPTIONS = new Map();
 /// Event handler Subscription
 ///
 var Subscription = /** @class */ (function () {
@@ -296,148 +307,175 @@ var Subscription = /** @class */ (function () {
     }
     return Subscription;
 }());
-/// Validate provided config for #ready, #setConfig, #reset.
-var validateConfig = function (config) {
-    // Detect obsolete notification* fields and re-map to Notification instance.
-    if ((config.notificationPriority) ||
-        (config.notificationText) ||
-        (config.notificationTitle) ||
-        (config.notificationChannelName) ||
-        (config.notificationColor) ||
-        (config.notificationSmallIcon) ||
-        (config.notificationLargeIcon)) {
-        console.warn('[BackgroundGeolocation] WARNING: Config.notification* fields (eg: notificationText) are all deprecated in favor of notification: {title: "My Title", text: "My Text"}  See docs for "Notification" class');
-        config.notification = {
-            text: config.notificationText,
-            title: config.notificationTitle,
-            color: config.notificationColor,
-            channelName: config.notificationChannelName,
-            smallIcon: config.notificationSmallIcon,
-            largeIcon: config.notificationLargeIcon,
-            priority: config.notificationPriority
-        };
-    }
-    config = TransistorAuthorizationToken.applyIf(config);
-    return config;
-};
-var LOG_LEVEL_OFF = 0;
-var LOG_LEVEL_ERROR = 1;
-var LOG_LEVEL_WARNING = 2;
-var LOG_LEVEL_INFO = 3;
-var LOG_LEVEL_DEBUG = 4;
-var LOG_LEVEL_VERBOSE = 5;
-var DESIRED_ACCURACY_NAVIGATION = -2;
-var DESIRED_ACCURACY_HIGH = -1;
-var DESIRED_ACCURACY_MEDIUM = 10;
-var DESIRED_ACCURACY_LOW = 100;
-var DESIRED_ACCURACY_VERY_LOW = 1000;
-var DESIRED_ACCURACY_LOWEST = 3000;
-var AUTHORIZATION_STATUS_NOT_DETERMINED = 0;
-var AUTHORIZATION_STATUS_RESTRICTED = 1;
-var AUTHORIZATION_STATUS_DENIED = 2;
-var AUTHORIZATION_STATUS_ALWAYS = 3;
-var AUTHORIZATION_STATUS_WHEN_IN_USE = 4;
-var NOTIFICATION_PRIORITY_DEFAULT = 0;
-var NOTIFICATION_PRIORITY_HIGH = 1;
-var NOTIFICATION_PRIORITY_LOW = -1;
-var NOTIFICATION_PRIORITY_MAX = 2;
-var NOTIFICATION_PRIORITY_MIN = -2;
-var ACTIVITY_TYPE_OTHER = 1;
-var ACTIVITY_TYPE_AUTOMOTIVE_NAVIGATION = 2;
-var ACTIVITY_TYPE_FITNESS = 3;
-var ACTIVITY_TYPE_OTHER_NAVIGATION = 4;
-var ACTIVITY_TYPE_AIRBORNE = 5;
-var LOCATION_AUTHORIZATION_ALWAYS = "Always";
-var LOCATION_AUTHORIZATION_WHEN_IN_USE = "WhenInUse";
-var LOCATION_AUTHORIZATION_ANY = "Any";
-var PERSIST_MODE_ALL = 2;
-var PERSIST_MODE_LOCATION = 1;
-var PERSIST_MODE_GEOFENCE = -1;
-var PERSIST_MODE_NONE = 0;
-var ACCURACY_AUTHORIZATION_FULL = 0;
-var ACCURACY_AUTHORIZATION_REDUCED = 1;
+var LOG_LEVEL_OFF = backgroundGeolocationTypes.LogLevel.Off;
+var LOG_LEVEL_ERROR = backgroundGeolocationTypes.LogLevel.Error;
+var LOG_LEVEL_WARNING = backgroundGeolocationTypes.LogLevel.Warning;
+var LOG_LEVEL_INFO = backgroundGeolocationTypes.LogLevel.Info;
+var LOG_LEVEL_DEBUG = backgroundGeolocationTypes.LogLevel.Debug;
+var LOG_LEVEL_VERBOSE = backgroundGeolocationTypes.LogLevel.Verbose;
+var DESIRED_ACCURACY_NAVIGATION = backgroundGeolocationTypes.DesiredAccuracy.Navigation;
+var DESIRED_ACCURACY_HIGH = backgroundGeolocationTypes.DesiredAccuracy.High;
+var DESIRED_ACCURACY_MEDIUM = backgroundGeolocationTypes.DesiredAccuracy.Medium;
+var DESIRED_ACCURACY_LOW = backgroundGeolocationTypes.DesiredAccuracy.Low;
+var DESIRED_ACCURACY_VERY_LOW = backgroundGeolocationTypes.DesiredAccuracy.VeryLow;
+var DESIRED_ACCURACY_LOWEST = backgroundGeolocationTypes.DesiredAccuracy.Lowest;
+var AUTHORIZATION_STATUS_NOT_DETERMINED = backgroundGeolocationTypes.AuthorizationStatus.NotDetermined;
+var AUTHORIZATION_STATUS_RESTRICTED = backgroundGeolocationTypes.AuthorizationStatus.Restricted;
+var AUTHORIZATION_STATUS_DENIED = backgroundGeolocationTypes.AuthorizationStatus.Denied;
+var AUTHORIZATION_STATUS_ALWAYS = backgroundGeolocationTypes.AuthorizationStatus.Always;
+var AUTHORIZATION_STATUS_WHEN_IN_USE = backgroundGeolocationTypes.AuthorizationStatus.WhenInUse;
+var NOTIFICATION_PRIORITY_DEFAULT = backgroundGeolocationTypes.NotificationPriority.Default;
+var NOTIFICATION_PRIORITY_HIGH = backgroundGeolocationTypes.NotificationPriority.High;
+var NOTIFICATION_PRIORITY_LOW = backgroundGeolocationTypes.NotificationPriority.Low;
+var NOTIFICATION_PRIORITY_MAX = backgroundGeolocationTypes.NotificationPriority.Max;
+var NOTIFICATION_PRIORITY_MIN = backgroundGeolocationTypes.NotificationPriority.Min;
+var ACTIVITY_TYPE_OTHER = backgroundGeolocationTypes.ActivityType.Other;
+var ACTIVITY_TYPE_AUTOMOTIVE_NAVIGATION = backgroundGeolocationTypes.ActivityType.AutomotiveNavigation;
+var ACTIVITY_TYPE_FITNESS = backgroundGeolocationTypes.ActivityType.Fitness;
+var ACTIVITY_TYPE_OTHER_NAVIGATION = backgroundGeolocationTypes.ActivityType.OtherNavigation;
+var ACTIVITY_TYPE_AIRBORNE = backgroundGeolocationTypes.ActivityType.Airborne;
+var LOCATION_AUTHORIZATION_ALWAYS = backgroundGeolocationTypes.LocationRequest.Always;
+var LOCATION_AUTHORIZATION_WHEN_IN_USE = backgroundGeolocationTypes.LocationRequest.WhenInUse;
+var LOCATION_AUTHORIZATION_ANY = backgroundGeolocationTypes.LocationRequest.Any;
+var PERSIST_MODE_ALL = backgroundGeolocationTypes.PersistMode.All;
+var PERSIST_MODE_LOCATION = backgroundGeolocationTypes.PersistMode.Location;
+var PERSIST_MODE_GEOFENCE = backgroundGeolocationTypes.PersistMode.Geofence;
+var PERSIST_MODE_NONE = backgroundGeolocationTypes.PersistMode.None;
+var ACCURACY_AUTHORIZATION_FULL = backgroundGeolocationTypes.AccuracyAuthorization.Full;
+var ACCURACY_AUTHORIZATION_REDUCED = backgroundGeolocationTypes.AccuracyAuthorization.Reduced;
 /// BackgroundGeolocation JS API
 var BackgroundGeolocation = /** @class */ (function () {
     function BackgroundGeolocation() {
     }
+    Object.defineProperty(BackgroundGeolocation, "LogLevel", {
+        get: function () { return backgroundGeolocationTypes.LogLevel; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "DesiredAccuracy", {
+        get: function () { return backgroundGeolocationTypes.DesiredAccuracy; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "PersistMode", {
+        get: function () { return backgroundGeolocationTypes.PersistMode; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "AuthorizationStatus", {
+        get: function () { return backgroundGeolocationTypes.AuthorizationStatus; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "AccuracyAuthorization", {
+        get: function () { return backgroundGeolocationTypes.AccuracyAuthorization; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "AuthorizationStrategy", {
+        get: function () { return backgroundGeolocationTypes.AuthorizationStrategy; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "LocationFilterPolicy", {
+        get: function () { return backgroundGeolocationTypes.LocationFilterPolicy; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "KalmanProfile", {
+        get: function () { return backgroundGeolocationTypes.KalmanProfile; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "HttpMethod", {
+        get: function () { return backgroundGeolocationTypes.HttpMethod; },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BackgroundGeolocation, "TriggerActivity", {
+        get: function () { return backgroundGeolocationTypes.TriggerActivity; },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(BackgroundGeolocation, "EVENT_BOOT", {
         /// Events
-        get: function () { return Events.BOOT; },
+        get: function () { return backgroundGeolocationTypes.Event.Boot; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_TERMINATE", {
-        get: function () { return Events.TERMINATE; },
+        get: function () { return backgroundGeolocationTypes.Event.Terminate; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_LOCATION", {
-        get: function () { return Events.LOCATION; },
+        get: function () { return backgroundGeolocationTypes.Event.Location; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_MOTIONCHANGE", {
-        get: function () { return Events.MOTIONCHANGE; },
+        get: function () { return backgroundGeolocationTypes.Event.MotionChange; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_HTTP", {
-        get: function () { return Events.HTTP; },
+        get: function () { return backgroundGeolocationTypes.Event.Http; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_HEARTBEAT", {
-        get: function () { return Events.HEARTBEAT; },
+        get: function () { return backgroundGeolocationTypes.Event.Heartbeat; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_PROVIDERCHANGE", {
-        get: function () { return Events.PROVIDERCHANGE; },
+        get: function () { return backgroundGeolocationTypes.Event.ProviderChange; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_ACTIVITYCHANGE", {
-        get: function () { return Events.ACTIVITYCHANGE; },
+        get: function () { return backgroundGeolocationTypes.Event.ActivityChange; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_GEOFENCE", {
-        get: function () { return Events.GEOFENCE; },
+        get: function () { return backgroundGeolocationTypes.Event.Geofence; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_GEOFENCESCHANGE", {
-        get: function () { return Events.GEOFENCESCHANGE; },
+        get: function () { return backgroundGeolocationTypes.Event.GeofencesChange; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_ENABLEDCHANGE", {
-        get: function () { return Events.ENABLEDCHANGE; },
+        get: function () { return backgroundGeolocationTypes.Event.EnabledChange; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_CONNECTIVITYCHANGE", {
-        get: function () { return Events.CONNECTIVITYCHANGE; },
+        get: function () { return backgroundGeolocationTypes.Event.ConnectivityChange; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_SCHEDULE", {
-        get: function () { return Events.SCHEDULE; },
+        get: function () { return backgroundGeolocationTypes.Event.Schedule; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_POWERSAVECHANGE", {
-        get: function () { return Events.POWERSAVECHANGE; },
+        get: function () { return backgroundGeolocationTypes.Event.PowerSaveChange; },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_NOTIFICATIONACTION", {
-        get: function () { return Events.NOTIFICATIONACTION; },
+        get: function () { return "notificationaction"; } // <-- TODO : Add to background-geolocation-types
+        ,
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(BackgroundGeolocation, "EVENT_AUTHORIZATION", {
-        get: function () { return Events.AUTHORIZATION; },
+        get: function () { return backgroundGeolocationTypes.Event.Authorization; },
         enumerable: false,
         configurable: true
     });
@@ -632,10 +670,10 @@ var BackgroundGeolocation = /** @class */ (function () {
         configurable: true
     });
     BackgroundGeolocation.ready = function (config) {
-        return NativeModule.ready({ options: validateConfig(config) });
+        return NativeModule.ready({ options: config });
     };
     BackgroundGeolocation.reset = function (config) {
-        return NativeModule.reset({ options: validateConfig(config) });
+        return NativeModule.reset({ options: config });
     };
     BackgroundGeolocation.start = function () {
         return NativeModule.start();
@@ -653,7 +691,7 @@ var BackgroundGeolocation = /** @class */ (function () {
         return NativeModule.startGeofences();
     };
     BackgroundGeolocation.setConfig = function (config) {
-        return NativeModule.setConfig({ options: validateConfig(config) });
+        return NativeModule.setConfig({ options: config });
     };
     BackgroundGeolocation.getState = function () {
         return NativeModule.getState();
@@ -677,48 +715,63 @@ var BackgroundGeolocation = /** @class */ (function () {
             });
         });
     };
-    BackgroundGeolocation.watchPosition = function (onLocation, onError, options) {
-        var _this = this;
+    BackgroundGeolocation.watchPosition = function (options, onLocation, onError) {
         options = options || {};
-        return new Promise(function (resolve, reject) { return __awaiter(_this, undefined, undefined, function () {
-            var handler, listener;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        handler = function (response) {
-                            if (response.hasOwnProperty("error") && (response.error != null)) {
-                                if (typeof (onError) === 'function') {
-                                    onError(response.error.code);
-                                }
-                                else {
-                                    console.warn('[BackgroundGeolocation watchPostion] DEFAULT ERROR HANDLER.  Provide an onError handler to watchPosition to receive this message: ', response.error);
-                                }
-                            }
-                            else {
-                                onLocation(response);
-                            }
-                        };
-                        return [4 /*yield*/, NativeModule.addListener("watchposition", handler)];
-                    case 1:
-                        listener = _a.sent();
-                        NativeModule.watchPosition({ options: options }).then(function () {
-                            WATCH_POSITION_SUBSCRIPTIONS.push(listener);
-                            resolve();
-                        }).catch(function (error) {
-                            listener.remove();
-                            reject(error.message);
-                        });
-                        return [2 /*return*/];
+        var isRemoved = false;
+        var nativeWatchId = null;
+        var subscriptionProxy = {
+            remove: function () {
+                isRemoved = true;
+                if (nativeWatchId !== null) {
+                    var listener = WATCH_POSITION_SUBSCRIPTIONS.get(nativeWatchId);
+                    if (listener) {
+                        listener.remove();
+                        WATCH_POSITION_SUBSCRIPTIONS.delete(nativeWatchId);
+                    }
+                    NativeModule.stopWatchPosition({ watchId: nativeWatchId });
+                    nativeWatchId = null;
                 }
+            }
+        };
+        var handler = function (response) {
+            if (response.hasOwnProperty("error") && (response.error != null)) {
+                if (typeof (onError) === 'function') {
+                    onError(response.error.code);
+                }
+                else {
+                    console.warn('[BackgroundGeolocation watchPosition] DEFAULT ERROR HANDLER.  Provide an onError callback to watchPosition to receive this message: ', response.error);
+                }
+            }
+            else {
+                onLocation(response);
+            }
+        };
+        NativeModule.addListener("watchposition", handler).then(function (listener) {
+            NativeModule.watchPosition({ options: options }).then(function (result) {
+                nativeWatchId = result.watchId;
+                if (isRemoved) {
+                    // remove() was called before the native async call resolved — honour it now.
+                    listener.remove();
+                    NativeModule.stopWatchPosition({ watchId: nativeWatchId });
+                }
+                else {
+                    WATCH_POSITION_SUBSCRIPTIONS.set(nativeWatchId, listener);
+                }
+            }).catch(function () {
+                listener.remove();
             });
-        }); });
+        });
+        return subscriptionProxy;
     };
-    BackgroundGeolocation.stopWatchPosition = function () {
-        for (var n = 0; n < WATCH_POSITION_SUBSCRIPTIONS.length; n++) {
-            var subscription = WATCH_POSITION_SUBSCRIPTIONS[n];
-            subscription.remove();
+    BackgroundGeolocation.stopWatchPosition = function (watchId) {
+        if (watchId !== undefined) {
+            var listener = WATCH_POSITION_SUBSCRIPTIONS.get(watchId);
+            if (listener) {
+                listener.remove();
+                WATCH_POSITION_SUBSCRIPTIONS.delete(watchId);
+            }
+            NativeModule.stopWatchPosition({ watchId: watchId });
         }
-        return NativeModule.stopWatchPosition();
     };
     BackgroundGeolocation.requestPermission = function () {
         return new Promise(function (resolve, reject) {
@@ -953,55 +1006,52 @@ var BackgroundGeolocation = /** @class */ (function () {
     };
     /// Event Handling
     ///
-    BackgroundGeolocation.onLocation = function (success, failure) {
-        return BackgroundGeolocation.addListener(Events.LOCATION, success, failure);
+    BackgroundGeolocation.onLocation = function (cb, onError) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.Location, cb, onError);
     };
-    BackgroundGeolocation.onMotionChange = function (success) {
-        return BackgroundGeolocation.addListener(Events.MOTIONCHANGE, success);
+    BackgroundGeolocation.onMotionChange = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.MotionChange, cb);
     };
-    BackgroundGeolocation.onHttp = function (success) {
-        return BackgroundGeolocation.addListener(Events.HTTP, success);
+    BackgroundGeolocation.onHttp = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.Http, cb);
     };
-    BackgroundGeolocation.onHeartbeat = function (success) {
-        return BackgroundGeolocation.addListener(Events.HEARTBEAT, success);
+    BackgroundGeolocation.onHeartbeat = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.Heartbeat, cb);
     };
-    BackgroundGeolocation.onProviderChange = function (success) {
-        return BackgroundGeolocation.addListener(Events.PROVIDERCHANGE, success);
+    BackgroundGeolocation.onProviderChange = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.ProviderChange, cb);
     };
-    BackgroundGeolocation.onActivityChange = function (success) {
-        return BackgroundGeolocation.addListener(Events.ACTIVITYCHANGE, success);
+    BackgroundGeolocation.onActivityChange = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.ActivityChange, cb);
     };
-    BackgroundGeolocation.onGeofence = function (success) {
-        return BackgroundGeolocation.addListener(Events.GEOFENCE, success);
+    BackgroundGeolocation.onGeofence = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.Geofence, cb);
     };
-    BackgroundGeolocation.onGeofencesChange = function (success) {
-        return BackgroundGeolocation.addListener(Events.GEOFENCESCHANGE, success);
+    BackgroundGeolocation.onGeofencesChange = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.GeofencesChange, cb);
     };
-    BackgroundGeolocation.onSchedule = function (success) {
-        return BackgroundGeolocation.addListener(Events.SCHEDULE, success);
+    BackgroundGeolocation.onSchedule = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.Schedule, cb);
     };
-    BackgroundGeolocation.onEnabledChange = function (success) {
-        return BackgroundGeolocation.addListener(Events.ENABLEDCHANGE, success);
+    BackgroundGeolocation.onEnabledChange = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.EnabledChange, cb);
     };
-    BackgroundGeolocation.onConnectivityChange = function (success) {
-        return BackgroundGeolocation.addListener(Events.CONNECTIVITYCHANGE, success);
+    BackgroundGeolocation.onConnectivityChange = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.ConnectivityChange, cb);
     };
-    BackgroundGeolocation.onPowerSaveChange = function (success) {
-        return BackgroundGeolocation.addListener(Events.POWERSAVECHANGE, success);
+    BackgroundGeolocation.onPowerSaveChange = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.PowerSaveChange, cb);
     };
-    BackgroundGeolocation.onNotificationAction = function (success) {
-        return BackgroundGeolocation.addListener(Events.NOTIFICATIONACTION, success);
+    BackgroundGeolocation.onNotificationAction = function (cb) {
+        return BackgroundGeolocation.addListener("notificationaction", cb);
     };
-    BackgroundGeolocation.onAuthorization = function (success) {
-        return BackgroundGeolocation.addListener(Events.AUTHORIZATION, success);
+    BackgroundGeolocation.onAuthorization = function (cb) {
+        return BackgroundGeolocation.addListener(backgroundGeolocationTypes.Event.Authorization, cb);
     };
     ///
     /// Listen to a plugin event
     ///
     BackgroundGeolocation.addListener = function (event, success, failure) {
-        if (!Events[event.toUpperCase()]) {
-            throw (TAG + "#addListener - Unknown event '" + event + "'");
-        }
         var handler = function (response) {
             if (response.hasOwnProperty("value")) {
                 response = response.value;