@josuelmm/cordova-background-geolocation 4.2.3 → 4.5.2

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

@@ -60,6 +60,12 @@ public class LocationTemplateFactory {
         attrs.put("altitude", "@altitude");
         attrs.put("bearing", "@bearing");
         attrs.put("radius", "@radius");
+        // v4.5.1 — README/CHANGELOG promete que el payload default incluye events/battery/isCharging.
+        // Como Config.getTemplate() siempre cae a este default si no hay postTemplate custom, hay
+        // que añadirlos aquí para que PostLocationTask + BatchManager los serialicen al backend.
+        attrs.put("events", "@events");
+        attrs.put("battery", "@battery");
+        attrs.put("isCharging", "@isCharging");
         return new HashMapLocationTemplate(attrs);
     }
 }

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

@@ -47,6 +47,9 @@ public final class SQLiteConfigurationContract {
         public static final String COLUMN_NAME_TEMPLATE = "template";
         public static final String COLUMN_NAME_SHOW_TIME = "show_time";
         public static final String COLUMN_NAME_SHOW_DISTANCE = "show_distance";
+        // v4.4.1 — single JSON blob holding the full config (replaces per-field columns
+        // for new keys). Old columns are kept for backward compat with v20 databases.
+        public static final String COLUMN_NAME_CONFIG_JSON = "config_json";
 
         public static final String SQL_CREATE_CONFIG_TABLE =
                 "CREATE TABLE " + ConfigurationEntry.TABLE_NAME + " (" +
@@ -81,7 +84,8 @@ public final class SQLiteConfigurationContract {
                         ConfigurationEntry.COLUMN_NAME_MAX_LOCATIONS + INTEGER_TYPE + COMMA_SEP +
                         ConfigurationEntry.COLUMN_NAME_TEMPLATE + TEXT_TYPE + COMMA_SEP +
                         ConfigurationEntry.COLUMN_NAME_SHOW_TIME + INTEGER_TYPE + COMMA_SEP +
-                        ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE + INTEGER_TYPE +
+                        ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE + INTEGER_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_CONFIG_JSON + TEXT_TYPE +
                         " )";
 
         public static final String SQL_DROP_CONFIG_TABLE =

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

@@ -10,6 +10,7 @@ import org.json.JSONObject;
 import org.json.JSONException;
 
 import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.data.ConfigJsonMapper;
 import com.marianhello.bgloc.data.ConfigurationDAO;
 import com.marianhello.bgloc.data.LocationTemplateFactory;
 import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract.ConfigurationEntry;
@@ -63,7 +64,8 @@ public class SQLiteConfigurationDAO implements ConfigurationDAO {
       ConfigurationEntry.COLUMN_NAME_MAX_LOCATIONS,
       ConfigurationEntry.COLUMN_NAME_TEMPLATE,
       ConfigurationEntry.COLUMN_NAME_SHOW_TIME,
-      ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE
+      ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE,
+      ConfigurationEntry.COLUMN_NAME_CONFIG_JSON
     };
 
     String whereClause = null;
@@ -105,6 +107,26 @@ public class SQLiteConfigurationDAO implements ConfigurationDAO {
   }
 
   private Config hydrate(Cursor c) throws JSONException {
+    // v4.4.1: prefer the full JSON blob if present (covers all keys, including post-3.2 ones).
+    // Note: `template` (postTemplate) lives in its dedicated column — restore it after the
+    // JSON deserialization so it's not lost when the config arrived via config_json only.
+    int idxJson = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_CONFIG_JSON);
+    if (idxJson >= 0 && !c.isNull(idxJson)) {
+      String json = c.getString(idxJson);
+      if (json != null && !json.isEmpty()) {
+        try {
+          Config restored = ConfigJsonMapper.fromJSONObject(new JSONObject(json));
+          int idxTpl = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_TEMPLATE);
+          if (idxTpl >= 0 && !c.isNull(idxTpl)) {
+            restored.setTemplate(LocationTemplateFactory.fromJSONString(c.getString(idxTpl)));
+          }
+          return restored;
+        } catch (JSONException ex) {
+          Log.w(TAG, "config_json parse failed; falling back to legacy columns: " + ex.getMessage());
+        }
+      }
+    }
+    // Legacy hydration (DBs upgraded from v20 or earlier where config_json is still NULL).
     Config config = Config.getDefault();
     config.setStationaryRadius(c.getFloat(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_RADIUS)));
     config.setDistanceFilter(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_DISTANCE_FILTER)));
