@josuelmm/capacitor-background-geolocation 1.0.0

package/android/src/main/java/com/marianhello/bgloc/provider/LocationProvider.java

@@ -0,0 +1,32 @@
+/*
+According to apache license
+
+This is fork of christocracy cordova-plugin-background-geolocation plugin
+https://github.com/christocracy/cordova-plugin-background-geolocation
+
+This is a new class
+*/
+
+package com.marianhello.bgloc.provider;
+
+import com.marianhello.bgloc.Config;
+
+/**
+ * LocationProvider interface
+ */
+public interface LocationProvider {
+
+    int CMD_SWITCH_MODE = 1;
+
+    int BACKGROUND_MODE = 0;
+    int FOREGROUND_MODE = 1;
+
+    void onCreate();
+    void onDestroy();
+    void onStart();
+    void onStop();
+    void onCommand(int commandId, int arg1);
+    void onConfigure(Config config);
+    void setDelegate(ProviderDelegate delegate);
+    boolean isStarted();
+}

package/android/src/main/java/com/marianhello/bgloc/provider/LocationProviderFactory.java

@@ -0,0 +1,47 @@
+/*
+According to apache license
+
+This is fork of christocracy cordova-plugin-background-geolocation plugin
+https://github.com/christocracy/cordova-plugin-background-geolocation
+
+This is a new class
+*/
+
+package com.marianhello.bgloc.provider;
+
+import android.content.Context;
+
+import com.marianhello.bgloc.Config;
+
+import java.lang.IllegalArgumentException;
+
+/**
+ * LocationProviderFactory
+ */
+public class LocationProviderFactory {
+
+    private Context mContext;
+
+    public LocationProviderFactory(Context context) {
+        this.mContext = context;
+    };
+
+    public LocationProvider getInstance (Integer locationProvider) {
+        LocationProvider provider;
+        switch (locationProvider) {
+            case Config.DISTANCE_FILTER_PROVIDER:
+                provider = new DistanceFilterLocationProvider(mContext);
+                break;
+            case Config.ACTIVITY_PROVIDER:
+                provider = new ActivityRecognitionLocationProvider(mContext);
+                break;
+            case Config.RAW_PROVIDER:
+                provider = new RawLocationProvider(mContext);
+                break;
+            default:
+                throw new IllegalArgumentException("Provider not found");
+        }
+
+        return provider;
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/provider/ProviderDelegate.java

@@ -0,0 +1,12 @@
+package com.marianhello.bgloc.provider;
+
+import com.marianhello.bgloc.PluginException;
+import com.marianhello.bgloc.data.BackgroundActivity;
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+public interface ProviderDelegate {
+    void onLocation(BackgroundLocation location);
+    void onStationary(BackgroundLocation location);
+    void onActivity(BackgroundActivity activity);
+    void onError(PluginException error);
+}

package/android/src/main/java/com/marianhello/bgloc/provider/RawLocationProvider.java

@@ -0,0 +1,175 @@
+package com.marianhello.bgloc.provider;
+
+import android.content.Context;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Bundle;
+
+import com.marianhello.bgloc.Config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RawLocationProvider extends AbstractLocationProvider implements LocationListener {
+    private LocationManager locationManager;
+    private boolean isStarted = false;
+    // v4.5.2: providers we actively subscribed to (so we can unsubscribe cleanly).
+    private final List<String> activeProviders = new ArrayList<>(2);
+
+    public RawLocationProvider(Context context) {
+        super(context);
+        PROVIDER_ID = Config.RAW_PROVIDER;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        locationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
+    }
+
+    @Override
+    public void onStart() {
+        if (isStarted) {
+            return;
+        }
+        if (locationManager == null) {
+            logger.error("LocationManager is null");
+            return;
+        }
+        if (mConfig == null) {
+            logger.warn("RawLocationProvider started without config");
+            return;
+        }
+        // v4.5.2: honor desiredAccuracy and subscribe to all suitable providers
+        // simultaneously (GPS + Network when available). Previously RAW only
+        // used GPS-or-Network and ignored desiredAccuracy.
+        List<String> providers = pickProviders();
+        if (providers.isEmpty()) {
+            logger.warn("No location provider available (GPS and Network disabled)");
+            return;
+        }
+        activeProviders.clear();
+        for (String provider : providers) {
+            try {
+                logger.info("Requesting location updates from provider {}", provider);
+                locationManager.requestLocationUpdates(provider, mConfig.getInterval(), mConfig.getDistanceFilter(), this);
+                activeProviders.add(provider);
+            } catch (SecurityException e) {
+                logger.error("Security exception requesting {} updates: {}", provider, e.getMessage());
+                this.handleSecurityException(e);
+            } catch (IllegalArgumentException e) {
+                logger.warn("requestLocationUpdates({}) failed: {}", provider, e.getMessage());
+            }
+        }
+        isStarted = !activeProviders.isEmpty();
+    }
+
+    /**
+     * v4.5.2: choose providers based on desiredAccuracy.
+     * <ul>
+     *   <li>&lt; 1000 m → include GPS when enabled (HIGH / BALANCED)</li>
+     *   <li>≥ 10 m → include Network when enabled (covers indoor and quick fixes)</li>
+     *   <li>≥ 1000 m → Network-only (LOW_POWER)</li>
+     * </ul>
+     * Falls back to whatever is enabled if the preferred set is empty.
+     */
+    private List<String> pickProviders() {
+        List<String> result = new ArrayList<>(2);
+        if (locationManager == null) return result;
+
+        Integer da = mConfig != null ? mConfig.getDesiredAccuracy() : null;
+        int desired = (da != null) ? da : 100; // default BALANCED
+
+        boolean wantGps = desired < 1000;
+        boolean wantNet = desired >= 10;
+
+        boolean gpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
+        boolean netEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
+
+        if (wantGps && gpsEnabled) result.add(LocationManager.GPS_PROVIDER);
+        if (wantNet && netEnabled) result.add(LocationManager.NETWORK_PROVIDER);
+
+        // Fallback: at least one of the available providers if our preferred set was empty.
+        if (result.isEmpty()) {
+            if (gpsEnabled) result.add(LocationManager.GPS_PROVIDER);
+            else if (netEnabled) result.add(LocationManager.NETWORK_PROVIDER);
+        }
+        return result;
+    }
+
+    /** Backwards-compatible single-provider picker used by onProviderDisabled to check fallback. */
+    private String pickProvider() {
+        List<String> ps = pickProviders();
+        return ps.isEmpty() ? null : ps.get(0);
+    }
+
+    @Override
+    public void onStop() {
+        if (!isStarted) {
+            return;
+        }
+        try {
+            // v4.5.2: removeUpdates(this) detaches us from every provider we
+            // subscribed to via the same LocationListener.
+            locationManager.removeUpdates(this);
+        } catch (SecurityException e) {
+            logger.error("Security exception: {}", e.getMessage());
+            this.handleSecurityException(e);
+        } finally {
+            activeProviders.clear();
+            isStarted = false;
+        }
+    }
+
+    @Override
+    public void onConfigure(Config config) {
+        super.onConfigure(config);
+        if (isStarted) {
+            onStop();
+            onStart();
+        }
+    }
+
+    @Override
+    public boolean isStarted() {
+        return isStarted;
+    }
+
+    @Override
+    public void onLocationChanged(Location location) {
+        logger.debug("Location change: {}", location.toString());
+
+        showDebugToast("acy:" + location.getAccuracy() + ",v:" + location.getSpeed());
+        handleLocation(location);
+    }
+
+    @Override
+    public void onStatusChanged(String provider, int status, Bundle bundle) {
+        logger.debug("Provider {} status changed: {}", provider, status);
+    }
+
+    @Override
+    public void onProviderEnabled(String provider) {
+        logger.debug("Provider {} was enabled", provider);
+    }
+
+    @Override
+    public void onProviderDisabled(String provider) {
+        logger.warn("Provider {} was disabled", provider);
+        // v4.5.2: emit SERVICE error when no fallback provider is available so
+        // the JS layer can re-prompt the user. Matches DISTANCE_FILTER provider
+        // behavior.
+        if (locationManager != null && pickProvider() == null) {
+            handleServiceError("Location provider '" + provider + "' disabled and no fallback available.");
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        logger.debug("Destroying RawLocationProvider");
+        this.onStop();
+        super.onDestroy();
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/sensor/SensorFusionDetector.java

@@ -0,0 +1,199 @@
+package com.marianhello.bgloc.sensor;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.PowerManager;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+/**
+ * v4.2 Phase 8 — Real sensor fusion detector.
+ *
+ * Samples linear acceleration (TYPE_LINEAR_ACCELERATION, gravity removed) and
+ * gyroscope (TYPE_GYROSCOPE) at SENSOR_DELAY_GAME (~50 Hz). Used to refine
+ * possibleCrash and to detect phoneUsageWhileDriving. Pure-Android, no JNI.
+ *
+ * Crash detection: |a| (m/s²) above {@code crashImpactG} g during a tripActive
+ * window emits {@link Listener#onPossibleCrash}. Combined with the GPS-derived
+ * heuristic in {@link com.marianhello.bgloc.driving.DrivingEventsDetector},
+ * this gives a far higher-confidence signal at low speeds (parking-lot impact)
+ * where GPS alone misses.
+ *
+ * phoneUsageWhileDriving: while {@code tripActive} is true, if the screen turns
+ * on and the user produces touch-shaped jitter on the device for a sustained
+ * window, fires {@link Listener#onPhoneUsageWhileDriving}. Conservative — designed
+ * to avoid false-positives from passenger usage by tying to {@code tripActive}.
+ */
+public class SensorFusionDetector implements SensorEventListener {
+
+    public interface Listener {
+        /** Triggered when |a| exceeds crashImpactG while tripActive. */
+        void onSensorCrash(BackgroundLocation lastLocation, double impactG);
+        /** Screen on + sustained device interaction during tripActive. */
+        void onPhoneUsageWhileDriving(BackgroundLocation lastLocation);
+    }
+
+    public static class Config {
+        public boolean enabled = false;
+        /** Crash threshold in g. 1g = 9.81 m/s². Default 3g. */
+        public double crashImpactG = 3.0;
+        /** Cooldown between repeated crash detections. */
+        public long   crashCooldownMs = 10_000;
+        /** Min sustained gyro+accel jitter window for phoneUsage. */
+        public long   phoneUsageWindowMs = 4_000;
+        /** Cooldown between repeated phone-usage events. */
+        public long   phoneUsageCooldownMs = 60_000;
+    }
+
+    private static final float G = 9.80665f;
+
+    private final Context appContext;
+    private final Listener listener;
+    private final SensorManager sensorManager;
+    private final Sensor linearAccel;
+    private final Sensor gyroscope;
+    private final PowerManager powerManager;
+    private final Handler handler;
+
+    private Config cfg = new Config();
+    private boolean started = false;
+    private boolean tripActive = false;
+    private BackgroundLocation lastLocation;
+
+    private long lastCrashAt = 0L;
+    private long lastPhoneUsageAt = 0L;
+
+    // phoneUsage state
+    private long jitterAboveSince = 0L;
+    private static final double JITTER_GYRO_RAD_S = 0.7;     // ~40 deg/s
+    private static final double JITTER_ACCEL_MPS2 = 0.5;     // small accel, hand movement
+
+    public SensorFusionDetector(Context context, Listener listener) {
+        this.appContext = context.getApplicationContext();
+        this.listener = listener;
+        this.sensorManager = (SensorManager) appContext.getSystemService(Context.SENSOR_SERVICE);
+        this.linearAccel = sensorManager != null ? sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION) : null;
+        this.gyroscope = sensorManager != null ? sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE) : null;
+        this.powerManager = (PowerManager) appContext.getSystemService(Context.POWER_SERVICE);
+        this.handler = new Handler(Looper.getMainLooper());
+    }
+
+    public synchronized void setConfig(Config c) {
+        if (c != null) this.cfg = c;
+    }
+
+    public synchronized boolean isAvailable() {
+        return sensorManager != null && linearAccel != null;
+    }
+
+    /** Start sampling sensors. Idempotent. */
+    public synchronized void start() {
+        if (started || !cfg.enabled || sensorManager == null) return;
+        if (linearAccel != null) {
+            sensorManager.registerListener(this, linearAccel, SensorManager.SENSOR_DELAY_GAME, handler);
+        }
+        if (gyroscope != null) {
+            sensorManager.registerListener(this, gyroscope, SensorManager.SENSOR_DELAY_GAME, handler);
+        }
+        started = true;
+    }
+
+    /** Stop sampling. Idempotent. */
+    public synchronized void stop() {
+        if (!started) return;
+        if (sensorManager != null) sensorManager.unregisterListener(this);
+        started = false;
+        jitterAboveSince = 0L;
+    }
+
+    /** Called by detector host whenever the GPS layer marks tripActive on/off. */
+    public synchronized void setTripActive(boolean active) {
+        this.tripActive = active;
+        if (!active) jitterAboveSince = 0L;
+    }
+
+    /** Last known location for event payload. Updated by host. */
+    public synchronized void setLastLocation(BackgroundLocation loc) {
+        this.lastLocation = loc;
+    }
+
+    @Override public void onAccuracyChanged(Sensor sensor, int accuracy) { /* ignore */ }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        Listener l;
+        Config c;
+        boolean tripActiveNow;
+        BackgroundLocation loc;
+        synchronized (this) {
+            l = this.listener;
+            c = this.cfg;
+            tripActiveNow = this.tripActive;
+            loc = this.lastLocation;
+        }
+        if (l == null || c == null || !c.enabled) return;
+
+        long now = System.currentTimeMillis();
+
+        if (event.sensor.getType() == Sensor.TYPE_LINEAR_ACCELERATION) {
+            float ax = event.values[0], ay = event.values[1], az = event.values[2];
+            double mag = Math.sqrt(ax * ax + ay * ay + az * az);
+            double gMag = mag / G;
+
+            // Crash: high impact during a trip.
+            if (tripActiveNow && c.crashImpactG > 0 && gMag >= c.crashImpactG
+                    && (now - lastCrashAt) >= c.crashCooldownMs) {
+                lastCrashAt = now;
+                l.onSensorCrash(loc, gMag);
+            }
+
+            // Phone usage signal: small accel jitter during trip + screen on.
+            evaluatePhoneUsage(now, mag, /*gyroMag*/ -1, c, l, tripActiveNow, loc);
+        } else if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
+            float gx = event.values[0], gy = event.values[1], gz = event.values[2];
+            double gyroMag = Math.sqrt(gx * gx + gy * gy + gz * gz);
+            evaluatePhoneUsage(now, /*accelMag*/ -1, gyroMag, c, l, tripActiveNow, loc);
+        }
+    }
+
+    private void evaluatePhoneUsage(long now,
+                                    double accelMag,
+                                    double gyroMag,
+                                    Config c,
+                                    Listener l,
+                                    boolean tripActiveNow,
+                                    BackgroundLocation loc) {
+        if (!tripActiveNow) { jitterAboveSince = 0L; return; }
+        if (powerManager == null || !isScreenOn()) { jitterAboveSince = 0L; return; }
+
+        boolean above = (accelMag >= 0 && accelMag >= JITTER_ACCEL_MPS2)
+                || (gyroMag >= 0 && gyroMag >= JITTER_GYRO_RAD_S);
+        if (above) {
+            if (jitterAboveSince == 0L) jitterAboveSince = now;
+            if ((now - jitterAboveSince) >= c.phoneUsageWindowMs
+                    && (now - lastPhoneUsageAt) >= c.phoneUsageCooldownMs) {
+                lastPhoneUsageAt = now;
+                jitterAboveSince = 0L;
+                l.onPhoneUsageWhileDriving(loc);
+            }
+        } else {
+            jitterAboveSince = 0L;
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private boolean isScreenOn() {
+        if (powerManager == null) return false;
+        try {
+            // isInteractive added API 20; we target >= 21 elsewhere, but guard anyway.
+            return powerManager.isInteractive();
+        } catch (Throwable t) {
+            return powerManager.isScreenOn();
+        }
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/service/LocationService.java

@@ -0,0 +1,16 @@
+package com.marianhello.bgloc.service;
+
+import com.marianhello.bgloc.Config;
+
+public interface LocationService {
+    void start();
+    void startForegroundService();
+    void stop();
+    void startForeground();
+    void stopForeground();
+    void configure(Config config);
+    void registerHeadlessTask(String jsFunction);
+    void startHeadlessTask();
+    void stopHeadlessTask();
+    void executeProviderCommand(int command, int arg);
+}