@josuelmm/cordova-background-geolocation 4.2.2 → 4.5.1

package/android/common/src/main/java/com/marianhello/bgloc/data/sqlite/SQLiteLocationDAO.java

@@ -300,7 +300,10 @@ public class SQLiteLocationDAO implements LocationDAO {
             .append(LocationEntry.COLUMN_NAME_LOCATION_PROVIDER).append("= ?,")
             .append(LocationEntry.COLUMN_NAME_BATCH_START_MILLIS).append("= ?,")
             .append(LocationEntry.COLUMN_NAME_STATUS).append("= ?,")
-            .append(LocationEntry.COLUMN_NAME_MOCK_FLAGS).append("= ?")
+            .append(LocationEntry.COLUMN_NAME_MOCK_FLAGS).append("= ?,")
+            .append(LocationEntry.COLUMN_NAME_EVENTS_JSON).append("= ?,")
+            .append(LocationEntry.COLUMN_NAME_BATTERY_LEVEL).append("= ?,")
+            .append(LocationEntry.COLUMN_NAME_IS_CHARGING).append("= ?")
             .append(" WHERE ").append(LocationEntry._ID)
             .append("= ?")
             .toString();
@@ -325,6 +328,9 @@ public class SQLiteLocationDAO implements LocationDAO {
             location.getBatchStartMillis(),
             location.getStatus(),
             location.getMockFlags(),
+            location.hasDrivingEvents() ? location.getDrivingEvents().toString() : null,
+            location.getBatteryLevel(),
+            location.isCharging() != null ? (location.isCharging() ? 1 : 0) : null,
             locationId
     });
 
@@ -459,6 +465,18 @@ public class SQLiteLocationDAO implements LocationDAO {
     l.setStatus(c.getInt(c.getColumnIndex(LocationEntry.COLUMN_NAME_STATUS)));
     l.setLocationId(c.getLong(c.getColumnIndex(LocationEntry._ID)));
     l.setMockFlags(c.getInt((c.getColumnIndex(LocationEntry.COLUMN_NAME_MOCK_FLAGS))));
+    // v4.5: events / battery / charging
+    int idxEv = c.getColumnIndex(LocationEntry.COLUMN_NAME_EVENTS_JSON);
+    if (idxEv >= 0 && !c.isNull(idxEv)) {
+      String s = c.getString(idxEv);
+      if (s != null && !s.isEmpty()) {
+        try { l.setDrivingEvents(new org.json.JSONArray(s)); } catch (org.json.JSONException ignored) {}
+      }
+    }
+    int idxBat = c.getColumnIndex(LocationEntry.COLUMN_NAME_BATTERY_LEVEL);
+    if (idxBat >= 0 && !c.isNull(idxBat)) l.setBatteryLevel(c.getInt(idxBat));
+    int idxChg = c.getColumnIndex(LocationEntry.COLUMN_NAME_IS_CHARGING);
+    if (idxChg >= 0 && !c.isNull(idxChg)) l.setCharging(c.getInt(idxChg) == 1);
 
     return l;
   }
@@ -485,6 +503,16 @@ public class SQLiteLocationDAO implements LocationDAO {
     values.put(LocationEntry.COLUMN_NAME_STATUS, l.getStatus());
     values.put(LocationEntry.COLUMN_NAME_BATCH_START_MILLIS, l.getBatchStartMillis());
     values.put(LocationEntry.COLUMN_NAME_MOCK_FLAGS, l.getMockFlags());
+    // v4.5.1: always write — NULL when absent — to clear stale values on maxRows recycle.
+    if (l.hasDrivingEvents()) {
+      values.put(LocationEntry.COLUMN_NAME_EVENTS_JSON, l.getDrivingEvents().toString());
+    } else {
+      values.putNull(LocationEntry.COLUMN_NAME_EVENTS_JSON);
+    }
+    if (l.getBatteryLevel() != null) values.put(LocationEntry.COLUMN_NAME_BATTERY_LEVEL, l.getBatteryLevel());
+    else values.putNull(LocationEntry.COLUMN_NAME_BATTERY_LEVEL);
+    if (l.isCharging() != null) values.put(LocationEntry.COLUMN_NAME_IS_CHARGING, l.isCharging() ? 1 : 0);
+    else values.putNull(LocationEntry.COLUMN_NAME_IS_CHARGING);
 
     return values;
   }
