@situm/react-native 3.0.10 → 3.1.0

package/lib/module/sdk/index.js

@@ -1,47 +1,78 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/ban-types */
-import invariant from "invariant";
+
 import { NativeEventEmitter, NativeModules, Platform } from "react-native";
-export * from "./types/constants";
 import packageJson from "../../package.json";
 import { logError } from "../utils/logError";
-const LINKING_ERROR = `The package 'situm-react-native-plugin' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
+import { SdkNavigationUpdateType } from "./types/constants";
+import { exceptionWrapper, promiseWrapper } from "./utils";
+export * from "./types/constants";
+const LINKING_ERROR = `The package 'react-native' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
   ios: "- You have run 'pod install'\n",
   default: ""
 }) + "- You rebuilt the app after installing the package\n" + "- You are not using Expo managed workflow\n";
-const RNCSitumPlugin = NativeModules.RNCSitumPlugin ? NativeModules.RNCSitumPlugin : new Proxy({}, {
+const RNCSitumPlugin = NativeModules.RNCSitumPlugin || new Proxy({}, {
   get() {
     throw new Error(LINKING_ERROR);
   }
 });
 const SitumPluginEventEmitter = new NativeEventEmitter(RNCSitumPlugin);
-let positioningSubscriptions = [];
-let navigationSubscriptions = [];
+
+// TODO: these do not act as state, not reliable
+let positioningRunning = false;
+let navigationRunning = false;
 let realtimeSubscriptions = [];
-export default {
+export default class SitumPlugin {
+  /**
+   * Whether the positioning is currently in execution.
+   * @returns boolean
+   */
+  static positioningIsRunning = () => positioningRunning;
+
   /**
-   * Initializes SDK.
+   * Whether the navigation is currently in execution.
+   * @returns boolean
+   */
+  static navigationIsRunning = () => navigationRunning;
+
+  /**
+   * Initializes {@link SitumPlugin}.
    *
-   * You have to call this function prior any call to other method.
+   * This method must be called before invoking any other methods.
    * This method can be safely called many times as it will only initialise the SDK
    * if it is not already initialised.
+   *
+   * @returns void
+   * @throw Exception
    */
-  initSitumSDK: function () {
-    RNCSitumPlugin.initSitumSDK();
-  },
+  static init = () => {
+    return exceptionWrapper(() => {
+      RNCSitumPlugin.initSitumSDK();
+    });
+  };
+
   /**
    * Provides your API key to the Situm SDK.
    *
    * This key is generated for your application in the Dashboard.
    * Old credentials will be removed.
    *
-   * @param email user's email.
    * @param apiKey user's apikey.
-   * @param onSuccess callback to use when the function returns successfully
+   *
+   * @returns void
+   * @throw Exception
    */
-  setApiKey: function (email, apiKey, onSuccess) {
-    RNCSitumPlugin.setApiKey(email, apiKey, onSuccess);
-  },
+  static setApiKey = apiKey => {
+    return exceptionWrapper(_ref => {
+      let {
+        onCallback
+      } = _ref;
+      RNCSitumPlugin.setApiKey("email@email.com", apiKey, response => {
+        onCallback(response, "Failed to set API key.");
+      });
+    });
+  };
+
   /**
    * Provides user's email and password. This credentials will be used to obtain a
    * valid user token to authenticate the server request, when necessary. Token
@@ -50,297 +81,422 @@ export default {
    *
    * @param email user's email.
    * @param password user's password.
-   * @param onSuccess callback to use when the function returns successfully
+   *
+   * @returns void
+   * @throw Exception
    */
-  setUserPass: function (email, password, onSuccess) {
-    RNCSitumPlugin.setUserPass(email, password, onSuccess);
-  },
-  setDashboardURL: function (url, success) {
-    RNCSitumPlugin.setDashboardURL(url, success);
-  },
+  static setUserPass = (email, password) => {
+    return exceptionWrapper(_ref2 => {
+      let {
+        onCallback
+      } = _ref2;
+      RNCSitumPlugin.setUserPass(email, password, response => {
+        onCallback(response, "Failed to set user credentials.");
+      });
+    });
+  };
+
+  /**
+   * Sets the API's base URL to retrieve the data.
+   *
+   * @param url user's email.
+   *
+   * @returns void
+   * @throw Exception
+   */
+
+  static setDashboardURL = url => {
+    return exceptionWrapper(_ref3 => {
+      let {
+        onCallback
+      } = _ref3;
+      RNCSitumPlugin.setDashboardURL(url, response => {
+        onCallback(response, "Failed to set dashboard URL.");
+      });
+    });
+  };
+
   /**
    * Set to true if you want the SDK to download the configuration from the Situm API
-   * and use it by default. Right now it only affects the LocationRequest.
+   * and use it by default. Right now it only affects the {@link LocationRequest}.
    * Default value is true from SDK version 2.83.5
    *
-   * @param useRemoteConfig boolean
-   * @param success function called on sucess
+   * @param useRemoteConfig
+   *
+   * @returns void
+   * @throw Exception
    */
-  setUseRemoteConfig(useRemoteConfig, onSuccess) {
-    RNCSitumPlugin.setUseRemoteConfig(useRemoteConfig, onSuccess);
-  },
+  static setUseRemoteConfig = useRemoteConfig => {
+    return exceptionWrapper(_ref4 => {
+      let {
+        onCallback
+      } = _ref4;
+      RNCSitumPlugin.setUseRemoteConfig(useRemoteConfig ? "true" : "false", response => {
+        onCallback(response, "Failed to set remote config");
+      });
+    });
+  };
+
   /**
-   * Sets the maximum age of a cached response. If the cache response's age exceeds
-   * maxAge, it will not be used and a network request will be made.
+   * Sets the max seconds the cache is valid
    *
-   * @param cacheAge a non-negative integer
-   * @param success function called on success
+   * @returns void
+   * @throw Exception
    */
-  setCacheMaxAge: function (cacheAge, success) {
-    RNCSitumPlugin.setCacheMaxAge(cacheAge, success);
-  },
+  static setMaxCacheAge = cacheAge => {
+    return exceptionWrapper(_ref5 => {
+      let {
+        onCallback
+      } = _ref5;
+      RNCSitumPlugin.setCacheMaxAge(cacheAge, response => {
+        onCallback(response, "Failed to set cache max age");
+      });
+    });
+  };
+
+  /**
+   * Sets the SDK {@link ConfigurationOptions}.
+   *
+   * @param options {@link ConfigurationOptions}
+   *
+   * @returns void
+   * @throw Exception
+   */
+  static setConfiguration = options => {
+    return exceptionWrapper(() => {
+      if (options.useRemoteConfig !== undefined) {
+        SitumPlugin.setUseRemoteConfig(options.useRemoteConfig);
+      }
+      if (options.cacheMaxAge !== undefined) {
+        SitumPlugin.setMaxCacheAge(options.cacheMaxAge);
+      }
+
+      // Handle rest of configuration options
+    });
+  };
+
   /**
    * Invalidate all the resources in the cache
+   *
+   * @returns void
+   * @throw Exception
    */
-  invalidateCache: function () {
-    RNCSitumPlugin.invalidateCache();
-  },
+  static invalidateCache = () => {
+    return exceptionWrapper(() => {
+      RNCSitumPlugin.invalidateCache();
+    });
+  };
+
   /**
    * Gets the list of versions for the current plugin and environment
    *
-   * @param callback callback to use on success
+   * @returns void
+   * @throw Exception
    */
-  sdkVersions: function (callback) {
-    const versions = {
-      react_native: packageJson.version
-    };
-    if (Platform.OS === "ios") {
-      versions.ios = packageJson.sdkVersions.ios;
-    } else {
-      versions.android = packageJson.sdkVersions.android;
-    }
-    callback(versions);
-  },
+  static sdkVersion = () => {
+    return exceptionWrapper(_ref6 => {
+      let {
+        onSuccess
+      } = _ref6;
+      const versions = {
+        react_native: packageJson.version
+      };
+      if (Platform.OS === "ios") {
+        versions.ios = packageJson.sdkVersions.ios;
+      } else {
+        versions.android = packageJson.sdkVersions.android;
+      }
+      onSuccess(versions);
+    });
+  };
+
   /**
    * Returns the device identifier that has generated the location
    *
-   * @param callback function called on sucess, returns the id of the current device
+   * @returns void
+   * @throw Exception
    */
-  getDeviceId: function (callback) {
-    RNCSitumPlugin.getDeviceId(callback);
-  },
+  static getDeviceId = () => {
+    return exceptionWrapper(_ref7 => {
+      let {
+        onSuccess
+      } = _ref7;
+      RNCSitumPlugin.getDeviceId(onSuccess);
+    });
+  };
+
   /**
-   * Request authorization for the provided authentication
-   * and stores it internally for subsequent requests
+   * Downloads all the {@link Building}s for the current user.
    */
-  requestAuthorization: function () {
-    RNCSitumPlugin.requestAuthorization();
-  },
+  static fetchBuildings = () => {
+    return promiseWrapper(_ref8 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref8;
+      RNCSitumPlugin.fetchBuildings(onSuccess, onError);
+    });
+  };
+
   /**
-   * Download all the buildings for the current user
+   * Downloads all the building data for the selected building. This info includes
+   * {@link Floor}, indoor and outdoor {@link Poi}s, events and paths. Also it download floor
+   * maps and {@link PoiCategory} icons to local storage.
    *
-   * @param success function called on sucess, returns a list of Building objects
-   * @param error function called on failure, returns an error string
+   * @param building {@link Building}
    */
-  fetchBuildings: function (success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchBuildings(success, error || logError);
-  },
+  static fetchBuildingInfo = building => {
+    return promiseWrapper(_ref9 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref9;
+      RNCSitumPlugin.fetchBuildingInfo(building, onSuccess, onError);
+    });
+  };
+
   /**
-   * Download all the building data for the selected building. This info includes
-   * floors, indoor and outdoor POIs, events and paths. Also it download floor
-   * maps and POI category icons to local storage.
+   * (Experimental) Downloads the tiled-map of a certain building
    *
-   * @param building
-   * @param success function called on sucess, returns a list of Building objects
-   * @param error function called on failure, returns an error string
+   * @param building {@link Building} whose tiles will be downloaded
    */
-  fetchBuildingInfo: function (building, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchBuildingInfo(building, success, error || logError);
-  },
-  fetchTilesFromBuilding: function (building, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchTilesFromBuilding(building, success, error || logError);
-  },
+  static fetchTilesFromBuilding = building => {
+    return promiseWrapper(_ref10 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref10;
+      RNCSitumPlugin.fetchTilesFromBuilding(building, onSuccess, onError);
+    });
+  };
+
   /**
-   * Download all the floors of a building
+   * Downloads all the floors of a building
    *
-   * @param building
-   * @param success function called on sucess, returns a list of Floor objects
-   * @param error function called on failure, returns an error string
+   * @param building {@link Building}
    */
-  fetchFloorsFromBuilding: function (building, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchFloorsFromBuilding(building, success, error || logError);
-  },
+  static fetchFloorsFromBuilding = building => {
+    return promiseWrapper(_ref11 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref11;
+      RNCSitumPlugin.fetchFloorsFromBuilding(building, onSuccess, onError);
+    });
+  };
+
   /**
-   * Download the map image of a floor
+   * Downloads the map image of a {@link Floor}
    *
-   * @param floor the floor object. Not null.
-   * @param success function called on sucess, returns a list of Map url objects
-   * @param error function called on failure, returns an error string
+   * @param floor {@link Floor}
    */
