@tsachit/react-native-geo-service 1.0.1 → 1.0.3

package/lib/GeoDebugOverlay.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+/**
+ * Drop this anywhere in your component tree once.
+ * It renders the GeoDebugPanel automatically when:
+ *   - debug: true was passed to configure()
+ *   - location tracking is active (implies permission was granted)
+ * Nothing is rendered if debug is false or tracking hasn't started.
+ */
+export declare const GeoDebugOverlay: React.FC;

package/lib/GeoDebugOverlay.js

@@ -0,0 +1,86 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoDebugOverlay = void 0;
+const react_1 = __importStar(require("react"));
+const index_1 = __importDefault(require("./index"));
+const index_2 = require("./index");
+const GeoDebugPanel_1 = require("./GeoDebugPanel");
+/**
+ * Drop this anywhere in your component tree once.
+ * It renders the GeoDebugPanel automatically when:
+ *   - debug: true was passed to configure()
+ *   - location tracking is active (implies permission was granted)
+ * Nothing is rendered if debug is false or tracking hasn't started.
+ */
+const GeoDebugOverlay = () => {
+    const [visible, setVisible] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        const check = () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                const tracking = yield index_1.default.isTracking();
+                if (!cancelled)
+                    setVisible((0, index_2._isDebugMode)() && tracking);
+            }
+            catch (_) {
+                if (!cancelled)
+                    setVisible(false);
+            }
+        });
+        check();
+        const id = setInterval(check, 3000);
+        return () => {
+            cancelled = true;
+            clearInterval(id);
+        };
+    }, []);
+    if (!visible)
+        return null;
+    return <GeoDebugPanel_1.GeoDebugPanel />;
+};
+exports.GeoDebugOverlay = GeoDebugOverlay;

package/lib/GeoDebugPanel.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface Props {
+    /** Refresh interval in ms. Default: 30000 */
+    pollInterval?: number;
+}
+export declare const GeoDebugPanel: React.FC<Props>;
+export {};

package/lib/GeoDebugPanel.js