@@ -511,7 +539,10 @@ public class SQLiteLocationDAO implements LocationDAO {
             LocationEntry.COLUMN_NAME_LOCATION_PROVIDER,
             LocationEntry.COLUMN_NAME_STATUS,
             LocationEntry.COLUMN_NAME_BATCH_START_MILLIS,
-            LocationEntry.COLUMN_NAME_MOCK_FLAGS
+            LocationEntry.COLUMN_NAME_MOCK_FLAGS,
+            LocationEntry.COLUMN_NAME_EVENTS_JSON,
+            LocationEntry.COLUMN_NAME_BATTERY_LEVEL,
+            LocationEntry.COLUMN_NAME_IS_CHARGING
     };
 
     return columns;

package/android/common/src/main/java/com/marianhello/bgloc/data/sqlite/SQLiteOpenHelper.java

@@ -22,7 +22,7 @@ import static com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationE
 public class SQLiteOpenHelper extends android.database.sqlite.SQLiteOpenHelper {
     private static final String TAG = SQLiteOpenHelper.class.getName();
     public static final String SQLITE_DATABASE_NAME = "cordova_bg_geolocation.db";
-    public static final int DATABASE_VERSION = 20;
+    public static final int DATABASE_VERSION = 22;
 
     public static final String TEXT_TYPE = " TEXT";
     public static final String INTEGER_TYPE = " INTEGER";
@@ -143,6 +143,20 @@ public class SQLiteOpenHelper extends android.database.sqlite.SQLiteOpenHelper {
             case 19:
                 alterSql.add(SessionEntry.SQL_CREATE_SESSION_TABLE);
                 alterSql.add(SessionEntry.SQL_CREATE_SESSION_TABLE_TIME_IDX);
+            case 20:
+                // v4.4.1: store the full Config as a single JSON blob so future-added fields
+                // do not require a per-field schema bump.
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_CONFIG_JSON + TEXT_TYPE);
+            case 21:
+                // v4.5.0: persist driving events / battery / isCharging on each location so
+                // they survive the sync queue (POST failure → SQLite → background sync).
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_EVENTS_JSON + TEXT_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_BATTERY_LEVEL + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_IS_CHARGING + INTEGER_TYPE);
 
                 break; // DO NOT FORGET TO MOVE DOWN BREAK ON DB UPGRADE!!!
             default:

package/android/common/src/main/java/com/marianhello/bgloc/provider/DistanceFilterLocationProvider.java

@@ -33,9 +33,10 @@ public class DistanceFilterLocationProvider extends AbstractLocationProvider imp
     private static final String SINGLE_LOCATION_UPDATE_ACTION   = P_NAME + ".SINGLE_LOCATION_UPDATE_ACTION";
     private static final String STATIONARY_LOCATION_MONITOR_ACTION = P_NAME + ".STATIONARY_LOCATION_MONITOR_ACTION";
 
-    private static final long STATIONARY_TIMEOUT                                = 5 * 1000 * 60;    // 5 minutes.
-    private static final long STATIONARY_LOCATION_POLLING_INTERVAL_LAZY         = 3 * 1000 * 60;    // 3 minutes.
-    private static final long STATIONARY_LOCATION_POLLING_INTERVAL_AGGRESSIVE   = 1 * 1000 * 60;    // 1 minute.
+    // v4.5.1: defaults — overridable per-config via config.stationaryTimeout / stationaryPollInterval / stationaryPollFast
+    private static final long DEFAULT_STATIONARY_TIMEOUT                                = 5 * 1000 * 60;
+    private static final long DEFAULT_STATIONARY_LOCATION_POLLING_INTERVAL_LAZY         = 3 * 1000 * 60;
+    private static final long DEFAULT_STATIONARY_LOCATION_POLLING_INTERVAL_AGGRESSIVE   = 1 * 1000 * 60;
     private static final int MAX_STATIONARY_ACQUISITION_ATTEMPTS = 5;
     private static final int MAX_SPEED_ACQUISITION_ATTEMPTS = 3;
 
@@ -50,6 +51,20 @@ public class DistanceFilterLocationProvider extends AbstractLocationProvider imp
     private PendingIntent stationaryAlarmPI;
     private PendingIntent stationaryLocationPollingPI;
     private long stationaryLocationPollingInterval;
