react-native-nitro-geolocation 1.2.6 → 1.3.0

package/src/background/NitroBackgroundLocation.nitro.ts

@@ -0,0 +1,83 @@
+import type { HybridObject } from "react-native-nitro-modules";
+import type { LocationError } from "../NitroGeolocation.nitro";
+import type {
+  ActivityRecognitionOptions,
+  BackgroundEventEnvelope,
+  BackgroundEventType,
+  BackgroundHttpSyncResult,
+  BackgroundLocation,
+  BackgroundLocationOptions,
+  BackgroundLocationStatus,
+  BackgroundPermissionResult,
+  DetectedActivity,
+  GeofenceEvent,
+  GeofenceRegion,
+  GeofencingOptions,
+  GetStoredBackgroundEventsOptions,
+  GetStoredBackgroundLocationsOptions,
+  StoredBackgroundEventEnvelope,
+  StoredBackgroundLocation
+} from "./types";
+
+export interface NitroBackgroundLocation
+  extends HybridObject<{ ios: "swift"; android: "kotlin" }> {
+  checkBackgroundPermission(): Promise<BackgroundPermissionResult>;
+  requestBackgroundPermission(): Promise<BackgroundPermissionResult>;
+  openAppLocationSettings(): Promise<void>;
+  configureBackgroundLocation(
+    options: BackgroundLocationOptions
+  ): Promise<void>;
+  getBackgroundConfiguration(): Promise<BackgroundLocationOptions | undefined>;
+  startBackgroundLocation(options?: BackgroundLocationOptions): Promise<void>;
+  stopBackgroundLocation(): Promise<void>;
+  resetBackgroundLocation(): Promise<void>;
+  getBackgroundLocationStatus(): Promise<BackgroundLocationStatus>;
+  addBackgroundEventListener(
+    listener: (event: BackgroundEventEnvelope) => void
+  ): string;
+  removeBackgroundEventListener(token: string): void;
+  addBackgroundLocationListener(
+    listener: (location: BackgroundLocation) => void
+  ): string;
+  removeBackgroundLocationListener(token: string): void;
+  addBackgroundErrorListener(listener: (error: LocationError) => void): string;
+  removeBackgroundErrorListener(token: string): void;
+  getStoredBackgroundLocations(
+    options?: GetStoredBackgroundLocationsOptions
+  ): Promise<StoredBackgroundLocation[]>;
+  clearStoredBackgroundLocations(ids?: string[]): Promise<void>;
+  markStoredBackgroundLocationsDelivered(ids: string[]): Promise<void>;
+  getStoredBackgroundEvents(
+    options?: GetStoredBackgroundEventsOptions
+  ): Promise<StoredBackgroundEventEnvelope[]>;
+  clearStoredBackgroundEvents(ids?: string[]): Promise<void>;
+  markStoredBackgroundEventsDelivered(ids: string[]): Promise<void>;
+  addGeofences(
+    regions: GeofenceRegion[],
+    options?: GeofencingOptions
+  ): Promise<void>;
+  removeGeofences(identifiers?: string[]): Promise<void>;
+  getRegisteredGeofences(): Promise<GeofenceRegion[]>;
+  startActivityRecognition(options?: ActivityRecognitionOptions): Promise<void>;
+  stopActivityRecognition(): Promise<void>;
+  syncStoredLocations(): Promise<BackgroundHttpSyncResult>;
+}
+
+export type {
+  ActivityRecognitionOptions,
+  BackgroundEventEnvelope,
+  BackgroundEventType,
+  BackgroundHttpSyncResult,
+  BackgroundLocation,
+  BackgroundLocationOptions,
+  BackgroundLocationStatus,
+  BackgroundPermissionResult,
+  DetectedActivity,
+  GeofenceEvent,
+  GeofenceRegion,
+  GeofencingOptions,
+  GetStoredBackgroundEventsOptions,
+  GetStoredBackgroundLocationsOptions,
+  StoredBackgroundEventEnvelope,
+  StoredBackgroundLocation
+};

package/src/background/index.ts