@@ -0,0 +1,319 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoDebugPanel = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const index_1 = __importDefault(require("./index"));
+const { width: SCREEN_WIDTH, height: SCREEN_HEIGHT } = react_native_1.Dimensions.get('window');
+const PANEL_WIDTH = Math.round(SCREEN_WIDTH * 0.95);
+const PILL_SIZE = 50;
+// ─── Formatting helpers ──────────────────────────────────────────────────────
+function formatBattery(level) {
+    return level < 0 ? 'N/A' : `${level.toFixed(1)}%`;
+}
+function formatElapsed(seconds) {
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    const m = Math.floor(seconds / 60);
+    const s = Math.round(seconds % 60);
+    if (m < 60)
+        return `${m}m ${s}s`;
+    const h = Math.floor(m / 60);
+    return `${h}h ${m % 60}m`;
+}
+function formatGpsPercent(gpsActiveSeconds, elapsedSeconds) {
+    if (elapsedSeconds <= 0)
+        return 'N/A';
+    return `${Math.round((gpsActiveSeconds / elapsedSeconds) * 100)}%`;
+}
+function getSuggestions(info) {
+    var _a, _b, _c, _d, _e;
+    const suggestions = [];
+    const elapsed = (_a = info.trackingElapsedSeconds) !== null && _a !== void 0 ? _a : 0;
+    const updates = (_b = info.updateCount) !== null && _b !== void 0 ? _b : 0;
+    const upm = (_c = info.updatesPerMinute) !== null && _c !== void 0 ? _c : 0;
+    const gpsActive = (_d = info.gpsActiveSeconds) !== null && _d !== void 0 ? _d : 0;
+    const drainRate = (_e = info.drainRatePerHour) !== null && _e !== void 0 ? _e : 0;
+    const gpsPercent = elapsed > 0 ? (gpsActive / elapsed) * 100 : 0;
+    // Not enough data yet
+    if (updates === 0) {
+        suggestions.push({ emoji: '⏳', color: '#aaa', text: 'No location updates received yet — make sure tracking has started and permission is granted' });
+        return suggestions;
+    }
+    if (elapsed < 60) {
+        suggestions.push({ emoji: '⏳', color: '#aaa', text: `${Math.round(elapsed)}s into session — rate metrics need ~1 min to stabilise` });
+    }
+    // ── Frequency ──
+    if (upm > 20) {
+        suggestions.push({ emoji: '🔴', color: '#f55', text: `Very frequent updates (${upm.toFixed(1)}/min) — increase minDistanceMeters or updateIntervalMs to reduce battery drain` });
+    }
+    else if (upm > 8) {
+        suggestions.push({ emoji: '⚠️', color: '#fa0', text: `Frequent updates (${upm.toFixed(1)}/min) — consider increasing minDistanceMeters` });
+    }
+    else if (upm > 0) {
+        suggestions.push({ emoji: '✅', color: '#4c4', text: `Update frequency is good (${upm.toFixed(1)}/min)` });
+    }
+    // ── GPS active time (only meaningful after 60s) ──
+    if (elapsed >= 60) {
+        if (gpsPercent > 80) {
+            suggestions.push({ emoji: '🔴', color: '#f55', text: `GPS on ${Math.round(gpsPercent)}% of the time — enable adaptiveAccuracy or switch to coarseTracking to save battery` });
+        }
+        else if (gpsPercent > 50) {
+            suggestions.push({ emoji: '⚠️', color: '#fa0', text: `GPS on ${Math.round(gpsPercent)}% of time — device is mostly moving, adaptive accuracy is active` });
+        }
+        else if (gpsPercent > 0) {
+            suggestions.push({ emoji: '✅', color: '#4c4', text: `GPS on ${Math.round(gpsPercent)}% of time — adaptive accuracy is saving battery` });
+        }
+    }
+    // ── Drain rate ──
+    if (drainRate > 8) {
+        suggestions.push({ emoji: '🔴', color: '#f55', text: `High drain (${drainRate.toFixed(1)}%/hr) — try accuracy: 'balanced' or increase update intervals` });
+    }
+    else if (drainRate > 4) {
+        suggestions.push({ emoji: '⚠️', color: '#fa0', text: `Moderate drain (${drainRate.toFixed(1)}%/hr) — normal for active GPS, consider adaptiveAccuracy` });
+    }
+    else if (drainRate > 0) {
+        suggestions.push({ emoji: '✅', color: '#4c4', text: `Low drain (${drainRate.toFixed(1)}%/hr) — battery usage is efficient` });
+    }
+    return suggestions;
+}
+// ─── Pan responder factory ───────────────────────────────────────────────────
+function makePanResponder(pan, lastPos, maxWidth, maxHeight, onTap) {
+    const didDrag = { current: false };
+    return react_native_1.PanResponder.create({
+        onStartShouldSetPanResponder: () => true,
+        onMoveShouldSetPanResponder: () => true,
+        onPanResponderGrant: () => {
+            didDrag.current = false;
+            pan.setOffset({ x: lastPos.current.x, y: lastPos.current.y });
+            pan.setValue({ x: 0, y: 0 });
+        },
+        onPanResponderMove: (_, g) => {
+            if (Math.abs(g.dx) > 4 || Math.abs(g.dy) > 4)
+                didDrag.current = true;
+            react_native_1.Animated.event([null, { dx: pan.x, dy: pan.y }], { useNativeDriver: false })(_, g);
+        },
+        onPanResponderRelease: (_, g) => {
+            pan.flattenOffset();
+            if (!didDrag.current && onTap) {
+                onTap();
+                return;
+            }
+            const newX = Math.max(0, Math.min(lastPos.current.x + g.dx, SCREEN_WIDTH - maxWidth));
+            const newY = Math.max(0, Math.min(lastPos.current.y + g.dy, SCREEN_HEIGHT - maxHeight));
+            lastPos.current = { x: newX, y: newY };
+            pan.setValue({ x: newX, y: newY });
+        },
+    });
+}
+// ─── Component ───────────────────────────────────────────────────────────────
+const GeoDebugPanel = ({ pollInterval = 30000 }) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const [info, setInfo] = (0, react_1.useState)(null);
+    const [minimized, setMinimized] = (0, react_1.useState)(true);
+    const pan = (0, react_1.useRef)(new react_native_1.Animated.ValueXY({ x: 8, y: SCREEN_HEIGHT - 320 })).current;
+    const lastPos = (0, react_1.useRef)({ x: 8, y: SCREEN_HEIGHT - 320 });
+    const panelHeight = (0, react_1.useRef)(0);
+    const pillPanResponder = (0, react_1.useRef)(makePanResponder(pan, lastPos, PILL_SIZE, PILL_SIZE, () => {
+        const clamped = {
+            x: Math.min(lastPos.current.x, SCREEN_WIDTH - PANEL_WIDTH),
+            y: Math.min(lastPos.current.y, SCREEN_HEIGHT - panelHeight.current),
+        };
+        lastPos.current = clamped;
+        pan.setValue(clamped);
+        setMinimized(false);
+    })).current;
+    const headerPanResponder = (0, react_1.useRef)(react_native_1.PanResponder.create({
+        onStartShouldSetPanResponder: () => false,
+        onMoveShouldSetPanResponder: (_, g) => Math.abs(g.dx) > 4 || Math.abs(g.dy) > 4,
+        onPanResponderGrant: () => {
+            pan.setOffset({ x: lastPos.current.x, y: lastPos.current.y });
+            pan.setValue({ x: 0, y: 0 });
+        },
+        onPanResponderMove: react_native_1.Animated.event([null, { dx: pan.x, dy: pan.y }], { useNativeDriver: false }),
+        onPanResponderRelease: (_, g) => {
+            pan.flattenOffset();
+            const newX = Math.max(0, Math.min(lastPos.current.x + g.dx, SCREEN_WIDTH - PANEL_WIDTH));
+            const newY = Math.max(0, Math.min(lastPos.current.y + g.dy, SCREEN_HEIGHT - panelHeight.current));
+            lastPos.current = { x: newX, y: newY };
+            pan.setValue({ x: newX, y: newY });
+        },
+    })).current;
+    const refresh = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const data = yield index_1.default.getBatteryInfo();
+            setInfo(data);
+        }
+        catch (_) { }
+    }), []);
+    (0, react_1.useEffect)(() => {
+        refresh();
+        const id = setInterval(refresh, pollInterval);
+        return () => clearInterval(id);
+    }, [refresh, pollInterval]);
+    // ── Minimized pill ──
+    if (minimized) {
+        return (<react_native_1.Animated.View style={[styles.pill, { transform: pan.getTranslateTransform() }]} {...pillPanResponder.panHandlers}>
+        <react_native_1.Text style={styles.pillText}>📍</react_native_1.Text>
+      </react_native_1.Animated.View>);
+    }
+    // Safely normalise — native side returns undefined for new fields until rebuilt
+    const elapsed = (_a = info === null || info === void 0 ? void 0 : info.trackingElapsedSeconds) !== null && _a !== void 0 ? _a : 0;
+    const updates = (_b = info === null || info === void 0 ? void 0 : info.updateCount) !== null && _b !== void 0 ? _b : 0;
+    const upm = (_c = info === null || info === void 0 ? void 0 : info.updatesPerMinute) !== null && _c !== void 0 ? _c : 0;
+    const gpsActive = (_d = info === null || info === void 0 ? void 0 : info.gpsActiveSeconds) !== null && _d !== void 0 ? _d : 0;
+    const level = (_e = info === null || info === void 0 ? void 0 : info.level) !== null && _e !== void 0 ? _e : -1;
+    const drain = (_f = info === null || info === void 0 ? void 0 : info.drainSinceStart) !== null && _f !== void 0 ? _f : 0;
+    const drainRate = (_g = info === null || info === void 0 ? void 0 : info.drainRatePerHour) !== null && _g !== void 0 ? _g : 0;
+    const safeInfo = info
+        ? Object.assign(Object.assign({}, info), { trackingElapsedSeconds: elapsed, updateCount: updates, updatesPerMinute: upm, gpsActiveSeconds: gpsActive, drainRatePerHour: drainRate }) : null;
+    const suggestions = safeInfo ? getSuggestions(safeInfo) : [];
+    // ── Expanded panel ──
+    return (<react_native_1.Animated.View style={[styles.container, { transform: pan.getTranslateTransform() }]} onLayout={e => { panelHeight.current = e.nativeEvent.layout.height; }}>
+      {/* Drag header */}
+      <react_native_1.View style={styles.header} {...headerPanResponder.panHandlers}>
+        <react_native_1.View style={styles.dragPill}/>
+        <react_native_1.View style={styles.titleRow}>
+          <react_native_1.Text style={styles.title}>📍 GeoService Debug</react_native_1.Text>
+          <react_native_1.TouchableOpacity onPress={() => setMinimized(true)} hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}>
+            <react_native_1.Text style={styles.minimizeBtn}>⊖</react_native_1.Text>
+          </react_native_1.TouchableOpacity>
+        </react_native_1.View>
+        <react_native_1.Text style={styles.dragHint}>⠿ hold & drag to move</react_native_1.Text>
+      </react_native_1.View>
+
+      <react_native_1.View style={styles.body}>
+        {info ? (<>
+            {/* ── Metrics grid ── */}
+            <react_native_1.View style={styles.grid}>
+              <MetricBox label="Tracking for" value={elapsed > 0 ? formatElapsed(elapsed) : '—'} desc="session duration"/>
+              <MetricBox label="Geopoints" value={`${updates}`} desc="total locations received"/>
+              <MetricBox label="Updates/min" value={upm > 0 ? upm.toFixed(1) : '—'} desc="higher = more battery"/>
+              <MetricBox label="GPS active" value={elapsed > 0 ? formatGpsPercent(gpsActive, elapsed) : '—'} desc="lower = adaptive saving"/>
+              <MetricBox label="Battery now" value={formatBattery(level)} desc={info.isCharging ? '⚡ charging' : 'not charging'}/>
+              <MetricBox label="Drained" value={level < 0 ? 'N/A' : `${drain.toFixed(2)}%`} desc="since tracking started"/>
+              <MetricBox label="Drain rate" value={drainRate > 0 ? `${drainRate.toFixed(1)}%/hr` : '—'} desc="whole device, not just GPS"/>
+            </react_native_1.View>
+
+            {/* ── Suggestions ── */}
+            <react_native_1.View style={styles.divider}/>
+            <react_native_1.Text style={styles.sectionLabel}>SUGGESTIONS</react_native_1.Text>
+            {suggestions.map((s, i) => (<react_native_1.View key={i} style={styles.suggestion}>
+                <react_native_1.Text style={styles.suggestionEmoji}>{s.emoji}</react_native_1.Text>
+                <react_native_1.Text style={[styles.suggestionText, { color: s.color }]}>{s.text}</react_native_1.Text>
+              </react_native_1.View>))}
+          </>) : (<react_native_1.Text style={styles.label}>Waiting for data…</react_native_1.Text>)}
+      </react_native_1.View>
+    </react_native_1.Animated.View>);
+};
+exports.GeoDebugPanel = GeoDebugPanel;
+// ─── MetricBox sub-component ─────────────────────────────────────────────────
+const MetricBox = ({ label, value, desc }) => (<react_native_1.View style={styles.metricBox}>
+    <react_native_1.Text style={styles.metricValue}>{value}</react_native_1.Text>
+    <react_native_1.Text style={styles.metricLabel}>{label}</react_native_1.Text>
+    {desc && <react_native_1.Text style={styles.metricSub}>{desc}</react_native_1.Text>}
+  </react_native_1.View>);
+// ─── Styles ──────────────────────────────────────────────────────────────────
+const styles = react_native_1.StyleSheet.create({
+    container: {
+        position: 'absolute',
+        width: PANEL_WIDTH,
+        backgroundColor: 'rgba(20,20,20,0.92)',
+        borderRadius: 12,
+        overflow: 'hidden',
+        borderWidth: 1,
+        borderColor: 'rgba(255,255,255,0.15)',
+    },
+    header: {
+        paddingTop: 6,
+        paddingBottom: 8,
+        paddingHorizontal: 12,
+        backgroundColor: 'rgba(255,255,255,0.07)',
+        alignItems: 'center',
+    },
+    dragPill: {
+        width: 40, height: 4, borderRadius: 2,
+        backgroundColor: 'rgba(255,255,255,0.5)',
+        marginBottom: 8,
+    },
+    titleRow: {
+        flexDirection: 'row', justifyContent: 'space-between',
+        alignItems: 'center', width: '100%',
+    },
+    title: { color: '#fff', fontWeight: 'bold', fontSize: 12 },
+    minimizeBtn: { color: '#aaa', fontSize: 18 },
+    dragHint: { color: 'rgba(255,255,255,0.35)', fontSize: 9, marginTop: 4 },
+    body: { padding: 12 },
+    label: { color: '#ddd', fontSize: 12 },
+    // Metrics grid
+    grid: { flexDirection: 'row', flexWrap: 'wrap', gap: 8, marginBottom: 10 },
+    metricBox: {
+        backgroundColor: 'rgba(255,255,255,0.06)',
+        borderRadius: 8, padding: 8,
+        minWidth: '30%', flex: 1,
+        alignItems: 'center',
+    },
+    metricValue: { color: '#fff', fontWeight: 'bold', fontSize: 15 },
+    metricLabel: { color: 'rgba(255,255,255,0.5)', fontSize: 9, marginTop: 2, textAlign: 'center' },
+    metricSub: { color: 'rgba(255,255,255,0.3)', fontSize: 8, textAlign: 'center' },
+    // Suggestions
+    divider: { height: 1, backgroundColor: 'rgba(255,255,255,0.1)', marginBottom: 8 },
+    sectionLabel: { color: 'rgba(255,255,255,0.35)', fontSize: 9, letterSpacing: 1, marginBottom: 6 },
+    suggestion: { flexDirection: 'row', alignItems: 'flex-start', marginBottom: 5, gap: 6 },
+    suggestionEmoji: { fontSize: 12, lineHeight: 16 },
+    suggestionText: { fontSize: 11, lineHeight: 16, flex: 1 },
+    // Minimized pill
+    pill: {
+        position: 'absolute',
+        width: PILL_SIZE, height: PILL_SIZE, borderRadius: PILL_SIZE / 2,
+        backgroundColor: 'rgba(20,20,20,0.92)',
+        borderWidth: 1, borderColor: 'rgba(255,255,255,0.2)',
+        alignItems: 'center', justifyContent: 'center',
+    },
+    pillText: { fontSize: 24, textAlign: 'center' },
+});