+
+    /** v4.5.1: read overrides from {@link com.marianhello.bgloc.Config}; fall back to defaults. */
+    private long getStationaryTimeout() {
+        Integer v = mConfig != null ? mConfig.getStationaryTimeout() : null;
+        return v != null ? v.longValue() : DEFAULT_STATIONARY_TIMEOUT;
+    }
+    private long getStationaryPollLazy() {
+        Integer v = mConfig != null ? mConfig.getStationaryPollInterval() : null;
+        return v != null ? v.longValue() : DEFAULT_STATIONARY_LOCATION_POLLING_INTERVAL_LAZY;
+    }
+    private long getStationaryPollFast() {
+        Integer v = mConfig != null ? mConfig.getStationaryPollFast() : null;
+        return v != null ? v.longValue() : DEFAULT_STATIONARY_LOCATION_POLLING_INTERVAL_AGGRESSIVE;
+    }
     private PendingIntent stationaryRegionPI;
     private PendingIntent singleUpdatePI;
     private Integer scaledDistanceFilter;
@@ -367,7 +382,7 @@ public class DistanceFilterLocationProvider extends AbstractLocationProvider imp
     public void resetStationaryAlarm() {
         if (alarmManager == null || stationaryAlarmPI == null) return;
         alarmManager.cancel(stationaryAlarmPI);
-        alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + STATIONARY_TIMEOUT, stationaryAlarmPI);
+        alarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + getStationaryTimeout(), stationaryAlarmPI);
     }
 
     private Integer calculateDistanceFilter(Float speed) {
@@ -401,7 +416,7 @@ public class DistanceFilterLocationProvider extends AbstractLocationProvider imp
 
             this.stationaryRadius = proximityRadius;
 
-            startPollingStationaryLocation(STATIONARY_LOCATION_POLLING_INTERVAL_LAZY);
+            startPollingStationaryLocation(getStationaryPollLazy());
         } catch (SecurityException e) {
             logger.error("Security exception: {}", e.getMessage());
             this.handleSecurityException(e);
@@ -464,9 +479,9 @@ public class DistanceFilterLocationProvider extends AbstractLocationProvider imp
         if (distance > stationaryRadius) {
             onExitStationaryRegion(location);
         } else if (distance > 0) {
-            startPollingStationaryLocation(STATIONARY_LOCATION_POLLING_INTERVAL_AGGRESSIVE);
-        } else if (stationaryLocationPollingInterval != STATIONARY_LOCATION_POLLING_INTERVAL_LAZY) {
-            startPollingStationaryLocation(STATIONARY_LOCATION_POLLING_INTERVAL_LAZY);
+            startPollingStationaryLocation(getStationaryPollFast());
+        } else if (stationaryLocationPollingInterval != getStationaryPollLazy()) {
+            startPollingStationaryLocation(getStationaryPollLazy());
         }
     }
 

package/android/common/src/main/java/com/marianhello/bgloc/service/LocationServiceImpl.java

@@ -36,6 +36,7 @@ import android.os.Message;
 import android.os.PowerManager;
 import android.os.Process;
 import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
 
 import com.marianhello.bgloc.Config;
@@ -179,6 +180,13 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
     private com.marianhello.bgloc.sensor.SensorFusionDetector mSensorFusion;
     /** v4.2 Phase 8: cached tripActive state so hot-reload can re-inject it. */
     private volatile boolean mDrivingTripActive = false;
