expo-background-tracking 1.0.0

package/build/HttpService.js

@@ -0,0 +1,265 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpService = void 0;
+const Network = __importStar(require("expo-network"));
+const Database_1 = require("./Database");
+const Logger_1 = require("./Logger");
+/**
+ * HTTP upload service: autoSync, batchSync, templates, JWT refresh,
+ * offline queue with re-sync on reconnect. Pure `fetch` — no Firebase.
+ */
+class HttpService {
+    constructor(bus) {
+        this.bus = bus;
+        this.config = {};
+        this.syncing = false;
+        this.connectivityTimer = null;
+        this.lastConnected = null;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    startConnectivityMonitoring(intervalMs = 10000) {
+        this.stopConnectivityMonitoring();
+        this.connectivityTimer = setInterval(() => {
+            void this.checkConnectivity();
+        }, intervalMs);
+        void this.checkConnectivity();
+    }
+    stopConnectivityMonitoring() {
+        if (this.connectivityTimer) {
+            clearInterval(this.connectivityTimer);
+            this.connectivityTimer = null;
+        }
+    }
+    async checkConnectivity() {
+        try {
+            const state = await Network.getNetworkStateAsync();
+            const connected = !!(state.isConnected && state.isInternetReachable !== false);
+            if (this.lastConnected !== null && connected !== this.lastConnected) {
+                this.bus.emit('connectivitychange', { connected });
+                if (connected && this.config.autoSync !== false) {
+                    void this.sync();
+                }
+            }
+            this.lastConnected = connected;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    /** Called after each persisted location when autoSync is enabled. */
+    async autoSync() {
+        if (!this.config.url || this.config.autoSync === false)
+            return;
+        const threshold = this.config.autoSyncThreshold ?? 0;
+        if (threshold > 0) {
+            const count = await Database_1.database.getCount();
+            if (count < threshold)
+                return;
+        }
+        await this.sync();
+    }
+    /** Upload all queued locations. Resolves with the uploaded records. */
+    async sync() {
+        if (!this.config.url) {
+            throw new Error('sync() requires config.url');
+        }
+        if (this.syncing)
+            return [];
+        this.syncing = true;
+        try {
+            const queue = await Database_1.database.getLocations({ order: 1 });
+            if (!queue.length)
+                return [];
+            const batchSync = this.config.batchSync === true;
+            const maxBatch = this.config.maxBatchSize && this.config.maxBatchSize > 0
+                ? this.config.maxBatchSize
+                : Infinity;
+            if (batchSync) {
+                let i = 0;
+                while (i < queue.length) {
+                    const batch = queue.slice(i, i + (isFinite(maxBatch) ? maxBatch : queue.length));
+                    const ok = await this.upload(batch);
+                    if (!ok)
+                        break;
+                    await Database_1.database.deleteLocations(batch.map((l) => l.uuid));
+                    i += batch.length;
+                }
+            }
+            else {
+                for (const location of queue) {
+                    const ok = await this.upload([location]);
+                    if (!ok)
+                        break;
+                    await Database_1.database.destroyLocation(location.uuid);
+                }
+            }
+            return queue;
+        }
+        finally {
+            this.syncing = false;
+        }
+    }
+    renderTemplate(template, location) {
+        return template.replace(/<%=?\s*([\w.]+)\s*%>/g, (_m, path) => {
+            const flat = {
+                ...location.coords,
+                uuid: location.uuid,
+                timestamp: location.timestamp,
+                odometer: location.odometer,
+                is_moving: location.is_moving,
+                activity: location.activity?.activity,
+                'activity.type': location.activity?.activity,
+                'activity.confidence': location.activity?.confidence,
+                'battery.level': location.battery?.level,
+                'battery.is_charging': location.battery?.is_charging,
+            };
+            const v = flat[path];
+            return v === undefined ? 'null' : JSON.stringify(v);
+        });
+    }
+    buildBody(locations) {
+        const template = this.config.locationTemplate;
+        const extras = this.config.extras ?? {};
+        const records = locations.map((l) => {
+            if (template) {
+                try {
+                    return JSON.parse(this.renderTemplate(template, l));
+                }
+                catch {
+                    return { ...l, extras: { ...extras, ...l.extras } };
+                }
+            }
+            return { ...l, extras: { ...extras, ...l.extras } };
+        });
+        const root = this.config.httpRootProperty ?? 'location';
+        const payload = locations.length === 1 && !this.config.batchSync ? records[0] : records;
+        if (root === '.')
+            return payload;
+        return { [root]: payload, ...(this.config.params ?? {}) };
+    }
+    async authHeaders() {
+        const auth = this.config.authorization;
+        if (!auth?.accessToken)
+            return {};
+        return { Authorization: `Bearer ${auth.accessToken}` };
+    }
+    async refreshToken(auth) {
+        if (!auth.refreshUrl || !auth.refreshToken)
+            return false;
+        try {
+            const payload = {};
+            const tpl = auth.refreshPayload ?? { refresh_token: '{refreshToken}' };
+            for (const [k, v] of Object.entries(tpl)) {
+                payload[k] = v.replace('{refreshToken}', auth.refreshToken);
+            }
+            const res = await fetch(auth.refreshUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', ...(auth.refreshHeaders ?? {}) },
+                body: JSON.stringify(payload),
+            });
+            const json = (await res.json().catch(() => ({})));
+            const event = res.ok
+                ? { success: true, status: res.status, response: json }
+                : { success: false, status: res.status, error: 'refresh failed' };
+            if (res.ok) {
+                const token = json.access_token ?? json.accessToken ?? null;
+                const refresh = json.refresh_token ?? json.refreshToken ?? null;
+                if (token)
+                    auth.accessToken = token;
+                if (refresh)
+                    auth.refreshToken = refresh;
+            }
+            this.bus.emit('authorization', event);
+            return res.ok;
+        }
+        catch (e) {
+            this.bus.emit('authorization', {
+                success: false,
+                error: String(e),
+            });
+            return false;
+        }
+    }
+    async upload(locations, retried = false) {
+        const url = this.config.url;
+        const method = this.config.method ?? 'POST';
+        const timeout = this.config.httpTimeout ?? 60000;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+            const res = await fetch(url, {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this.config.headers ?? {}),
+                    ...(await this.authHeaders()),
+                },
+                body: JSON.stringify(this.buildBody(locations)),
+                signal: controller.signal,
+            });
+            const text = await res.text().catch(() => '');
+            const event = {
+                success: res.ok,
+                status: res.status,
+                responseText: text,
+            };
+            this.bus.emit('http', event);
+            if (res.status === 401 && !retried && this.config.authorization) {
+                const refreshed = await this.refreshToken(this.config.authorization);
+                if (refreshed)
+                    return this.upload(locations, true);
+            }
+            if (!res.ok)
+                Logger_1.logger.warn(`HTTP ${res.status}: ${text.slice(0, 200)}`);
+            return res.ok;
+        }
+        catch (e) {
+            Logger_1.logger.warn(`HTTP error: ${String(e)}`);
+            this.bus.emit('http', {
+                success: false,
+                status: 0,
+                responseText: String(e),
+            });
+            return false;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.HttpService = HttpService;

package/build/Logger.d.ts

@@ -0,0 +1,15 @@
+import { LogLevel } from './types';
+/** SQLite-backed logger, mirrors BackgroundGeolocation.logger. */
+export declare class Logger {
+    level: LogLevel;
+    debug: boolean;
+    private write;
+    error(message: string): void;
+    warn(message: string): void;
+    info(message: string): void;
+    debugLog(message: string): void;
+    notice(message: string): void;
+    getLog(): Promise<string>;
+    destroyLog(): Promise<void>;
+}
+export declare const logger: Logger;

package/build/Logger.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+const Database_1 = require("./Database");
+const types_1 = require("./types");
+/** SQLite-backed logger, mirrors BackgroundGeolocation.logger. */
+class Logger {
+    constructor() {
+        this.level = types_1.LogLevel.INFO;
+        this.debug = false;
+    }
+    write(level, tag, message) {
+        if (level > this.level)
+            return;
+        const line = `[${tag}] ${message}`;
+        if (this.debug || level <= types_1.LogLevel.WARNING) {
+            const fn = level === types_1.LogLevel.ERROR
+                ? console.error
+                : level === types_1.LogLevel.WARNING
+                    ? console.warn
+                    : console.log;
+            fn(`[expo-background-tracking]${line}`);
+        }
+        Database_1.database.insertLog(types_1.LogLevel[level], line).catch(() => undefined);
+    }
+    error(message) {
+        this.write(types_1.LogLevel.ERROR, 'ERROR', message);
+    }
+    warn(message) {
+        this.write(types_1.LogLevel.WARNING, 'WARN', message);
+    }
+    info(message) {
+        this.write(types_1.LogLevel.INFO, 'INFO', message);
+    }
+    debugLog(message) {
+        this.write(types_1.LogLevel.DEBUG, 'DEBUG', message);
+    }
+    notice(message) {
+        this.write(types_1.LogLevel.INFO, 'NOTICE', message);
+    }
+    async getLog() {
+        const entries = await Database_1.database.getLogs();
+        return entries
+            .map((e) => `${e.timestamp} ${e.level} ${e.message}`)
+            .join('\n');
+    }
+    async destroyLog() {
+        await Database_1.database.destroyLogs();
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();

package/build/MotionDetector.d.ts

@@ -0,0 +1,40 @@
+import type { ActivityChangeEvent } from './types';
+export interface MotionDetectorOptions {
+    /** Minutes of stillness before declaring stationary (stopTimeout). */
+    stopTimeoutMinutes: number;
+    /** ms of sustained motion before declaring moving (motionTriggerDelay). */
+    motionTriggerDelayMs: number;
+    /** Disable accelerometer sampling (disableMotionActivityUpdates). */
+    disabled: boolean;
+    onMotionChange: (isMoving: boolean) => void;
+    onActivityChange: (activity: ActivityChangeEvent) => void;
+}
+/**
+ * Battery-conscious motion intelligence:
+ * - accelerometer variance → moving / stationary transitions
+ * - GPS speed + accelerometer → activity classification
+ *   (still, on_foot, walking, running, on_bicycle, in_vehicle)
+ */
+export declare class MotionDetector {
+    private sub;
+    private samples;
+    private isMoving;
+    private stillSince;
+    private movingSince;
+    private lastActivity;
+    private lastSpeed;
+    private opts;
+    private static MOTION_THRESHOLD;
+    constructor(opts: MotionDetectorOptions);
+    setOptions(opts: Partial<MotionDetectorOptions>): void;
+    get moving(): boolean;
+    /** Force pace (changePace). */
+    setMoving(isMoving: boolean): void;
+    /** Feed GPS speed (m/s) for activity classification. */
+    feedSpeed(speed: number | null): void;
+    start(): Promise<void>;
+    stop(): void;
+    private evaluate;
+    private noteMotion;
+    private classify;
+}

package/build/MotionDetector.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MotionDetector = void 0;
+const expo_sensors_1 = require("expo-sensors");
+/**
+ * Battery-conscious motion intelligence:
+ * - accelerometer variance → moving / stationary transitions
+ * - GPS speed + accelerometer → activity classification
+ *   (still, on_foot, walking, running, on_bicycle, in_vehicle)
+ */
+class MotionDetector {
+    constructor(opts) {
+        this.sub = null;
+        this.samples = [];
+        this.isMoving = false;
+        this.stillSince = null;
+        this.movingSince = null;
+        this.lastActivity = 'still';
+        this.lastSpeed = 0;
+        this.opts = opts;
+    }
+    setOptions(opts) {
+        this.opts = { ...this.opts, ...opts };
+    }
+    get moving() {
+        return this.isMoving;
+    }
+    /** Force pace (changePace). */
+    setMoving(isMoving) {
+        if (this.isMoving === isMoving)
+            return;
+        this.isMoving = isMoving;
+        this.stillSince = null;
+        this.movingSince = null;
+        this.opts.onMotionChange(isMoving);
+    }
+    /** Feed GPS speed (m/s) for activity classification. */
+    feedSpeed(speed) {
+        if (speed == null || speed < 0)
+            return;
+        this.lastSpeed = speed;
+        this.classify();
+        // GPS speed is also strong evidence of motion
+        if (speed > 1 && !this.isMoving)
+            this.noteMotion(true);
+    }
+    async start() {
+        if (this.opts.disabled)
+            return;
+        try {
+            const available = await expo_sensors_1.Accelerometer.isAvailableAsync();
+            if (!available)
+                return;
+        }
+        catch {
+            return;
+        }
+        expo_sensors_1.Accelerometer.setUpdateInterval(1000);
+        this.sub = expo_sensors_1.Accelerometer.addListener(({ x, y, z }) => {
+            const magnitude = Math.abs(Math.sqrt(x * x + y * y + z * z) - 1); // gravity-normalized
+            this.samples.push(magnitude);
+            if (this.samples.length > 10)
+                this.samples.shift();
+            if (this.samples.length >= 5)
+                this.evaluate();
+        });
+    }
+    stop() {
+        this.sub?.remove();
+        this.sub = null;
+        this.samples = [];
+        this.stillSince = null;
+        this.movingSince = null;
+    }
+    evaluate() {
+        const mean = this.samples.reduce((a, b) => a + b, 0) / this.samples.length;
+        const variance = this.samples.reduce((a, b) => a + (b - mean) ** 2, 0) / this.samples.length;
+        const active = variance > MotionDetector.MOTION_THRESHOLD ||
+            mean > MotionDetector.MOTION_THRESHOLD * 2;
+        this.noteMotion(active);
+        this.classify();
+    }
+    noteMotion(active) {
+        const now = Date.now();
+        if (active) {
+            this.stillSince = null;
+            if (!this.isMoving) {
+                if (this.movingSince == null)
+                    this.movingSince = now;
+                if (now - this.movingSince >= this.opts.motionTriggerDelayMs) {
+                    this.isMoving = true;
+                    this.movingSince = null;
+                    this.opts.onMotionChange(true);
+                }
+            }
+        }
+        else {
+            this.movingSince = null;
+            if (this.isMoving) {
+                if (this.stillSince == null)
+                    this.stillSince = now;
+                if (now - this.stillSince >= this.opts.stopTimeoutMinutes * 60000) {
+                    this.isMoving = false;
+                    this.stillSince = null;
+                    this.opts.onMotionChange(false);
+                }
+            }
+        }
+    }
+    classify() {
+        const speed = this.lastSpeed;
+        let activity;
+        let confidence = 75;
+        if (!this.isMoving && speed < 0.5) {
+            activity = 'still';
+            confidence = 90;
+        }
+        else if (speed < 2) {
+            activity = 'walking';
+        }
+        else if (speed < 3.5) {
+            activity = 'running';
+            confidence = 60;
+        }
+        else if (speed < 8) {
+            activity = 'on_bicycle';
+            confidence = 55;
+        }
+        else {
+            activity = 'in_vehicle';
+            confidence = 85;
+        }
+        if (activity !== this.lastActivity) {
+            this.lastActivity = activity;
+            this.opts.onActivityChange({ activity, confidence });
+        }
+    }
+}
+exports.MotionDetector = MotionDetector;
+// m/s² variance thresholds (device acceleration, gravity removed approx.)
+MotionDetector.MOTION_THRESHOLD = 0.05;

package/build/Scheduler.d.ts

@@ -0,0 +1,19 @@
+import type { ScheduleItem } from './types';
+/**
+ * Weekly schedule engine — "1-5 09:00-17:00" style entries
+ * (same syntax as transistorsoft). JS timer-based: evaluated every
+ * 30 s while the app runs; state re-evaluated on resume.
+ */
+export declare class Scheduler {
+    private onScheduleChange;
+    private timer;
+    private schedules;
+    private lastShouldBeEnabled;
+    constructor(onScheduleChange: (enabled: boolean) => void);
+    get enabled(): boolean;
+    setSchedule(items: ScheduleItem[]): void;
+    start(): void;
+    stop(): void;
+    private evaluate;
+    private parse;
+}

package/build/Scheduler.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const Logger_1 = require("./Logger");
+/**
+ * Weekly schedule engine — "1-5 09:00-17:00" style entries
+ * (same syntax as transistorsoft). JS timer-based: evaluated every
+ * 30 s while the app runs; state re-evaluated on resume.
+ */
+class Scheduler {
+    constructor(onScheduleChange) {
+        this.onScheduleChange = onScheduleChange;
+        this.timer = null;
+        this.schedules = [];
+        this.lastShouldBeEnabled = null;
+    }
+    get enabled() {
+        return this.timer != null;
+    }
+    setSchedule(items) {
+        this.schedules = items
+            .map((s) => this.parse(s))
+            .filter((s) => s != null);
+    }
+    start() {
+        if (this.timer)
+            return;
+        if (!this.schedules.length) {
+            Logger_1.logger.warn('startSchedule: no schedule configured');
+            return;
+        }
+        this.timer = setInterval(() => this.evaluate(), 30000);
+        this.evaluate();
+        Logger_1.logger.info('Schedule started');
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.lastShouldBeEnabled = null;
+        Logger_1.logger.info('Schedule stopped');
+    }
+    evaluate() {
+        const now = new Date();
+        const isoDay = now.getDay() === 0 ? 7 : now.getDay();
+        const minutes = now.getHours() * 60 + now.getMinutes();
+        const shouldBeEnabled = this.schedules.some((s) => s.days.has(isoDay) && minutes >= s.startMinutes && minutes < s.endMinutes);
+        if (shouldBeEnabled !== this.lastShouldBeEnabled) {
+            this.lastShouldBeEnabled = shouldBeEnabled;
+            this.onScheduleChange(shouldBeEnabled);
+        }
+    }
+    parse(item) {
+        // "1-5 09:00-17:00" | "7 10:00-12:00" | "1,3,5 08:30-18:00"
+        const m = item.trim().match(/^([\d,\-]+)\s+(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/);
+        if (!m) {
+            Logger_1.logger.warn(`Invalid schedule item: "${item}"`);
+            return null;
+        }
+        const days = new Set();
+        for (const part of m[1].split(',')) {
+            const range = part.split('-').map(Number);
+            if (range.length === 2) {
+                for (let d = range[0]; d <= range[1]; d++)
+                    days.add(d);
+            }
+            else {
+                days.add(range[0]);
+            }
+        }
+        return {
+            days,
+            startMinutes: Number(m[2]) * 60 + Number(m[3]),
+            endMinutes: Number(m[4]) * 60 + Number(m[5]),
+        };
+    }
+}
+exports.Scheduler = Scheduler;

package/build/environment.d.ts

@@ -0,0 +1,8 @@
+/** True when running inside the Expo Go sandbox app. */
+export declare function isExpoGo(): boolean;
+/**
+ * Background location (expo-task-manager location tasks) requires a
+ * development build — it is not available inside Expo Go.
+ * https://docs.expo.dev/versions/latest/sdk/location/
+ */
+export declare function isBackgroundCapable(): boolean;

package/build/environment.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpoGo = isExpoGo;
+exports.isBackgroundCapable = isBackgroundCapable;
+const expo_constants_1 = __importDefault(require("expo-constants"));
+/** True when running inside the Expo Go sandbox app. */
+function isExpoGo() {
+    try {
+        return (expo_constants_1.default
+            ?.executionEnvironment === 'storeClient');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Background location (expo-task-manager location tasks) requires a
+ * development build — it is not available inside Expo Go.
+ * https://docs.expo.dev/versions/latest/sdk/location/
+ */
+function isBackgroundCapable() {
+    return !isExpoGo();
+}

package/build/geo.d.ts

@@ -0,0 +1,10 @@
+/** Geodesic helpers. */
+export declare function haversine(lat1: number, lon1: number, lat2: number, lon2: number): number;
+/** Point-in-polygon (ray casting) — vertices as [lat, lon]. */
+export declare function pointInPolygon(lat: number, lon: number, vertices: Array<[number, number]>): boolean;
+/** Centroid of a polygon's vertices ([lat, lon]). */
+export declare function centroid(vertices: Array<[number, number]>): {
+    latitude: number;
+    longitude: number;
+};
+export declare function uuidv4(): string;