package/lib/index.d.ts

@@ -1,5 +1,6 @@
-import { GeoServiceConfig, GeoSubscription, Location, LocationCallback, ErrorCallback } from './types';
+import { GeoServiceConfig, GeoSubscription, Location, LocationCallback, ErrorCallback, BatteryInfo } from './types';
 export * from './types';
+export declare function _isDebugMode(): boolean;
 /**
  * Configure the geo service. Call this before start().
  * Safe to call multiple times; subsequent calls update the config.
@@ -60,6 +61,16 @@ declare function onError(callback: ErrorCallback): GeoSubscription;
  * @platform android
  */
 declare function registerHeadlessTask(handler: (location: Location) => Promise<void>): void;
+/**
+ * Returns battery information including current level and drain since tracking started.
+ * Only meaningful after start() has been called.
+ */
+declare function getBatteryInfo(): Promise<BatteryInfo>;
+/**
+ * Show or hide the status bar location indicator at runtime (iOS only).
+ * On Android this is a no-op — the foreground notification handles visibility.
+ */
+declare function setLocationIndicator(show: boolean): Promise<void>;
 declare const RNGeoService: {
     configure: typeof configure;
     start: typeof start;
@@ -69,5 +80,9 @@ declare const RNGeoService: {
     onLocation: typeof onLocation;
     onError: typeof onError;
     registerHeadlessTask: typeof registerHeadlessTask;
+    getBatteryInfo: typeof getBatteryInfo;
+    setLocationIndicator: typeof setLocationIndicator;
 };
 export default RNGeoService;
+export { GeoDebugPanel } from './GeoDebugPanel';
+export { GeoDebugOverlay } from './GeoDebugOverlay';

package/lib/index.js

@@ -23,6 +23,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoDebugOverlay = exports.GeoDebugPanel = void 0;
+exports._isDebugMode = _isDebugMode;
 const react_native_1 = require("react-native");
 __exportStar(require("./types"), exports);
 // The native bridge module registered as "RNGeoService" on both platforms
@@ -52,12 +54,18 @@ const DEFAULT_CONFIG = {
     idleSampleCount: 3,
     debug: false,
 };
+// Tracks the debug flag set via configure() so GeoDebugOverlay can
+// read it without the consuming app having to pass it as a prop.
+let _debugMode = false;
+function _isDebugMode() { return _debugMode; }
 /**
  * Configure the geo service. Call this before start().
  * Safe to call multiple times; subsequent calls update the config.
  */
 function configure(config) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        _debugMode = (_a = config.debug) !== null && _a !== void 0 ? _a : false;
         const merged = Object.assign(Object.assign({}, DEFAULT_CONFIG), config);
         return nativeModule.configure(merged);
     });
