expo-background-tracking 1.0.0

package/build/geo.js

@@ -0,0 +1,46 @@
+"use strict";
+/** Geodesic helpers. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.haversine = haversine;
+exports.pointInPolygon = pointInPolygon;
+exports.centroid = centroid;
+exports.uuidv4 = uuidv4;
+const R = 6371000; // earth radius, metres
+function haversine(lat1, lon1, lat2, lon2) {
+    const toRad = (d) => (d * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLon = toRad(lon2 - lon1);
+    const a = Math.sin(dLat / 2) ** 2 +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
+    return 2 * R * Math.asin(Math.sqrt(a));
+}
+/** Point-in-polygon (ray casting) — vertices as [lat, lon]. */
+function pointInPolygon(lat, lon, vertices) {
+    let inside = false;
+    for (let i = 0, j = vertices.length - 1; i < vertices.length; j = i++) {
+        const [yi, xi] = vertices[i];
+        const [yj, xj] = vertices[j];
+        if (yi > lat !== yj > lat && lon < ((xj - xi) * (lat - yi)) / (yj - yi) + xi) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+/** Centroid of a polygon's vertices ([lat, lon]). */
+function centroid(vertices) {
+    const n = vertices.length || 1;
+    let lat = 0;
+    let lon = 0;
+    for (const [vLat, vLon] of vertices) {
+        lat += vLat;
+        lon += vLon;
+    }
+    return { latitude: lat / n, longitude: lon / n };
+}
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}

package/build/index.d.ts

@@ -0,0 +1,6 @@
+export { BackgroundGeolocation, LOCATION_TASK } from './BackgroundGeolocation';
+export { GEOFENCE_TASK } from './GeofenceManager';
+export { isExpoGo, isBackgroundCapable } from './environment';
+export * from './types';
+import { BackgroundGeolocation } from './BackgroundGeolocation';
+export default BackgroundGeolocation;

package/build/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBackgroundCapable = exports.isExpoGo = exports.GEOFENCE_TASK = exports.LOCATION_TASK = exports.BackgroundGeolocation = void 0;
+var BackgroundGeolocation_1 = require("./BackgroundGeolocation");
+Object.defineProperty(exports, "BackgroundGeolocation", { enumerable: true, get: function () { return BackgroundGeolocation_1.BackgroundGeolocation; } });
+Object.defineProperty(exports, "LOCATION_TASK", { enumerable: true, get: function () { return BackgroundGeolocation_1.LOCATION_TASK; } });
+var GeofenceManager_1 = require("./GeofenceManager");
+Object.defineProperty(exports, "GEOFENCE_TASK", { enumerable: true, get: function () { return GeofenceManager_1.GEOFENCE_TASK; } });
+var environment_1 = require("./environment");
+Object.defineProperty(exports, "isExpoGo", { enumerable: true, get: function () { return environment_1.isExpoGo; } });
+Object.defineProperty(exports, "isBackgroundCapable", { enumerable: true, get: function () { return environment_1.isBackgroundCapable; } });
+__exportStar(require("./types"), exports);
+const BackgroundGeolocation_2 = require("./BackgroundGeolocation");
+exports.default = BackgroundGeolocation_2.BackgroundGeolocation;

package/build/types.d.ts

@@ -0,0 +1,275 @@
+/**
+ * expo-background-tracking — Type definitions.
+ * API surface modeled after transistorsoft/react-native-background-geolocation.
+ */
+export declare enum DesiredAccuracy {
+    NAVIGATION = -2,
+    HIGH = -1,
+    MEDIUM = 10,
+    LOW = 100,
+    VERY_LOW = 1000,
+    LOWEST = 3000
+}
+export declare enum LogLevel {
+    OFF = 0,
+    ERROR = 1,
+    WARNING = 2,
+    INFO = 3,
+    DEBUG = 4,
+    VERBOSE = 5
+}
+export declare enum ActivityType {
+    OTHER = 1,
+    AUTOMOTIVE_NAVIGATION = 2,
+    FITNESS = 3,
+    OTHER_NAVIGATION = 4,
+    AIRBORNE = 5
+}
+export declare enum PersistMode {
+    ALL = 2,
+    LOCATION = 1,
+    GEOFENCE = -1,
+    NONE = 0
+}
+export declare enum AuthorizationStatus {
+    NOT_DETERMINED = 0,
+    RESTRICTED = 1,
+    DENIED = 2,
+    ALWAYS = 3,
+    WHEN_IN_USE = 4
+}
+export declare enum AccuracyAuthorization {
+    FULL = 0,
+    REDUCED = 1
+}
+export type MotionActivityType = 'still' | 'walking' | 'on_foot' | 'running' | 'on_bicycle' | 'in_vehicle' | 'unknown';
+export type GeofenceAction = 'ENTER' | 'EXIT' | 'DWELL';
+export type TrackingMode = 0 | 1;
+export type LocationError = 0 | 1 | 2 | 3 | 408 | 499;
+export interface Coords {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+    speed: number;
+    speed_accuracy?: number;
+    heading: number;
+    heading_accuracy?: number;
+    altitude: number;
+    altitude_accuracy?: number;
+    ellipsoidal_altitude?: number;
+}
+export interface Battery {
+    level: number;
+    is_charging: boolean;
+}
+export interface ActivityChangeEvent {
+    activity: MotionActivityType;
+    confidence: number;
+}
+export interface Location {
+    uuid: string;
+    timestamp: string;
+    age?: number;
+    odometer: number;
+    is_moving: boolean;
+    coords: Coords;
+    activity: ActivityChangeEvent;
+    battery: Battery;
+    extras?: Record<string, unknown>;
+    event?: 'motionchange' | 'geofence' | 'heartbeat' | 'providerchange';
+    mock?: boolean;
+    sample?: boolean;
+}
+export interface MotionChangeEvent {
+    isMoving: boolean;
+    location: Location;
+}
+export interface HeartbeatEvent {
+    location: Location;
+}
+export interface Geofence {
+    identifier: string;
+    radius?: number;
+    latitude?: number;
+    longitude?: number;
+    /** Polygon geofence: list of [latitude, longitude] vertices. */
+    vertices?: Array<[number, number]>;
+    notifyOnEntry?: boolean;
+    notifyOnExit?: boolean;
+    notifyOnDwell?: boolean;
+    loiteringDelay?: number;
+    extras?: Record<string, unknown>;
+}
+export interface GeofenceEvent {
+    identifier: string;
+    action: GeofenceAction;
+    location: Location;
+    extras?: Record<string, unknown>;
+}
+export interface GeofencesChangeEvent {
+    on: Geofence[];
+    off: string[];
+}
+export interface HttpEvent {
+    success: boolean;
+    status: number;
+    responseText: string;
+}
+export interface Authorization {
+    strategy?: 'JWT' | 'BASIC';
+    accessToken?: string;
+    refreshToken?: string;
+    refreshUrl?: string;
+    refreshPayload?: Record<string, string>;
+    refreshHeaders?: Record<string, string>;
+    expires?: number;
+}
+export interface AuthorizationEvent {
+    success: boolean;
+    status?: number;
+    response?: Record<string, unknown>;
+    error?: string;
+}
+export interface ProviderChangeEvent {
+    enabled: boolean;
+    status: AuthorizationStatus;
+    network: boolean;
+    gps: boolean;
+    accuracyAuthorization: AccuracyAuthorization;
+}
+export interface ConnectivityChangeEvent {
+    connected: boolean;
+}
+/** e.g. "1-5 09:00-17:00" (ISO day numbers 1=Monday … 7=Sunday) */
+export type ScheduleItem = string;
+export interface ScheduleEvent {
+    enabled: boolean;
+    state: State;
+}
+export interface Notification {
+    title?: string;
+    text?: string;
+    color?: string;
+    channelName?: string;
+    smallIcon?: string;
+    largeIcon?: string;
+    priority?: number;
+    sticky?: boolean;
+    actions?: string[];
+}
+export interface Config {
+    desiredAccuracy?: DesiredAccuracy;
+    distanceFilter?: number;
+    stationaryRadius?: number;
+    locationTimeout?: number;
+    useSignificantChangesOnly?: boolean;
+    pausesLocationUpdatesAutomatically?: boolean;
+    showsBackgroundLocationIndicator?: boolean;
+    activityType?: ActivityType;
+    deferTime?: number;
+    disableElasticity?: boolean;
+    elasticityMultiplier?: number;
+    stopAfterElapsedMinutes?: number;
+    geofenceProximityRadius?: number;
+    geofenceInitialTriggerEntry?: boolean;
+    geofenceModeHighAccuracy?: boolean;
+    isMoving?: boolean;
+    stopTimeout?: number;
+    motionTriggerDelay?: number;
+    disableMotionActivityUpdates?: boolean;
+    disableStopDetection?: boolean;
+    stopOnStationary?: boolean;
+    url?: string;
+    method?: 'POST' | 'PUT' | 'OPTIONS';
+    httpRootProperty?: string;
+    params?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    extras?: Record<string, unknown>;
+    autoSync?: boolean;
+    autoSyncThreshold?: number;
+    batchSync?: boolean;
+    maxBatchSize?: number;
+    locationTemplate?: string;
+    geofenceTemplate?: string;
+    maxDaysToPersist?: number;
+    maxRecordsToPersist?: number;
+    persistMode?: PersistMode;
+    httpTimeout?: number;
+    authorization?: Authorization;
+    disableAutoSyncOnCellular?: boolean;
+    stopOnTerminate?: boolean;
+    startOnBoot?: boolean;
+    heartbeatInterval?: number;
+    schedule?: ScheduleItem[];
+    preventSuspend?: boolean;
+    foregroundService?: boolean;
+    notification?: Notification;
+    debug?: boolean;
+    logLevel?: LogLevel;
+    logMaxDays?: number;
+    locationAuthorizationRequest?: 'Always' | 'WhenInUse' | 'Any';
+    backgroundPermissionRationale?: {
+        title?: string;
+        message?: string;
+        positiveAction?: string;
+        negativeAction?: string;
+    };
+    reset?: boolean;
+}
+export interface State extends Config {
+    enabled: boolean;
+    isMoving?: boolean;
+    schedulerEnabled: boolean;
+    trackingMode: TrackingMode;
+    odometer: number;
+    didLaunchInBackground?: boolean;
+    isFirstBoot?: boolean;
+}
+export interface CurrentPositionRequest {
+    timeout?: number;
+    maximumAge?: number;
+    persist?: boolean;
+    samples?: number;
+    desiredAccuracy?: number;
+    extras?: Record<string, unknown>;
+}
+export interface WatchPositionRequest {
+    interval?: number;
+    desiredAccuracy?: DesiredAccuracy;
+    persist?: boolean;
+    extras?: Record<string, unknown>;
+}
+export interface Sensors {
+    platform: 'ios' | 'android' | string;
+    accelerometer: boolean;
+    gyroscope: boolean;
+    magnetometer: boolean;
+    motion_hardware: boolean;
+}
+export interface DeviceInfo {
+    model: string;
+    manufacturer: string;
+    version: string;
+    platform: string;
+    framework: string;
+}
+export interface SQLQuery {
+    start?: number;
+    end?: number;
+    limit?: number;
+    order?: -1 | 1;
+}
+export interface HeadlessEvent {
+    name: 'location' | 'motionchange' | 'geofence' | 'heartbeat' | 'http' | 'providerchange' | 'connectivitychange' | 'powersavechange' | 'schedule' | 'enabledchange' | 'activitychange' | 'authorization' | 'geofenceschange' | 'notificationaction';
+    params: unknown;
+}
+export type HeadlessTask = (event: HeadlessEvent) => Promise<void>;
+export interface Subscription {
+    remove: () => void;
+}
+export type EventName = HeadlessEvent['name'];
+export interface LogEntry {
+    timestamp: string;
+    level: string;
+    message: string;
+}

package/build/types.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * expo-background-tracking — Type definitions.
+ * API surface modeled after transistorsoft/react-native-background-geolocation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccuracyAuthorization = exports.AuthorizationStatus = exports.PersistMode = exports.ActivityType = exports.LogLevel = exports.DesiredAccuracy = void 0;
+// ---------------------------------------------------------------------------
+// Enums / constants
+// ---------------------------------------------------------------------------
+var DesiredAccuracy;
+(function (DesiredAccuracy) {
+    DesiredAccuracy[DesiredAccuracy["NAVIGATION"] = -2] = "NAVIGATION";
+    DesiredAccuracy[DesiredAccuracy["HIGH"] = -1] = "HIGH";
+    DesiredAccuracy[DesiredAccuracy["MEDIUM"] = 10] = "MEDIUM";
+    DesiredAccuracy[DesiredAccuracy["LOW"] = 100] = "LOW";
+    DesiredAccuracy[DesiredAccuracy["VERY_LOW"] = 1000] = "VERY_LOW";
+    DesiredAccuracy[DesiredAccuracy["LOWEST"] = 3000] = "LOWEST";
+})(DesiredAccuracy || (exports.DesiredAccuracy = DesiredAccuracy = {}));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["OFF"] = 0] = "OFF";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARNING"] = 2] = "WARNING";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+    LogLevel[LogLevel["VERBOSE"] = 5] = "VERBOSE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+var ActivityType;
+(function (ActivityType) {
+    ActivityType[ActivityType["OTHER"] = 1] = "OTHER";
+    ActivityType[ActivityType["AUTOMOTIVE_NAVIGATION"] = 2] = "AUTOMOTIVE_NAVIGATION";
+    ActivityType[ActivityType["FITNESS"] = 3] = "FITNESS";
+    ActivityType[ActivityType["OTHER_NAVIGATION"] = 4] = "OTHER_NAVIGATION";
+    ActivityType[ActivityType["AIRBORNE"] = 5] = "AIRBORNE";
+})(ActivityType || (exports.ActivityType = ActivityType = {}));
+var PersistMode;
+(function (PersistMode) {
+    PersistMode[PersistMode["ALL"] = 2] = "ALL";
+    PersistMode[PersistMode["LOCATION"] = 1] = "LOCATION";
+    PersistMode[PersistMode["GEOFENCE"] = -1] = "GEOFENCE";
+    PersistMode[PersistMode["NONE"] = 0] = "NONE";
+})(PersistMode || (exports.PersistMode = PersistMode = {}));
+var AuthorizationStatus;
+(function (AuthorizationStatus) {
+    AuthorizationStatus[AuthorizationStatus["NOT_DETERMINED"] = 0] = "NOT_DETERMINED";
+    AuthorizationStatus[AuthorizationStatus["RESTRICTED"] = 1] = "RESTRICTED";
+    AuthorizationStatus[AuthorizationStatus["DENIED"] = 2] = "DENIED";
+    AuthorizationStatus[AuthorizationStatus["ALWAYS"] = 3] = "ALWAYS";
+    AuthorizationStatus[AuthorizationStatus["WHEN_IN_USE"] = 4] = "WHEN_IN_USE";
+})(AuthorizationStatus || (exports.AuthorizationStatus = AuthorizationStatus = {}));
+var AccuracyAuthorization;
+(function (AccuracyAuthorization) {
+    AccuracyAuthorization[AccuracyAuthorization["FULL"] = 0] = "FULL";
+    AccuracyAuthorization[AccuracyAuthorization["REDUCED"] = 1] = "REDUCED";
+})(AccuracyAuthorization || (exports.AccuracyAuthorization = AccuracyAuthorization = {}));