+    /** v4.3: events fired without a simultaneous fix (providerChange, sensor crash, phone usage,
+     *  manual SOS) buffered here and flushed onto the next location's `events` array.
+     *  v4.4.1: capped at PENDING_DRIVING_EVENTS_MAX entries (oldest evicted) and entries older
+     *  than PENDING_DRIVING_EVENTS_TTL_MS are dropped at flush time. */
+    private final org.json.JSONArray mPendingDrivingEvents = new org.json.JSONArray();
+    private static final int  PENDING_DRIVING_EVENTS_MAX = 20;
+    private static final long PENDING_DRIVING_EVENTS_TTL_MS = 60_000L;
     private static final long WATCHDOG_INTERVAL_MS = 60_000L;
     private final Handler mMainHandler = new Handler(Looper.getMainLooper());
     private final Runnable mWatchdogRunnable = new Runnable() {
@@ -188,12 +196,23 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
             if (!Boolean.TRUE.equals(mConfig.getEnableWatchdog())) return;
             long now = System.currentTimeMillis();
             if (mLastLocationTime > 0 && (now - mLastLocationTime) > WATCHDOG_INTERVAL_MS) {
-                logger.info("Location watchdog: no update in {}s, restarting provider", WATCHDOG_INTERVAL_MS / 1000);
-                try {
-                    mProvider.onStop();
-                    mProvider.onStart();
-                } catch (Exception e) {
-                    logger.warn("Watchdog restart failed", e);
+                // v4.5.1: when drivingEvents is enabled, treat "no fixes" while NOT tripActive as
+                // intentional stationary → don't restart (saves battery). When drivingEvents is
+                // disabled (the plugin has no notion of "trip"), keep the legacy behaviour of
+                // restarting on every stale window.
+                Config.DrivingEventsOptions de = mConfig.getDrivingEvents();
+                boolean drivingEnabled = de != null && de.enabled;
+                boolean shouldRestart = !drivingEnabled || mDrivingTripActive;
+                if (shouldRestart) {
+                    logger.info("Location watchdog: no update in {}s, restarting provider", WATCHDOG_INTERVAL_MS / 1000);
+                    try {
+                        mProvider.onStop();
+                        mProvider.onStart();
+                    } catch (Exception e) {
+                        logger.warn("Watchdog restart failed", e);
+                    }
+                } else {
+                    logger.debug("Location watchdog: stationary (no active trip); skipping restart");
                 }
             }
             mMainHandler.postDelayed(this, WATCHDOG_INTERVAL_MS);
@@ -476,9 +495,12 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                 mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG);
             }
         }
-        if (mWakeLock != null && !mWakeLock.isHeld()) {
+        // v4.5.1: only hold a permanent CPU wake lock when wakeLockMode == 'always'.
+        // Default 'posting' acquires only briefly during onLocation/post; 'none' never.
+        String wlMode = mConfig.getWakeLockMode() != null ? mConfig.getWakeLockMode() : "posting";
+        if ("always".equals(wlMode) && mWakeLock != null && !mWakeLock.isHeld()) {
             mWakeLock.acquire();
-            logger.debug("Wake lock acquired");
+            logger.debug("Wake lock acquired (mode=always)");
         }
 
         if (Boolean.TRUE.equals(mConfig.getEnableWatchdog())) {
@@ -536,18 +558,21 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         mDrivingDetector = new com.marianhello.bgloc.driving.DrivingEventsDetector(
                 new com.marianhello.bgloc.driving.DrivingEventsDetector.Listener() {
                     @Override public void onMoving(BackgroundLocation l) {
+                        attachDrivingEvent(l, "moving", null);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_MOVING);
                         if (l != null) b.putParcelable("payload", l);
                         broadcastMessage(b);
                     }
                     @Override public void onStopped(BackgroundLocation l) {
+                        attachDrivingEvent(l, "stopped", null);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_STOPPED);
                         if (l != null) b.putParcelable("payload", l);
                         broadcastMessage(b);
                     }
                     @Override public void onTripStart(BackgroundLocation l) {
+                        attachDrivingEvent(l, "tripStart", null);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_TRIP_START);
                         if (l != null) b.putParcelable("payload", l);
@@ -556,6 +581,9 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                         if (mSensorFusion != null) mSensorFusion.setTripActive(true);
                     }
                     @Override public void onTripEnd(BackgroundLocation l, double distance, long durationMs) {
+                        org.json.JSONObject extra = new org.json.JSONObject();
+                        try { extra.put("distance", distance); extra.put("durationMs", durationMs); } catch (org.json.JSONException ignored) {}
+                        attachDrivingEvent(l, "tripEnd", extra);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_TRIP_END);
                         if (l != null) b.putParcelable("payload", l);
@@ -566,6 +594,9 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                         if (mSensorFusion != null) mSensorFusion.setTripActive(false);
                     }
                     @Override public void onSpeeding(BackgroundLocation l, double speedKmh, double limitKmh) {
+                        org.json.JSONObject extra = new org.json.JSONObject();
+                        try { extra.put("speedKmh", speedKmh); extra.put("limitKmh", limitKmh); } catch (org.json.JSONException ignored) {}
+                        attachDrivingEvent(l, "speeding", extra);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_SPEEDING);
                         if (l != null) b.putParcelable("payload", l);