@@ -142,6 +150,24 @@ function registerHeadlessTask(handler) {
     const taskName = DEFAULT_CONFIG.backgroundTaskName;
     react_native_1.AppRegistry.registerHeadlessTask(taskName, () => handler);
 }
+/**
+ * Returns battery information including current level and drain since tracking started.
+ * Only meaningful after start() has been called.
+ */
+function getBatteryInfo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return nativeModule.getBatteryInfo();
+    });
+}
+/**
+ * Show or hide the status bar location indicator at runtime (iOS only).
+ * On Android this is a no-op — the foreground notification handles visibility.
+ */
+function setLocationIndicator(show) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return nativeModule.setLocationIndicator(show);
+    });
+}
 const RNGeoService = {
     configure,
     start,
@@ -151,5 +177,11 @@ const RNGeoService = {
     onLocation,
     onError,
     registerHeadlessTask,
+    getBatteryInfo,
+    setLocationIndicator,
 };
 exports.default = RNGeoService;
+var GeoDebugPanel_1 = require("./GeoDebugPanel");
+Object.defineProperty(exports, "GeoDebugPanel", { enumerable: true, get: function () { return GeoDebugPanel_1.GeoDebugPanel; } });
+var GeoDebugOverlay_1 = require("./GeoDebugOverlay");
+Object.defineProperty(exports, "GeoDebugOverlay", { enumerable: true, get: function () { return GeoDebugOverlay_1.GeoDebugOverlay; } });

package/lib/types.d.ts

@@ -137,3 +137,23 @@ export type ErrorCallback = (error: LocationError) => void;
 export interface GeoSubscription {
     remove(): void;
 }
+export interface BatteryInfo {
+    /** Current battery level 0–100 */
+    level: number;
+    /** Whether the device is currently charging */
+    isCharging: boolean;
+    /** Battery level when tracking was started (0–100) */
+    levelAtStart: number;
+    /** Percentage points drained since tracking started */
+    drainSinceStart: number;
+    /** How many total location have been delivered since start() */
+    updateCount: number;
+    /** Total seconds since start() was called */
+    trackingElapsedSeconds: number;
+    /** Seconds the GPS chip was actively running (not in idle/low-power mode) */
+    gpsActiveSeconds: number;
+    /** Location updates per minute (averaged over entire session) */
+    updatesPerMinute: number;
+    /** Battery drain rate in percentage points per hour */
+    drainRatePerHour: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsachit/react-native-geo-service",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Battery-efficient background geolocation for React Native with headless support",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -28,6 +28,7 @@
     "react-native": ">=0.60.0"
   },
   "devDependencies": {
+    "@types/react": "^18.3.28",
     "@types/react-native": "0.73.0",
     "typescript": "5.9.3"
   },