-  fetchMapFromFloor: function (floor, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchMapFromFloor(floor, success, error || logError);
-  },
+  static fetchMapFromFloor = floor => {
+    return promiseWrapper(_ref12 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref12;
+      RNCSitumPlugin.fetchMapFromFloor(floor, onSuccess, onError);
+    });
+  };
+
   /**
-   * Get the geofences of a building
+   * Get the geofences of a {@link Building}
    *
-   * @param building
-   * @param success function called on sucess, returns a list of Building objects
-   * @param error function called on failure, returns an error string
+   * @param building {@link Building}
    */
-  fetchGeofencesFromBuilding: function (building, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchGeofencesFromBuilding(building, success, error || logError);
-  },
+  static fetchGeofencesFromBuilding = building => {
+    return promiseWrapper(_ref13 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref13;
+      RNCSitumPlugin.fetchGeofencesFromBuilding(building, onSuccess, onError);
+    });
+  };
+
   /**
-   * Get all POI categories, download and cache their icons asynchronously.
-   *
-   * @param success function called on sucess, returns a list of POI categories
-   * @param error function called on failure, returns an error string
+   * Get all {@link PoiCategory}, download and cache their icons asynchronously.
    */
-  fetchPoiCategories: function (success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchPoiCategories(success, error || logError);
-  },
+  static fetchPoiCategories = () => {
+    return promiseWrapper(_ref14 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref14;
+      RNCSitumPlugin.fetchPoiCategories(onSuccess, onError);
+    });
+  };
+
   /**
-   * Get the normal category icon for a category
+   * Get the normal {@link PoiIcon} for a category
    *
-   * @param category the category. Not null.
-   * @param success function called on sucess, returns the icon in normal state.
-   * @param error function called on failure, returns an error string
+   * @param category {@link PoiCategory}. Not null.
    */