@@ -190,6 +212,15 @@ public class SQLiteConfigurationDAO implements ConfigurationDAO {
     values.put(ConfigurationEntry.COLUMN_NAME_TEMPLATE, config.hasTemplate() ? config.getTemplate().toString() : null);
     values.put(ConfigurationEntry.COLUMN_NAME_SHOW_TIME, Boolean.TRUE.equals(config.getShowTime()) ? 1 : 0);
     values.put(ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE, Boolean.TRUE.equals(config.getShowDistance()) ? 1 : 0);
+    // v4.4.1: persist the full Config as JSON so post-3.2 fields (httpMethod, queryParams,
+    // drivingEvents, includeBattery, mockLocationPolicy, heartbeatInterval, ...) survive
+    // a reboot / startOnBoot. Legacy columns are kept populated above for backward compat.
+    try {
+      values.put(ConfigurationEntry.COLUMN_NAME_CONFIG_JSON,
+              ConfigJsonMapper.toJSONObject(config).toString());
+    } catch (JSONException e) {
+      Log.w(TAG, "config_json serialize failed: " + e.getMessage());
+    }
 
     return values;
   }

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

@@ -37,6 +37,10 @@ public final class SQLiteLocationContract {
         public static final String COLUMN_NAME_STATUS = "valid";
         public static final String COLUMN_NAME_BATCH_START_MILLIS = "batch_start";
         public static final String COLUMN_NAME_MOCK_FLAGS = "mock_flags";
+        // v4.5 — survive sync queue: events JSON, battery percentage and charging state.
+        public static final String COLUMN_NAME_EVENTS_JSON = "events_json";
+        public static final String COLUMN_NAME_BATTERY_LEVEL = "battery_level";
+        public static final String COLUMN_NAME_IS_CHARGING = "is_charging";
 
         public static final String SQL_CREATE_LOCATION_TABLE =
                 "CREATE TABLE " + LocationEntry.TABLE_NAME + " (" +
@@ -60,7 +64,10 @@ public final class SQLiteLocationContract {
                         LocationEntry.COLUMN_NAME_LOCATION_PROVIDER + INTEGER_TYPE + COMMA_SEP +
                         LocationEntry.COLUMN_NAME_STATUS + INTEGER_TYPE + COMMA_SEP +
                         LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + INTEGER_TYPE + COMMA_SEP +
-                        LocationEntry.COLUMN_NAME_MOCK_FLAGS + INTEGER_TYPE +
+                        LocationEntry.COLUMN_NAME_MOCK_FLAGS + INTEGER_TYPE + COMMA_SEP +
+                        LocationEntry.COLUMN_NAME_EVENTS_JSON + TEXT_TYPE + COMMA_SEP +
+                        LocationEntry.COLUMN_NAME_BATTERY_LEVEL + INTEGER_TYPE + COMMA_SEP +
+                        LocationEntry.COLUMN_NAME_IS_CHARGING + INTEGER_TYPE +
                         " )";
 
         public static final String SQL_DROP_LOCATION_TABLE =
@@ -106,7 +113,10 @@ public final class SQLiteLocationContract {
                 COLUMN_NAME_LOCATION_PROVIDER,
                 COLUMN_NAME_STATUS,
                 COLUMN_NAME_BATCH_START_MILLIS,
-                COLUMN_NAME_MOCK_FLAGS
+                COLUMN_NAME_MOCK_FLAGS,
+                COLUMN_NAME_EVENTS_JSON,
+                COLUMN_NAME_BATTERY_LEVEL,
+                COLUMN_NAME_IS_CHARGING
         };
     }
 }

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/AbstractLocationProvider.java