@@ -0,0 +1,200 @@
+import { NitroModules } from "react-native-nitro-modules";
+import type { LocationError } from "../NitroGeolocation.nitro";
+import type { NitroBackgroundLocation } from "./NitroBackgroundLocation.nitro";
+import type {
+  BackgroundActivityEventEnvelope,
+  BackgroundEvent,
+  BackgroundEventEnvelope,
+  BackgroundGeofenceEventEnvelope,
+  BackgroundHttpSyncEvent,
+  BackgroundLocation,
+  BackgroundSubscription,
+  StoredBackgroundEvent,
+  StoredBackgroundEventEnvelope
+} from "./types";
+
+const NativeBackgroundLocation =
+  NitroModules.createHybridObject<NitroBackgroundLocation>(
+    "NitroBackgroundLocation"
+  );
+
+function narrowBackgroundEvent(
+  event: BackgroundEventEnvelope
+): BackgroundEvent {
+  switch (event.type) {
+    case "location":
+      return { ...event, type: "location", location: event.location! };
+    case "geofence":
+      return { ...event, type: "geofence", geofence: event.geofence! };
+    case "activity":
+      return { ...event, type: "activity", activity: event.activity! };
+    case "providerChange":
+      return {
+        ...event,
+        type: "providerChange",
+        providerStatus: event.providerStatus!
+      };
+    case "httpSync":
+      return { ...event, type: "httpSync", result: event.result! };
+    case "error":
+      return { ...event, type: "error", error: event.error! };
+  }
+}
+
+export * from "./types";
+export { BACKGROUND_LOCATION_TASK_NAME, registerBackgroundTask } from "./task";
+
+export const checkBackgroundPermission =
+  NativeBackgroundLocation.checkBackgroundPermission.bind(
+    NativeBackgroundLocation
+  );
+export const requestBackgroundPermission =
+  NativeBackgroundLocation.requestBackgroundPermission.bind(
+    NativeBackgroundLocation
+  );
+export const openAppLocationSettings =
+  NativeBackgroundLocation.openAppLocationSettings.bind(
+    NativeBackgroundLocation
+  );
+export const configureBackgroundLocation =
+  NativeBackgroundLocation.configureBackgroundLocation.bind(
+    NativeBackgroundLocation
+  );
+export const getBackgroundConfiguration =
+  NativeBackgroundLocation.getBackgroundConfiguration.bind(
+    NativeBackgroundLocation
+  );
+export const startBackgroundLocation: NitroBackgroundLocation["startBackgroundLocation"] =
+  (options) =>
+    NativeBackgroundLocation.startBackgroundLocation(
+      options ?? (undefined as any)
+    );
+export const stopBackgroundLocation =
+  NativeBackgroundLocation.stopBackgroundLocation.bind(
+    NativeBackgroundLocation
+  );
+export const resetBackgroundLocation =
+  NativeBackgroundLocation.resetBackgroundLocation.bind(
+    NativeBackgroundLocation
+  );
+export const getBackgroundLocationStatus =
+  NativeBackgroundLocation.getBackgroundLocationStatus.bind(
+    NativeBackgroundLocation
+  );
+export const getStoredBackgroundLocations: NitroBackgroundLocation["getStoredBackgroundLocations"] =
+  (options) =>
+    NativeBackgroundLocation.getStoredBackgroundLocations(
+      options ?? (undefined as any)
+    );
+export const clearStoredBackgroundLocations: NitroBackgroundLocation["clearStoredBackgroundLocations"] =
+  (ids) =>
+    NativeBackgroundLocation.clearStoredBackgroundLocations(
+      ids ?? (undefined as any)
+    );
+export const markStoredBackgroundLocationsDelivered =
+  NativeBackgroundLocation.markStoredBackgroundLocationsDelivered.bind(
+    NativeBackgroundLocation
+  );
+export async function getStoredBackgroundEvents(
+  options?: Parameters<NitroBackgroundLocation["getStoredBackgroundEvents"]>[0]
+): Promise<StoredBackgroundEvent[]> {
+  const events = await NativeBackgroundLocation.getStoredBackgroundEvents(
+    options ?? (undefined as any)
+  );
+  return events.map((event: StoredBackgroundEventEnvelope) => ({
+    ...event,
+    event: narrowBackgroundEvent(event.event)
+  }));
+}
+export const clearStoredBackgroundEvents: NitroBackgroundLocation["clearStoredBackgroundEvents"] =
+  (ids) =>
+    NativeBackgroundLocation.clearStoredBackgroundEvents(
+      ids ?? (undefined as any)
+    );
+export const markStoredBackgroundEventsDelivered =
+  NativeBackgroundLocation.markStoredBackgroundEventsDelivered.bind(
+    NativeBackgroundLocation
+  );
+export const addGeofences = NativeBackgroundLocation.addGeofences.bind(
+  NativeBackgroundLocation
+);
+export const removeGeofences: NitroBackgroundLocation["removeGeofences"] = (
+  identifiers
+) =>
+  NativeBackgroundLocation.removeGeofences(identifiers ?? (undefined as any));
+export const getRegisteredGeofences =
+  NativeBackgroundLocation.getRegisteredGeofences.bind(
+    NativeBackgroundLocation
+  );
+export const startActivityRecognition: NitroBackgroundLocation["startActivityRecognition"] =
+  (options) =>
+    NativeBackgroundLocation.startActivityRecognition(
+      options ?? (undefined as any)
+    );
+export const stopActivityRecognition =
+  NativeBackgroundLocation.stopActivityRecognition.bind(
+    NativeBackgroundLocation
+  );
+export const syncStoredLocations =
+  NativeBackgroundLocation.syncStoredLocations.bind(NativeBackgroundLocation);
+
+export function onBackgroundEvent(
+  listener: (event: BackgroundEvent) => void
+): BackgroundSubscription {
+  const token = NativeBackgroundLocation.addBackgroundEventListener((event) => {
+    listener(narrowBackgroundEvent(event));
+  });
+  return {
+    remove: () => NativeBackgroundLocation.removeBackgroundEventListener(token)
+  };
+}
+
+export function onBackgroundLocation(
+  listener: (location: BackgroundLocation) => void
+): BackgroundSubscription {
+  const token =
+    NativeBackgroundLocation.addBackgroundLocationListener(listener);
+  return {
+    remove: () =>
+      NativeBackgroundLocation.removeBackgroundLocationListener(token)
+  };
+}
+
+export function onBackgroundError(
+  listener: (error: LocationError) => void
+): BackgroundSubscription {
+  const token = NativeBackgroundLocation.addBackgroundErrorListener(listener);
+  return {
+    remove: () => NativeBackgroundLocation.removeBackgroundErrorListener(token)
+  };
+}
+
+export function onGeofence(
+  listener: (event: BackgroundGeofenceEventEnvelope["geofence"]) => void
+): BackgroundSubscription {
+  return onBackgroundEvent((event) => {
+    if (event.type === "geofence") {
+      listener(event.geofence);
+    }
+  });
+}
+
+export function onActivityChange(
+  listener: (activity: BackgroundActivityEventEnvelope["activity"]) => void
+): BackgroundSubscription {
+  return onBackgroundEvent((event) => {
+    if (event.type === "activity") {
+      listener(event.activity);
+    }
+  });
+}
+
+export function onHttpSync(
+  listener: (result: BackgroundHttpSyncEvent["result"]) => void
+): BackgroundSubscription {
+  return onBackgroundEvent((event) => {
+    if (event.type === "httpSync") {
+      listener(event.result);
+    }
+  });
+}