-  fetchPoiCategoryIconNormal: function (category, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchPoiCategoryIconNormal(category, success, error || logError);
-  },
+  static fetchPoiCategoryIconNormal = category => {
+    return promiseWrapper(_ref15 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref15;
+      RNCSitumPlugin.fetchPoiCategoryIconNormal(category, onSuccess, onError);
+    });
+  };
+
   /**
-   * Get the selected category icon for a category
+   * Get the selected {@link PoiIcon} for a {@link PoiCategory}
    *
-   * @param category the category. Not null.
-   * @param success function called on sucess, returns the icon in selected state.
-   * @param error function called on failure, returns an error string
+   * @param category {@link PoiCategory}. Not null.
    */
-  fetchPoiCategoryIconSelected: function (category, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchPoiCategoryIconSelected(category, success, error || logError);
-  },
+  static fetchPoiCategoryIconSelected = category => {
+    return promiseWrapper(_ref16 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref16;
+      RNCSitumPlugin.fetchPoiCategoryIconSelected(category, onSuccess, onError);
+    });
+  };
+
   /**
-   * Download the indoor POIs of a building
+   * Download the indoor {@link Poi}s of a {@link Building}
    *
-   * @param building
-   * @param success function called on sucess, returns a list of POI objects
-   * @param error function called on failure, returns an error string
+   * @param building {@link Building}
    */