@@ -88,11 +88,29 @@ public abstract class AbstractLocationProvider implements LocationProvider {
         mContext.unregisterReceiver(receiver);
     }
 
+    /**
+     * v4.5.2: drop fixes whose horizontal accuracy is worse than the configured
+     * maxAcceptedAccuracy threshold. Returns true when the location must be
+     * discarded.
+     */
+    private boolean exceedsMaxAcceptedAccuracy(Location location) {
+        if (location == null || mConfig == null) return false;
+        Float max = mConfig.getMaxAcceptedAccuracy();
+        if (max == null || max <= 0) return false;
+        if (!location.hasAccuracy()) return false;
+        if (location.getAccuracy() > max) {
+            logger.debug("Dropping fix: accuracy={} exceeds maxAcceptedAccuracy={}", location.getAccuracy(), max);
+            return true;
+        }
+        return false;
+    }
+
     /**
      * Handle location as recorder by provider
      * @param location
      */
     protected void handleLocation (Location location) {
+        if (exceedsMaxAcceptedAccuracy(location)) return;
         playDebugTone(Tone.BEEP);
         if (mDelegate != null) {
             BackgroundLocation bgLocation = new BackgroundLocation(PROVIDER_ID, location);
@@ -108,6 +126,7 @@ public abstract class AbstractLocationProvider implements LocationProvider {
      * @param radius radius of stationary region
      */
     protected void handleStationary (Location location, float radius) {
+        if (exceedsMaxAcceptedAccuracy(location)) return;
         playDebugTone(Tone.LONG_BEEP);
         if (mDelegate != null) {
             BackgroundLocation bgLocation = new BackgroundLocation(PROVIDER_ID, location);
@@ -123,6 +142,7 @@ public abstract class AbstractLocationProvider implements LocationProvider {
      * @param location
      */
     protected void handleStationary (Location location) {
+        if (exceedsMaxAcceptedAccuracy(location)) return;
         playDebugTone(Tone.LONG_BEEP);
         if (mDelegate != null) {
             BackgroundLocation bgLocation = new BackgroundLocation(PROVIDER_ID, location);
@@ -148,6 +168,26 @@ public abstract class AbstractLocationProvider implements LocationProvider {
         }
     }
 
+    /**
+     * v4.5.2: emit a permission-denied error to the delegate (used when a runtime
+     * permission such as ACTIVITY_RECOGNITION is missing on Android 10+).
+     */
+    protected void handlePermissionDenied(String message) {
+        if (mDelegate != null) {
+            mDelegate.onError(new PluginException(message, PluginException.PERMISSION_DENIED_ERROR));
+        }
+    }
+
+    /**
+     * v4.5.2: emit a service-level error to the delegate (used when Google Play
+     * Services is missing/outdated or the OS location service is disabled).
+     */
+    protected void handleServiceError(String message) {
+        if (mDelegate != null) {
+            mDelegate.onError(new PluginException(message, PluginException.SERVICE_ERROR));
+        }
+    }
+
     protected void showDebugToast (String text) {
         if (mConfig.isDebugging()) {
             Toast.makeText(mContext, text, Toast.LENGTH_LONG).show();
@@ -155,7 +195,14 @@ public abstract class AbstractLocationProvider implements LocationProvider {
     }
 
     public Boolean hasMockLocationsEnabled() {
-        return Settings.Secure.getString(mContext.getContentResolver(), android.provider.Settings.Secure.ALLOW_MOCK_LOCATION).equals("1");
+        // v4.5.2: Settings.Secure.getString may return null (key absent on the
+        // device's settings provider). The previous code crashed with NPE because
+        // it called .equals("1") on the returned value. Invert the comparison so
+        // null safely yields false.
+        String value = Settings.Secure.getString(
+                mContext.getContentResolver(),
+                android.provider.Settings.Secure.ALLOW_MOCK_LOCATION);
+        return "1".equals(value);
     }
 
     /**

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

@@ -12,6 +12,8 @@ import android.os.Build;
 import android.os.Looper;
 import androidx.core.app.ActivityCompat;
 
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
 import com.google.android.gms.location.ActivityRecognition;
 import com.google.android.gms.location.ActivityRecognitionClient;
 import com.google.android.gms.location.ActivityRecognitionResult;
@@ -41,8 +43,19 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
     private boolean isStarted = false;
     private boolean isTracking = false;
     private boolean isWatchingActivity = false;
+    private boolean playServicesAvailable = false;
+    private boolean activityPermissionErrorEmitted = false;
+    private boolean stopOnStillWarningEmitted = false;
     private DetectedActivity lastActivity = new DetectedActivity(DetectedActivity.UNKNOWN, 100);
 
+    // v4.5.2: snapshot of fields that require restarting tracking when they change.
+    private Integer prevDesiredAccuracy;
+    private Integer prevInterval;
+    private Integer prevFastestInterval;
+    private Integer prevDistanceFilter;
+    private Integer prevActivitiesInterval;
+    private Boolean prevStopOnStillActivity;
+
     private final LocationCallback locationCallback = new LocationCallback() {
         @Override
         public void onLocationResult(LocationResult result) {
@@ -63,6 +76,20 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
     @Override
     public void onCreate() {
         super.onCreate();
+
+        // v4.5.2: ACTIVITY_PROVIDER strictly depends on Google Play Services
+        // (FusedLocationProviderClient + ActivityRecognitionClient). If GPS is
+        // missing/outdated we cannot operate — surface a clear error instead of
+        // silently failing.
+        int gps = GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(mContext);
+        playServicesAvailable = (gps == ConnectionResult.SUCCESS);
+        if (!playServicesAvailable) {
+            String msg = "Google Play Services unavailable for ACTIVITY_PROVIDER (code=" + gps + "); provider will be inert.";
+            logger.error(msg);
+            handleServiceError(msg);
+            return;
+        }
+
         fusedLocationClient = LocationServices.getFusedLocationProviderClient(mContext);
         activityRecognitionClient = ActivityRecognition.getClient(mContext);
 
@@ -80,6 +107,15 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
     public void onStart() {
         logger.info("Start recording");
         this.isStarted = true;
+
+        // v4.5.2: ACTIVITY_PROVIDER hinges on the STILL/ACTIVE state machine.
+        // If the host turned that off, the provider degenerates into a tracker
+        // that never pauses — warn so it shows up in logcat for the integrator.
+        if (mConfig != null && Boolean.FALSE.equals(mConfig.getStopOnStillActivity()) && !stopOnStillWarningEmitted) {
+            logger.warn("ACTIVITY_PROVIDER with stopOnStillActivity=false will track continuously; consider DISTANCE_FILTER_PROVIDER or RAW_PROVIDER for that use case.");
+            stopOnStillWarningEmitted = true;
+        }
+
         attachRecorder();
     }
 
@@ -93,11 +129,40 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
 
     @Override
     public void onConfigure(Config config) {
-        super.onConfigure(config);
+        // v4.5.2: only restart tracking if a field that actually affects the
+        // LocationRequest / activity-updates subscription has changed. A no-op
+        // reconfigure used to drop+re-add the location callback and momentarily
+        // leave the service without updates.
+        boolean restart = false;
         if (isStarted) {
+            restart = !sameValue(prevDesiredAccuracy, config != null ? config.getDesiredAccuracy() : null)
+                    || !sameValue(prevInterval, config != null ? config.getInterval() : null)
+                    || !sameValue(prevFastestInterval, config != null ? config.getFastestInterval() : null)
+                    || !sameValue(prevDistanceFilter, config != null ? config.getDistanceFilter() : null)
+                    || !sameValue(prevActivitiesInterval, config != null ? config.getActivitiesInterval() : null)
+                    || !sameValue(prevStopOnStillActivity, config != null ? config.getStopOnStillActivity() : null);
+        }
+
+        super.onConfigure(config);
+
+        if (restart) {
+            logger.debug("Restarting ACTIVITY_PROVIDER tracking after relevant config change.");
             onStop();
             onStart();
         }
+
+        if (config != null) {
+            prevDesiredAccuracy = config.getDesiredAccuracy();
+            prevInterval = config.getInterval();
+            prevFastestInterval = config.getFastestInterval();
+            prevDistanceFilter = config.getDistanceFilter();
+            prevActivitiesInterval = config.getActivitiesInterval();
+            prevStopOnStillActivity = config.getStopOnStillActivity();
+        }
+    }
+
+    private static boolean sameValue(Object a, Object b) {
+        return a == null ? b == null : a.equals(b);
     }
 
     @Override
@@ -139,10 +204,16 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
         int priority = translateDesiredAccuracy(mConfig.getDesiredAccuracy());
         // v3.4: LocationRequest.Builder (play-services-location 21.0.0+) replaces deprecated
         // LocationRequest.create() + setPriority/setInterval/setFastestInterval.
-        LocationRequest locationRequest = new LocationRequest.Builder(priority, mConfig.getInterval())
+        // v4.5.2: also honor distanceFilter (was ignored on ACTIVITY_PROVIDER), so the
+        // FusedLocationProvider can throttle by distance and not just by interval.
+        LocationRequest.Builder builder = new LocationRequest.Builder(priority, mConfig.getInterval())
                 .setMinUpdateIntervalMillis(mConfig.getFastestInterval())
-                .setWaitForAccurateLocation(false)
-                .build();
+                .setWaitForAccurateLocation(false);
+        Integer distanceFilter = mConfig.getDistanceFilter();
+        if (distanceFilter != null && distanceFilter > 0) {
+            builder.setMinUpdateDistanceMeters(distanceFilter.floatValue());
+        }
+        LocationRequest locationRequest = builder.build();
 
         try {
             fusedLocationClient.requestLocationUpdates(
@@ -185,7 +256,20 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
 
         startTracking();
 
-        if (!isWatchingActivity && mConfig.getStopOnStillActivity() && activityRecognitionPermitted()) {
+        if (!isWatchingActivity && mConfig.getStopOnStillActivity()) {
+            // v4.5.2: on Android 10+ ACTIVITY_RECOGNITION is a runtime permission.
+            // Without it, requestActivityUpdates() silently returns no broadcasts and
+            // STILL/ACTIVE never flips — the provider then runs as a continuous tracker
+            // by accident. Emit a one-shot error so the host app knows to request it.
+            if (!activityRecognitionPermitted()) {
+                if (!activityPermissionErrorEmitted) {
+                    String msg = "ACTIVITY_RECOGNITION permission denied; ACTIVITY_PROVIDER cannot detect STILL/ACTIVE transitions.";
+                    logger.warn(msg);
+                    handlePermissionDenied(msg);
+                    activityPermissionErrorEmitted = true;
+                }
+                return;
+            }
             activityRecognitionClient.requestActivityUpdates(
                     mConfig.getActivitiesInterval(),
                     detectedActivitiesPI
@@ -255,7 +339,22 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
             List<DetectedActivity> detectedActivities = result.getProbableActivities();
             if (detectedActivities == null || detectedActivities.isEmpty()) return;
 
-            lastActivity = getProbableActivity(detectedActivities);
+            DetectedActivity candidate = getProbableActivity(detectedActivities);
+
+            // v4.5.2: skip transitions whose confidence is below the configured
+            // threshold (default 50). Prevents jittery STILL/ACTIVE flips when the
+            // motion classifier is unsure — which translated into spurious GPS
+            // start/stop bursts in earlier versions.
+            Integer threshold = mConfig != null ? mConfig.getActivityConfidenceThreshold() : null;
+            if (threshold != null && candidate.getConfidence() < threshold) {
+                logger.debug("Ignoring low-confidence activity={} confidence={} threshold={}",
+                        BackgroundActivity.getActivityString(candidate.getType()),
+                        candidate.getConfidence(),
+                        threshold);
+                return;
+            }
+
+            lastActivity = candidate;
 
             logger.debug("Detected activity={} confidence={}", BackgroundActivity.getActivityString(lastActivity.getType()), lastActivity.getConfidence());