package/src/background/index.web.ts

@@ -0,0 +1,120 @@
+import type { LocationError } from "../NitroGeolocation.nitro";
+import type {
+  ActivityRecognitionOptions,
+  BackgroundEvent,
+  BackgroundHttpSyncResult,
+  BackgroundLocation,
+  BackgroundLocationOptions,
+  BackgroundLocationStatus,
+  BackgroundPermissionResult,
+  BackgroundSubscription,
+  DetectedActivity,
+  GeofenceEvent,
+  GeofenceRegion,
+  GeofencingOptions,
+  GetStoredBackgroundEventsOptions,
+  GetStoredBackgroundLocationsOptions,
+  StoredBackgroundEvent,
+  StoredBackgroundLocation
+} from "./types";
+
+export * from "./types";
+
+export const BACKGROUND_LOCATION_TASK_NAME = "NitroBackgroundLocationTask";
+
+const unsupported = (): Error =>
+  new Error("Background location is not available in the browser.");
+
+const rejectUnsupported = <T>(): Promise<T> => Promise.reject(unsupported());
+
+export function registerBackgroundTask(): void {
+  throw unsupported();
+}
+
+export const checkBackgroundPermission =
+  (): Promise<BackgroundPermissionResult> => rejectUnsupported();
+export const requestBackgroundPermission =
+  (): Promise<BackgroundPermissionResult> => rejectUnsupported();
+export const openAppLocationSettings = (): Promise<void> => rejectUnsupported();
+export const configureBackgroundLocation = (
+  _options: BackgroundLocationOptions
+): Promise<void> => rejectUnsupported();
+export const getBackgroundConfiguration = (): Promise<
+  BackgroundLocationOptions | undefined
+> => rejectUnsupported();
+export const startBackgroundLocation = (
+  _options?: BackgroundLocationOptions
+): Promise<void> => rejectUnsupported();
+export const stopBackgroundLocation = (): Promise<void> => rejectUnsupported();
+export const resetBackgroundLocation = (): Promise<void> => rejectUnsupported();
+export const getBackgroundLocationStatus =
+  (): Promise<BackgroundLocationStatus> => rejectUnsupported();
+export const getStoredBackgroundLocations = (
+  _options?: GetStoredBackgroundLocationsOptions
+): Promise<StoredBackgroundLocation[]> => rejectUnsupported();
+export const clearStoredBackgroundLocations = (
+  _ids?: string[]
+): Promise<void> => rejectUnsupported();
+export const markStoredBackgroundLocationsDelivered = (
+  _ids: string[]
+): Promise<void> => rejectUnsupported();
+export const getStoredBackgroundEvents = (
+  _options?: GetStoredBackgroundEventsOptions
+): Promise<StoredBackgroundEvent[]> => rejectUnsupported();
+export const clearStoredBackgroundEvents = (_ids?: string[]): Promise<void> =>
+  rejectUnsupported();
+export const markStoredBackgroundEventsDelivered = (
+  _ids: string[]
+): Promise<void> => rejectUnsupported();
+export const addGeofences = (
+  _regions: GeofenceRegion[],
+  _options?: GeofencingOptions
+): Promise<void> => rejectUnsupported();
+export const removeGeofences = (_identifiers?: string[]): Promise<void> =>
+  rejectUnsupported();
+export const getRegisteredGeofences = (): Promise<GeofenceRegion[]> =>
+  rejectUnsupported();
+export const startActivityRecognition = (
+  _options?: ActivityRecognitionOptions
+): Promise<void> => rejectUnsupported();
+export const stopActivityRecognition = (): Promise<void> => rejectUnsupported();
+export const syncStoredLocations = (): Promise<BackgroundHttpSyncResult> =>
+  rejectUnsupported();
+
+const noopSubscription = (): BackgroundSubscription => ({ remove() {} });
+
+export function onBackgroundEvent(
+  _listener: (event: BackgroundEvent) => void
+): BackgroundSubscription {
+  return noopSubscription();
+}
+
+export function onBackgroundLocation(
+  _listener: (location: BackgroundLocation) => void
+): BackgroundSubscription {
+  return noopSubscription();
+}
+
+export function onBackgroundError(
+  _listener: (error: LocationError) => void
+): BackgroundSubscription {
+  return noopSubscription();
+}
+
+export function onGeofence(
+  _listener: (event: GeofenceEvent) => void
+): BackgroundSubscription {
+  return noopSubscription();
+}
+
+export function onActivityChange(
+  _listener: (activity: DetectedActivity) => void
+): BackgroundSubscription {
+  return noopSubscription();
+}
+
+export function onHttpSync(
+  _listener: (result: BackgroundHttpSyncResult) => void
+): BackgroundSubscription {
+  return noopSubscription();
+}

package/src/background/task.ts

@@ -0,0 +1,13 @@
+import { AppRegistry } from "react-native";
+import type { BackgroundEvent, BackgroundTaskHandler } from "./types";
+
+export const BACKGROUND_LOCATION_TASK_NAME = "NitroBackgroundLocationTask";
+
+export function registerBackgroundTask(handler: BackgroundTaskHandler): void {
+  AppRegistry.registerHeadlessTask(
+    BACKGROUND_LOCATION_TASK_NAME,
+    () => async (event: BackgroundEvent) => {
+      await handler(event);
+    }
+  );
+}