-  fetchIndoorPOIsFromBuilding: function (building, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchIndoorPOIsFromBuilding(building, success, error || logError);
-  },
-  /**
-   * Download the outdoor POIs of a building
-   *
-   * @param building
-   * @param success function called on sucess, returns a list of POI objects
-   * @param error function called on failure, returns an error string
-   */
-  fetchOutdoorPOIsFromBuilding: function (building, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchOutdoorPOIsFromBuilding(building, success, error || logError);
-  },
-  /**
-   * Download the events of a building
-   *
-   * @param building
-   * @param success Callback to asynchronously receive the events of a building. Not null.
-   * @param error function called on failure, returns an error string
-   */
-  fetchEventsFromBuilding: function (building, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.fetchEventsFromBuilding(building, success, error || logError);
-  },
+  static fetchIndoorPOIsFromBuilding = building => {
+    return promiseWrapper(_ref17 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref17;
+      RNCSitumPlugin.fetchIndoorPOIsFromBuilding(building, onSuccess, onError);
+    });
+  };
+
   /**
-   * Starts positioning with the configuration specified by the LocationRequest;
-   * computed geolocations, status codes and errors will be received through the LocationListener callbacks.
-   * You may call this method more than once, with the following effect:
+   * Download the outdoor {@link Poi}s of a {@link Building}
    *
-   *  - If you provide a new LocationRequest instance, positioning will be re-started
-   *    with the new positioning options specified by this new instance.
-   *  - If you provide a new LocationListener, the former LocationListener will be
-   *    replaced, therefore geolocations will be communicated to the new one.
-   *  - If neither LocationRequest nor LocationListener change, nothing will happen.
-   *    You may stop positioning at any time by calling the LocationManager.removeUpdates() method.
+   * @param building {@link Building}
+   */
+  static fetchOutdoorPOIsFromBuilding = building => {
+    return promiseWrapper(_ref18 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref18;
+      RNCSitumPlugin.fetchOutdoorPOIsFromBuilding(building, onSuccess, onError);
+    });
+  };
+
+  /**
+   * Starts positioning.
    *
-   * @param location callback to use when location is udpated
-   * @param status callback to use when the positioning status changes
-   * @param error callback to use when error is raised
-   * @param locationOptions hashmap with options
-   *
-   * @returns the id of the subscription
+   * @param {LocationRequest} locationRequest Positioning options to configure how positioning will behave
    */