@@ -574,12 +605,19 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                         broadcastMessage(b);
                     }
                     @Override public void onProviderChange(String provider) {
+                        // No location associated; buffer for next fix.
+                        org.json.JSONObject ev = new org.json.JSONObject();
+                        try { ev.put("type", "providerChange"); ev.put("provider", provider != null ? provider : ""); ev.put("time", System.currentTimeMillis()); } catch (org.json.JSONException ignored) {}
+                        enqueuePendingDrivingEvent(ev);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_PROVIDER_CHANGE);
                         b.putString("provider", provider != null ? provider : "");
                         broadcastMessage(b);
                     }
                     @Override public void onHardBrake(BackgroundLocation l, double decelMps2) {
+                        org.json.JSONObject extra = new org.json.JSONObject();
+                        try { extra.put("value", decelMps2); } catch (org.json.JSONException ignored) {}
+                        attachDrivingEvent(l, "hardBrake", extra);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_HARD_BRAKE);
                         if (l != null) b.putParcelable("payload", l);
@@ -587,6 +625,9 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                         broadcastMessage(b);
                     }
                     @Override public void onRapidAcceleration(BackgroundLocation l, double accelMps2) {
+                        org.json.JSONObject extra = new org.json.JSONObject();
+                        try { extra.put("value", accelMps2); } catch (org.json.JSONException ignored) {}
+                        attachDrivingEvent(l, "rapidAcceleration", extra);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_RAPID_ACCELERATION);
                         if (l != null) b.putParcelable("payload", l);
@@ -594,6 +635,9 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                         broadcastMessage(b);
                     }
                     @Override public void onSharpTurn(BackgroundLocation l, double degPerSec) {
+                        org.json.JSONObject extra = new org.json.JSONObject();
+                        try { extra.put("value", degPerSec); } catch (org.json.JSONException ignored) {}
+                        attachDrivingEvent(l, "sharpTurn", extra);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_SHARP_TURN);
                         if (l != null) b.putParcelable("payload", l);
@@ -601,6 +645,9 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                         broadcastMessage(b);
                     }
                     @Override public void onPossibleCrash(BackgroundLocation l, double velocityDropKmh) {
+                        org.json.JSONObject extra = new org.json.JSONObject();
+                        try { extra.put("value", velocityDropKmh); extra.put("source", "gps"); } catch (org.json.JSONException ignored) {}
+                        attachDrivingEvent(l, "possibleCrash", extra);
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_POSSIBLE_CRASH);
                         if (l != null) b.putParcelable("payload", l);
@@ -638,6 +685,15 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         com.marianhello.bgloc.sensor.SensorFusionDetector.Listener l =
                 new com.marianhello.bgloc.sensor.SensorFusionDetector.Listener() {
                     @Override public void onSensorCrash(BackgroundLocation lastLocation, double impactG) {
+                        // Buffer for next fix (sensor events fire async to GPS).
+                        try {
+                            org.json.JSONObject ev = new org.json.JSONObject();
+                            ev.put("type", "possibleCrash");
+                            ev.put("value", impactG);
+                            ev.put("source", "sensor");
+                            ev.put("time", System.currentTimeMillis());
+                            enqueuePendingDrivingEvent(ev);
+                        } catch (org.json.JSONException ignored) {}
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_POSSIBLE_CRASH);
                         if (lastLocation != null) b.putParcelable("payload", lastLocation);
@@ -646,6 +702,12 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                         broadcastMessage(b);
                     }
                     @Override public void onPhoneUsageWhileDriving(BackgroundLocation lastLocation) {
+                        try {
+                            org.json.JSONObject ev = new org.json.JSONObject();
+                            ev.put("type", "phoneUsageWhileDriving");
+                            ev.put("time", System.currentTimeMillis());
+                            enqueuePendingDrivingEvent(ev);
+                        } catch (org.json.JSONException ignored) {}
                         Bundle b = new Bundle();
                         b.putInt("action", MSG_ON_PHONE_USAGE_WHILE_DRIVING);
                         if (lastLocation != null) b.putParcelable("payload", lastLocation);
@@ -673,6 +735,89 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         if (sIsRunning) mSensorFusion.start();
     }
 