-  startPositioning: function (location, status, error, options) {
-    this.requestAuthorization();
-    return this.startPositioningUpdates(location, status, error || logError, options || {});
-  },
-  startPositioningUpdates: function (location, status, error, options) {
-    // Remove old positioning subscriptions:
-    positioningSubscriptions.forEach(subscription => subscription === null || subscription === void 0 ? void 0 : subscription.remove());
-    positioningSubscriptions = [];
-    positioningSubscriptions.push(SitumPluginEventEmitter.addListener("locationChanged", location), SitumPluginEventEmitter.addListener("statusChanged", status), error ? SitumPluginEventEmitter.addListener("locationError", error || logError) : null);
-    // Call native:
-    RNCSitumPlugin.startPositioning(options || {});
-  },
+  static requestLocationUpdates = locationRequest => {
+    return exceptionWrapper(() => {
+      if (SitumPlugin.positioningIsRunning()) return;
+      RNCSitumPlugin.startPositioning(locationRequest || {});
+      positioningRunning = true;
+      SitumPlugin.onLocationUpdate(loc => {
+        if (!SitumPlugin.navigationIsRunning()) return;
+        SitumPlugin.updateNavigationWithLocation(loc);
+      });
+    });
+  };
+
   /**
    * Stops positioning, removing all location updates
-   *
-   * @param callback the callback to use when the function successfully ends
-   * @returns
    */
-  stopPositioning: function (callback) {
-    RNCSitumPlugin.stopPositioning(callback || logError);
-  },
+  static removeLocationUpdates = () => {
+    return exceptionWrapper(() => {
+      if (!SitumPlugin.positioningIsRunning()) return;
+      RNCSitumPlugin.stopPositioning(response => {
+        if (response.success) {
+          positioningRunning = false;
+        } else {
+          throw "Situm > hook > Could not stop positioning";
+        }
+      });
+    });
+  };
+
   /**
    * Calculates a route between two points. The result is provided
    * asynchronously using the callback.
    *
-   * @param directionParams
-   * @param success function called on sucess, returns a Route object
-   * @param error function called on failure, returns an error string
+   * @param building {@link Building}
+   * @param from {@link Point} route origin
+   * @param to {@link Point} route destination
+   * @param directionOptions {@link DirectionsOptions}
    */
-  requestDirections: function (directionParams, success, error) {
-    invariant(typeof success === "function", "Must provide a valid success callback.");
-    RNCSitumPlugin.requestDirections(directionParams, success, error || logError);
-  },
+  static requestDirections = (building, from, to, directionOptions) => {
+    return promiseWrapper(_ref19 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref19;
+      const params = [building, from, to, directionOptions || {}];
+      RNCSitumPlugin.requestDirections(params, onSuccess, onError);
+    });
+  };
+
   /**
    * Set the navigation params, and the listener that receives the updated
    * navigation progress.
    *
    * Can only exist one navigation with one listener at a time. If this method was
-   * previously invoked, but removeUpdates() wasn't, removeUpdates() is called internally.
+   * previously invoked, but removeLocationUpdates() wasn't, removeLocationUpdates()
+   * is called internally.
    *
-   * @param navigationUpdates
-   * @param error function called on failure, returns an error string
-   * @param options
+   * @param options {@link NavigationRequest}
    */
-  requestNavigationUpdates: function (navigationUpdates, error, options) {
-    RNCSitumPlugin.requestNavigationUpdates(options || {});
-    navigationSubscriptions.push(SitumPluginEventEmitter.addListener("navigationUpdated", navigationUpdates));
-    navigationSubscriptions.push(error ? SitumPluginEventEmitter.addListener("navigationError", error || logError) : null);
-  },
+  static requestNavigationUpdates = options => {
+    return exceptionWrapper(() => {
+      RNCSitumPlugin.requestNavigationUpdates(options || {});
+      navigationRunning = true;
+    });
+  };
+
   /**
    * Informs NavigationManager object the change of the user's location
    *
-   * @param location new Location of the user. If null, nothing is done
-   * @param success callback to use when the navigation updates
-   * @param error callback to use when an error on navigation udpates raises
+   * @param location new {@link Location} of the user. If null, nothing is done
    */
-  updateNavigationWithLocation: function (location, success, error) {
-    if (navigationSubscriptions.length === 0) {
-      error("No active navigation!!");
-      return;
-    }
-    RNCSitumPlugin.updateNavigationWithLocation(location, success, error || logError);
-  },
+  static updateNavigationWithLocation = location => {
+    return exceptionWrapper(_ref20 => {
+      let {
+        onSuccess,
+        onError
+      } = _ref20;
+      if (!SitumPlugin.navigationIsRunning()) {
+        throw "Situm > hook > No active navigation";
+      }
+      RNCSitumPlugin.updateNavigationWithLocation(location, onSuccess, onError);
+    });
+  };
+
   /**
    * Removes all location updates. This removes the internal state of the manager,
    * including the listener provided in requestNavigationUpdates(NavigationRequest,
    * NavigationListener), so it won't receive more progress updates.
    *
-   * @param callback
    */
-  removeNavigationUpdates: function (callback) {
-    for (let i = 0; i < navigationSubscriptions.length; i++) {
-      navigationSubscriptions[i].remove();
-    }
-    navigationSubscriptions = [];
-    RNCSitumPlugin.removeNavigationUpdates(callback || logError);
-  },
-  requestRealTimeUpdates: function (navigationUpdates, error, options) {
-    RNCSitumPlugin.requestRealTimeUpdates(options || {});
-    realtimeSubscriptions.push([SitumPluginEventEmitter.addListener("realtimeUpdated", navigationUpdates), error ? SitumPluginEventEmitter.addListener("realtimeError", error || logError) : null]);
-  },
+  static removeNavigationUpdates = () => {
+    return exceptionWrapper(_ref21 => {
+      let {
+        onCallback
+      } = _ref21;
+      if (!SitumPlugin.navigationIsRunning()) {
+        throw "Situm > hook > Navigation updates were not active.";
+      }
+      navigationRunning = false;
+      RNCSitumPlugin.removeNavigationUpdates(reponse => {
+        onCallback(reponse, "Failed to remove navigation updates");
+      });
+    });
+  };
+
   /**
    * Requests a real time devices positions
    *
@@ -348,44 +504,148 @@ export default {
    * @param error callback to use when an error on navigation udpates raises
    * @param options Represents the configuration for getting realtime devices positions in
    */
-  removeRealTimeUpdates: function (_callback) {
-    realtimeSubscriptions = [];
-    RNCSitumPlugin.removeRealTimeUpdates();
-  },
-  checkIfPointInsideGeofence: function (request, callback) {
-    invariant(typeof callback === "function", "Must provide a valid success callback.");
+
+  static requestRealTimeUpdates = (realtimeUpdates, error, options) => {
+    return exceptionWrapper(() => {
+      RNCSitumPlugin.requestRealTimeUpdates(options || {});
+      realtimeSubscriptions.push([SitumPluginEventEmitter.addListener("realtimeUpdated", realtimeUpdates), error ? SitumPluginEventEmitter.addListener("realtimeError", error || logError) : null]);
+    });
+  };
+
+  /**
+   * Removes all real time updates listners.
+   *
+   * @param _callback
+   */
+  static removeRealTimeUpdates = _callback => {
+    return exceptionWrapper(() => {
+      realtimeSubscriptions = [];
+      RNCSitumPlugin.removeRealTimeUpdates();
+    });
+  };
+
+  /**
+   * Checks if a point is inside a {@link Geofence}
+   *
+   */
+  static checkIfPointInsideGeofence = (request, callback) => {
     RNCSitumPlugin.checkIfPointInsideGeofence(request, callback);
-  },
+  };
+
   /**
-   * Callback that notifies when the user enters a geofence.
+   * Callback that notifies when the user enters a {@link Geofence}.
    *
    * In order to use correctly these callbacks you must know the following:
    *  - Positioning geofences (with trainer_metadata custom field) won't be notified.
    *  - These callbacks only work with indoor locations. Any outdoor location will
    *    produce a call to onExitedGeofences with the last positioned geofences as argument.
    *
-   * @param callback the function called when the user enters a geofence
+   * @param callback the function called when the user enters a {@link Geofence}
    */