+    /** v4.3 — append a {type, time, ...extra} entry to the location's events array. */
+    private void attachDrivingEvent(BackgroundLocation loc, String type, org.json.JSONObject extra) {
+        if (loc == null || type == null) return;
+        try {
+            org.json.JSONObject ev = new org.json.JSONObject();
+            ev.put("type", type);
+            ev.put("time", System.currentTimeMillis());
+            if (extra != null) {
+                java.util.Iterator<String> keys = extra.keys();
+                while (keys.hasNext()) {
+                    String k = keys.next();
+                    ev.put(k, extra.opt(k));
+                }
+            }
+            loc.addDrivingEvent(ev);
+        } catch (org.json.JSONException ignored) {}
+    }
+
+    /** v4.5.1 — acquire a short, time-bounded wake lock when wakeLockMode is 'posting'. */
+    private void acquireWakeLockForPosting() {
+        if (mWakeLock == null || mConfig == null) return;
+        String mode = mConfig.getWakeLockMode() != null ? mConfig.getWakeLockMode() : "posting";
+        if (!"posting".equals(mode)) return;
+        try {
+            // Bounded: SQLite write + HTTP POST should finish well within 30 s.
+            if (!mWakeLock.isHeld()) mWakeLock.acquire(30_000L);
+        } catch (Throwable ignored) { /* best-effort */ }
+    }
+
+    /** v4.4 — read current device battery via sticky broadcast and stamp it onto the location.
+     *  No permission required. Sticky broadcast returns instantly without blocking.
+     *  v4.4.1: route through the application context to bypass our own registerReceiver()
+     *  override (which forces RECEIVER_NOT_EXPORTED + handler — incompatible with sticky-only reads). */
+    private void attachBatterySnapshot(BackgroundLocation loc) {
+        if (loc == null) return;
+        try {
+            android.content.IntentFilter filter = new android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED);
+            android.content.Intent batteryStatus = getApplicationContext().registerReceiver(null, filter);
+            if (batteryStatus == null) return;
+            int level = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_LEVEL, -1);
+            int scale = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_SCALE, -1);
+            if (level >= 0 && scale > 0) {
+                loc.setBatteryLevel((int) Math.round(level * 100.0 / scale));
+            }
+            int status = batteryStatus.getIntExtra(android.os.BatteryManager.EXTRA_STATUS, -1);
+            boolean charging = (status == android.os.BatteryManager.BATTERY_STATUS_CHARGING
+                    || status == android.os.BatteryManager.BATTERY_STATUS_FULL);
+            loc.setCharging(charging);
+        } catch (Throwable ignored) { /* best-effort; never fail the fix */ }
+    }
+
+    /** v4.3 — drain pending events (those fired without a simultaneous fix) onto this location.
+     *  v4.4.1: drop entries older than PENDING_DRIVING_EVENTS_TTL_MS so we don't anexar an event
+     *  whose context (location, speed, etc.) is no longer relevant. */
+    private void flushPendingDrivingEvents(BackgroundLocation loc) {
+        if (loc == null) return;
+        long now = System.currentTimeMillis();
+        synchronized (mPendingDrivingEvents) {
+            int n = mPendingDrivingEvents.length();
+            if (n == 0) return;
+            for (int i = 0; i < n; i++) {
+                org.json.JSONObject ev = mPendingDrivingEvents.optJSONObject(i);
+                if (ev == null) continue;
+                long t = ev.optLong("time", now);
+                if (now - t <= PENDING_DRIVING_EVENTS_TTL_MS) {
+                    loc.addDrivingEvent(ev);
+                }
+            }
+            for (int i = n - 1; i >= 0; i--) mPendingDrivingEvents.remove(i);
+        }
+    }
+
+    /** v4.4.1 — append to pending events with cap (oldest evicted). */
+    private void enqueuePendingDrivingEvent(org.json.JSONObject ev) {
+        if (ev == null) return;
+        synchronized (mPendingDrivingEvents) {
+            while (mPendingDrivingEvents.length() >= PENDING_DRIVING_EVENTS_MAX) {
+                mPendingDrivingEvents.remove(0);
+            }
+            mPendingDrivingEvents.put(ev);
+        }
+    }
+
     @Override
     public synchronized void startForegroundService() {
         start();
@@ -725,8 +870,9 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
      * Required before starting a location foreground service on API 34+.
      */
     private boolean hasLocationPermission() {
-        return checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
-                || checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        // v4.5.1 — ContextCompat handles API < 23 (permissions granted at install time).
+        return ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
+                || ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
     }
 
     /**
@@ -791,16 +937,32 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                 mProvider.onCommand(LocationProvider.CMD_SWITCH_MODE,
                         LocationProvider.FOREGROUND_MODE);
             }
-            // Android 14+ (API 34): type must match the merged manifest. Read it dynamically; if unknown, do not start.
-            if (Build.VERSION.SDK_INT >= 34) {
-                int type = getManifestForegroundServiceType();
-                if (type == 0) {
-                    logger.error("Cannot start foreground: manifest foregroundServiceType missing or unreadable");
+            // Android 14+ (API 34): type is required. Android 12-13 (API 31-33): type accepted (preferred).
+            // FOREGROUND_SERVICE_TYPE_LOCATION = 0x00000008. Resolve from merged manifest first;
+            // if reflection fails or manifest merge missed the attribute, fall back to LOCATION
+            // hardcoded so the FGS still promotes (otherwise: no notification, no background tracking).
+            try {
+                if (Build.VERSION.SDK_INT >= 30) {
+                    int type = getManifestForegroundServiceType();
+                    if (type == 0) {
+                        // Defensive fallback: every consumer of this plugin requires location FGS.
+                        // Logging at warn so the failure is visible without breaking the service.
+                        logger.warn("Manifest foregroundServiceType unreadable; defaulting to LOCATION (0x8). "
+                                + "Verify merged AndroidManifest has foregroundServiceType=\"location\"." );
+                        type = 0x00000008; // ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION
+                    }
+                    super.startForeground(NOTIFICATION_ID, notification, type);
+                } else {
+                    super.startForeground(NOTIFICATION_ID, notification);
+                }
+            } catch (Throwable t) {
+                logger.error("startForeground threw {}; retrying without type", t.getMessage());
+                try {
+                    super.startForeground(NOTIFICATION_ID, notification);
+                } catch (Throwable t2) {
+                    logger.error("startForeground retry failed: {}", t2.getMessage());
                     return;
                 }
-                super.startForeground(NOTIFICATION_ID, notification, type);
-            } else {
-                super.startForeground(NOTIFICATION_ID, notification);
             }
             mIsInForeground = true;
             scheduleNotificationUpdater();
@@ -955,6 +1117,26 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                     if (!equalsDrivingEvents(prevDe, newDe)) {
                         configureDrivingDetector();
                     }
+                    // v4.5.1 — hot-reload wakeLockMode: when transitioning between always /
+                    // posting / none, the existing permanent lock (if any) must be released,
+                    // or a new permanent lock acquired. Without this, switching mode at runtime
+                    // either leaked CPU or left the service running without the requested lock.
+                    String prevWl = currentConfig.getWakeLockMode() != null ? currentConfig.getWakeLockMode() : "posting";
+                    String newWl  = mConfig.getWakeLockMode()      != null ? mConfig.getWakeLockMode()      : "posting";
+                    if (!prevWl.equals(newWl) && mWakeLock != null) {
+                        if ("always".equals(newWl)) {
+                            if (!mWakeLock.isHeld()) {
+                                try { mWakeLock.acquire(); logger.debug("Wake lock acquired (hot-reload → always)"); }
+                                catch (Throwable t) { logger.warn("Wake lock acquire failed", t); }
+                            }
+                        } else {
+                            // 'posting' or 'none' — release any permanent lock; per-fix lock continues to work via acquireWakeLockForPosting().
+                            if (mWakeLock.isHeld()) {
+                                try { mWakeLock.release(); logger.debug("Wake lock released (hot-reload → {})", newWl); }
+                                catch (Throwable t) { logger.warn("Wake lock release failed", t); }
+                            }
+                        }
+                    }
                 }
             }
         });
@@ -1022,15 +1204,19 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
 
     @Override
     public void onLocation(BackgroundLocation location) {
+        // v4.5.1: in 'posting' wake-lock mode, hold the CPU briefly so SQLite writes + HTTP
+        // POST finish before the system returns to deep sleep. 30s ceiling — plenty for a fix.
+        acquireWakeLockForPosting();
         mLastLocationTime = System.currentTimeMillis();
         mLastReceivedLocation = location;
         sLastReceivedLocation = location;
 
-        // v4.0 Phase 6: feed the driver-insights state machine.
+        // v4.0 Phase 6: feed the driver-insights state machine on the *raw* location so speed/bearing
+        // come straight from the sensors. Listener attaches events to this same instance.
         if (mDrivingDetector != null) {
             mDrivingDetector.onLocation(location);
         }
-        // v4.2 Phase 8: keep sensor pipeline aware of the latest fix.
+        // v4.2 Phase 8: keep sensor pipeline aware of the latest raw fix.
         if (mSensorFusion != null) {
             mSensorFusion.setLastLocation(location);
         }
@@ -1056,12 +1242,38 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         }
         logger.debug("New location {}", location.toString());
 
+        // v4.5.1 — events were attached to the RAW location above (so detector heuristics see real
+        // speed/bearing). If transformLocation() returns a NEW instance, we'd lose those events
+        // and the battery snapshot. Solution: copy them across to the transformed instance below.
+        org.json.JSONArray rawEvents = location.getDrivingEvents();
+        Integer rawBatteryLevel = null;
+        Boolean rawIsCharging = null;
+
         location = transformLocation(location);
         if (location == null) {
             logger.debug("Skipping location as requested by the locationTransform");
             return;
         }
 
+        // Re-attach events to the transformed location if the transform produced a new instance.
+        if (rawEvents != null && rawEvents.length() > 0 && location.getDrivingEvents() != rawEvents) {
+            try {
+                org.json.JSONArray copy = new org.json.JSONArray(rawEvents.toString());
+                for (int i = 0; i < copy.length(); i++) {
+                    org.json.JSONObject ev = copy.optJSONObject(i);
+                    if (ev != null) location.addDrivingEvent(ev);
+                }
+            } catch (org.json.JSONException ignored) {}
+        }
+        // v4.3: drain pending events (providerChange/sensor crash/phone usage) onto the post-transform
+        // instance so they always reach the backend.
+        flushPendingDrivingEvents(location);
+        // v4.4: stamp device battery snapshot onto the *transformed* location so it survives any
+        // user-supplied locationTransform that creates a new instance.
+        if (mConfig == null || !Boolean.FALSE.equals(mConfig.getIncludeBattery())) {
+            attachBatterySnapshot(location);
+        }
+
         Bundle bundle = new Bundle();
         bundle.putInt("action", MSG_ON_LOCATION);
         bundle.putParcelable("payload", location);
@@ -1091,6 +1303,11 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
             logger.debug("Skipping location as requested by the locationTransform");
             return;
         }
+        // v4.5.1 — same enrichment as regular fixes: drain pending events and stamp battery.
+        flushPendingDrivingEvents(location);
+        if (mConfig == null || !Boolean.FALSE.equals(mConfig.getIncludeBattery())) {
+            attachBatterySnapshot(location);
+        }
 
         Bundle bundle = new Bundle();
         bundle.putInt("action", MSG_ON_STATIONARY);
@@ -1190,7 +1407,15 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
 
     @Override
     public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
-        return super.registerReceiver(receiver, filter, null, mServiceHandler, RECEIVER_NOT_EXPORTED);
+        // v4.5.1 — RECEIVER_NOT_EXPORTED flag is required on Android 13+ (API 33) for non-system
+        // broadcasts and the 5-arg overload exists only from API 26. Guard for older OSs.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            return super.registerReceiver(receiver, filter, null, mServiceHandler, Context.RECEIVER_NOT_EXPORTED);
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            return super.registerReceiver(receiver, filter, null, mServiceHandler);
+        }
+        return super.registerReceiver(receiver, filter);
     }
 
     @Override

package/android/common/src/main/java/com/marianhello/bgloc/service/LocationServiceProxy.java

@@ -7,6 +7,8 @@ import android.content.pm.PackageManager;
 import android.os.Build;
 import android.util.Log;
 
+import androidx.core.content.ContextCompat;
+
 import com.marianhello.bgloc.Config;
 
 public class LocationServiceProxy implements LocationService, LocationServiceInfo {
@@ -100,8 +102,9 @@ public class LocationServiceProxy implements LocationService, LocationServiceInf
     }
 
     private boolean hasLocationPermission() {
-        return mContext.checkSelfPermission(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
-                || mContext.checkSelfPermission(Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+        // v4.5.1 — ContextCompat handles API < 23 safely.
+        return ContextCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
+                || ContextCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
     }
 
     @Override