-  onEnterGeofences: function (callback) {
+  static onEnterGeofences = callback => {
     RNCSitumPlugin.onEnterGeofences();
     // Adopts SDK behavior (setter):
-    SitumPluginEventEmitter.removeAllListeners("onEnterGeofences");
     SitumPluginEventEmitter.addListener("onEnterGeofences", callback);
-  },
+  };
+
   /**
-   * Callback that notifies when the user exits a geofence.
+   * Callback that notifies when the user exits a {@link Geofence}.
    *
    * In order to use correctly these callbacks you must know the following:
    *  - Positioning geofences (with trainer_metadata custom field) won't be notified.
    *  - These callbacks only work with indoor locations. Any outdoor location will
    *    produce a call to onExitedGeofences with the last positioned geofences as argument.
    *
-   * @param callback the function called when the user exits a geofence
+   * @param callback the function called when the user exits a {@link Geofence}
    */
-  onExitGeofences: function (callback) {
+  static onExitGeofences = callback => {
     RNCSitumPlugin.onExitGeofences();
-    SitumPluginEventEmitter.removeAllListeners("onExitGeofences");
     SitumPluginEventEmitter.addListener("onExitGeofences", callback);
-  }
-};
+  };
+
+  /**
+   * Callback that notifies when the user {@link Location} changes.
+   *
+   * @param callback the function called when the user {@link Location} changes
+   */
+  static onLocationUpdate = callback => {
+    SitumPluginEventEmitter.addListener("locationChanged", callback);
+  };
+
+  /**
+   * Callback that notifies when the user {@link LocationStatus} changes.
+   *
+   * @param callback the function called when the user {@link LocationStatus} changes
+   */
+  static onLocationStatus = callback => {
+    SitumPluginEventEmitter.addListener("statusChanged", callback);
+  };
+
+  /**
+   * Callback that notifies when there is an error while the user is positioining.
+   *
+   * @param callback the function called when there is an error
+   */
+  static onLocationError = callback => {
+    SitumPluginEventEmitter.addListener("locationError", callback);
+  };
+
+  /**
+   * Callback that notifies when the user stops positioning.
+   *
+   * @param callback the function called when the user stops positioning.
+   */
+  static onLocationStopped = callback => {
+    SitumPluginEventEmitter.addListener("locationStopped", callback);
+  };
+
+  /**
+   * Callback that notifies every navigation progress.
+   *
+   * @param callback the function called when there is a navigation progress.
+   */
+  static onNavigationProgress = callback => {
+    SitumPluginEventEmitter.addListener("navigationUpdated", progress => {
+      if (progress.type === SdkNavigationUpdateType.PROGRESS) {
+        callback(progress);
+      }
+    });
+  };
+
+  /**
+   * Callback that notifies when the user gets out of the current route
+   *
+   * @param callback the function called when the user gets out of the current route.
+   */
+  static onNavigationOutOfRoute = callback => {
+    SitumPluginEventEmitter.addListener("navigationUpdated", progress => {
+      if (progress.type === SdkNavigationUpdateType.OUT_OF_ROUTE) {
+        // TODO: maybe this causes the navigation to not work on oor?
+        callback();
+      }
+    });
+  };
+
+  /**
+   * Callback that notifies when the user finishes the route.
+   *
+   * @param callback the function called when the user finishes the route.
+   */
+  static onNavigationFinished = callback => {
+    SitumPluginEventEmitter.addListener("navigationUpdated", progress => {
+      if (progress.type === SdkNavigationUpdateType.FINISHED) {
+        callback();
+      }
+    });
+  };
+
+  /**
+   * Callback that notifies when there is an error during navigation.
+   *
+   * @param callback the function called when there is an error during navigation.
+   */
+  static onNavigationError = callback => {
+    SitumPluginEventEmitter.addListener("navigationError", callback);
+  };
+}
 //# sourceMappingURL=index.js.map