@josuelmm/cordova-background-geolocation 3.2.0 → 4.2.2

package/android/common/src/main/java/com/marianhello/bgloc/driving/DrivingEventsDetector.java

@@ -0,0 +1,265 @@
+package com.marianhello.bgloc.driving;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+/**
+ * v4.0 Phase 6 — Driver insights state machine (GPS-only).
+ *
+ * Pure-Java helper, no Android imports. Hosted by {@code LocationServiceImpl}, which
+ * feeds it every received location and surfaces emitted events via the plugin
+ * {@code MSG_ON_*} broadcast pipeline.
+ *
+ * Heuristics:
+ *   moving   = speed > minMovingSpeed
+ *   stopped  = !moving for stoppedDuration ms
+ *   tripStart = stopped → moving with speed >= minTripSpeed sustained for minTripDuration ms
+ *   tripEnd  = moving → stopped (after a tripStart)
+ *   speeding = first crossing above speedLimit (km/h); rearms on drop below
+ *
+ * Sensor-fusion events (hardBrake / sharpTurn / possibleCrash) are intentionally NOT
+ * implemented in this class. They require linear acceleration + gyroscope sampling and
+ * are planned for v4.1 in a separate {@code SensorFusionDetector}.
+ */
+public class DrivingEventsDetector {
+
+    public interface Listener {
+        void onMoving(BackgroundLocation location);
+        void onStopped(BackgroundLocation location);
+        void onTripStart(BackgroundLocation location);
+        /** distance in meters, durationMs in milliseconds. */
+        void onTripEnd(BackgroundLocation location, double distance, long durationMs);
+        void onSpeeding(BackgroundLocation location, double speedKmh, double limitKmh);
+        void onProviderChange(String provider);
+        // v4.1 GPS-derived driving events
+        /** GPS-derived deceleration (m/s²). Negative number, more negative = harder brake. */
+        void onHardBrake(BackgroundLocation location, double decelMps2);
+        /** GPS-derived acceleration (m/s²). */
+        void onRapidAcceleration(BackgroundLocation location, double accelMps2);
+        /** Bearing change rate (deg/s). */
+        void onSharpTurn(BackgroundLocation location, double degPerSec);
+        /** Velocity drop in km/h within {@code crashWindowMs} while tripActive. */
+        void onPossibleCrash(BackgroundLocation location, double velocityDropKmh);
+    }
+
+    public static class Config {
+        public boolean enabled = false;
+        public double speedLimitKmh = 0;        // 0 disables speeding
+        public double minMovingSpeedMps = 1.0;  // ~3.6 km/h
+        public long stoppedDurationMs = 60_000;
+        public double minTripSpeedMps = 3.0;    // ~10.8 km/h
+        public long minTripDurationMs = 30_000;
+        // v4.1 GPS-derived driving events. 0 disables each one.
+        public double hardBrakeMps2 = 3.5;      // -m/s² threshold (positive value)
+        public double rapidAccelMps2 = 3.5;     // m/s² threshold
+        public double sharpTurnDegPerSec = 30;  // deg/sec, requires speed > 5 m/s
+        public double crashImpactKmh = 25;      // velocity drop within crashWindow
+        public long   crashWindowMs = 2_000;    // window to evaluate the velocity drop
+    }
+
+    private final Listener listener;
+    private Config cfg = new Config();
+
+    // State
+    private boolean isMoving = false;
+    private boolean tripActive = false;
+    private long tripStartedAt = 0;
+    private double tripDistanceMeters = 0;
+    private double tripStartLat, tripStartLon;
+    private boolean hasTripStartCoord = false;
+
+    private long aboveTripSpeedSince = 0;   // first sample with speed >= minTripSpeed
+    private long belowMovingSinceMs = 0;    // first sample with speed < minMovingSpeed
+
+    private boolean wasSpeeding = false;
+    private String lastProvider;
+
+    private double prevLat, prevLon;
+    private boolean hasPrev = false;
+
+    // v4.1 GPS-derived deltas
+    private double prevSpeedMps = 0.0;
+    private long   prevSpeedAt = 0L;
+    private double prevBearingDeg = 0.0;
+    private boolean hasPrevBearing = false;
+    private long   prevBearingAt = 0L;
+    /** Cooldown so we don't refire the same event on every fix in a sustained brake. */
+    private long lastHardBrakeAt = 0L, lastRapidAccelAt = 0L, lastSharpTurnAt = 0L, lastCrashAt = 0L;
+    private static final long DRIVING_EVENT_COOLDOWN_MS = 4_000L;
+
+    public DrivingEventsDetector(Listener listener) {
+        this.listener = listener;
+    }
+
+    public synchronized void setConfig(Config c) {
+        if (c != null) this.cfg = c;
+    }
+
+    /** Reset internal state. Called when service stops. */
+    public synchronized void reset() {
+        prevSpeedMps = 0.0;
+        prevSpeedAt = 0L;
+        prevBearingDeg = 0.0;
+        hasPrevBearing = false;
+        prevBearingAt = 0L;
+        lastHardBrakeAt = lastRapidAccelAt = lastSharpTurnAt = lastCrashAt = 0L;
+        isMoving = false;
+        tripActive = false;
+        tripStartedAt = 0;
+        tripDistanceMeters = 0;
+        hasTripStartCoord = false;
+        aboveTripSpeedSince = 0;
+        belowMovingSinceMs = 0;
+        wasSpeeding = false;
+        lastProvider = null;
+        hasPrev = false;
+    }
+
+    public synchronized void onLocation(BackgroundLocation loc) {
+        if (!cfg.enabled || loc == null) return;
+        long now = System.currentTimeMillis();
+        double speed = loc.hasSpeed() ? loc.getSpeed() : 0.0;
+
+        // Provider change
+        String provider = loc.getProvider();
+        if (provider != null && !provider.equals(lastProvider)) {
+            lastProvider = provider;
+            if (listener != null) listener.onProviderChange(provider);
+        }
+
+        // Distance accumulator (very simple: planar haversine approximation via
+        // Location.distanceBetween is not used here to keep this class platform-free;
+        // consumer can swap to BackgroundLocation.distanceTo in onTripEnd if desired).
+        double curLat = loc.getLatitude();
+        double curLon = loc.getLongitude();
+        if (hasPrev && tripActive) {
+            tripDistanceMeters += haversineMeters(prevLat, prevLon, curLat, curLon);
+        }
+        prevLat = curLat;
+        prevLon = curLon;
+        hasPrev = true;
+
+        // Moving / stopped state
+        boolean nowMoving = speed >= cfg.minMovingSpeedMps;
+        if (nowMoving) {
+            belowMovingSinceMs = 0;
+            if (!isMoving) {
+                isMoving = true;
+                if (listener != null) listener.onMoving(loc);
+            }
+            // Trip start arming
+            if (!tripActive) {
+                if (speed >= cfg.minTripSpeedMps) {
+                    if (aboveTripSpeedSince == 0) aboveTripSpeedSince = now;
+                    if (now - aboveTripSpeedSince >= cfg.minTripDurationMs) {
+                        tripActive = true;
+                        tripStartedAt = now;
+                        tripDistanceMeters = 0;
+                        tripStartLat = curLat;
+                        tripStartLon = curLon;
+                        hasTripStartCoord = true;
+                        if (listener != null) listener.onTripStart(loc);
+                    }
+                } else {
+                    aboveTripSpeedSince = 0;
+                }
+            }
+        } else {
+            aboveTripSpeedSince = 0;
+            if (belowMovingSinceMs == 0) belowMovingSinceMs = now;
+            if (isMoving && (now - belowMovingSinceMs) >= cfg.stoppedDurationMs) {
+                isMoving = false;
+                if (listener != null) listener.onStopped(loc);
+                if (tripActive) {
+                    long durMs = now - tripStartedAt;
+                    double dist = tripDistanceMeters;
+                    tripActive = false;
+                    if (listener != null) listener.onTripEnd(loc, dist, durMs);
+                }
+            }
+        }
+
+        // Speeding (km/h)
+        if (cfg.speedLimitKmh > 0) {
+            double kmh = speed * 3.6;
+            if (kmh > cfg.speedLimitKmh) {
+                if (!wasSpeeding) {
+                    wasSpeeding = true;
+                    if (listener != null) listener.onSpeeding(loc, kmh, cfg.speedLimitKmh);
+                }
+            } else {
+                // Rearm: emit again on next crossing.
+                wasSpeeding = false;
+            }
+        }
+
+        // v4.1 GPS-derived driving events (only meaningful during an active trip)
+        if (tripActive && prevSpeedAt > 0) {
+            long dtMs = now - prevSpeedAt;
+            if (dtMs > 0 && dtMs <= 5_000) {
+                double dt = dtMs / 1000.0;
+                double dv = speed - prevSpeedMps; // m/s
+                double accel = dv / dt;            // m/s²
+
+                if (cfg.hardBrakeMps2 > 0
+                        && accel <= -cfg.hardBrakeMps2
+                        && (now - lastHardBrakeAt) >= DRIVING_EVENT_COOLDOWN_MS) {
+                    lastHardBrakeAt = now;
+                    if (listener != null) listener.onHardBrake(loc, accel);
+                }
+                if (cfg.rapidAccelMps2 > 0
+                        && accel >= cfg.rapidAccelMps2
+                        && (now - lastRapidAccelAt) >= DRIVING_EVENT_COOLDOWN_MS) {
+                    lastRapidAccelAt = now;
+                    if (listener != null) listener.onRapidAcceleration(loc, accel);
+                }
+
+                // Possible crash: sustained velocity drop greater than crashImpactKmh in <= crashWindow.
+                if (cfg.crashImpactKmh > 0 && dtMs <= cfg.crashWindowMs) {
+                    double dropKmh = (prevSpeedMps - speed) * 3.6; // positive when slowing down
+                    if (dropKmh >= cfg.crashImpactKmh
+                            && speed < 1.5 // ended near stop
+                            && prevSpeedMps * 3.6 >= cfg.crashImpactKmh
+                            && (now - lastCrashAt) >= DRIVING_EVENT_COOLDOWN_MS) {
+                        lastCrashAt = now;
+                        if (listener != null) listener.onPossibleCrash(loc, dropKmh);
+                    }
+                }
+            }
+        }
+
+        // Sharp turn (bearing change rate) — requires meaningful speed to avoid GPS jitter.
+        if (cfg.sharpTurnDegPerSec > 0 && loc.hasBearing() && speed >= 5.0 && hasPrevBearing) {
+            long dtMs = now - prevBearingAt;
+            if (dtMs > 0 && dtMs <= 5_000) {
+                double bearing = loc.getBearing();
+                double diff = Math.abs(bearing - prevBearingDeg);
+                if (diff > 180) diff = 360 - diff;
+                double rate = diff * 1000.0 / dtMs;
+                if (rate >= cfg.sharpTurnDegPerSec
+                        && (now - lastSharpTurnAt) >= DRIVING_EVENT_COOLDOWN_MS) {
+                    lastSharpTurnAt = now;
+                    if (listener != null) listener.onSharpTurn(loc, rate);
+                }
+            }
+            prevBearingDeg = loc.getBearing();
+            prevBearingAt = now;
+        } else if (loc.hasBearing()) {
+            prevBearingDeg = loc.getBearing();
+            prevBearingAt = now;
+            hasPrevBearing = true;
+        }
+
+        prevSpeedMps = speed;
+        prevSpeedAt = now;
+    }
+
+    private static double haversineMeters(double lat1, double lon1, double lat2, double lon2) {
+        double R = 6371000.0;
+        double dLat = Math.toRadians(lat2 - lat1);
+        double dLon = Math.toRadians(lon2 - lon1);
+        double a = Math.sin(dLat/2) * Math.sin(dLat/2)
+                + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
+                * Math.sin(dLon/2) * Math.sin(dLon/2);
+        return 2 * R * Math.asin(Math.sqrt(a));
+    }
+}

package/android/common/src/main/java/com/marianhello/bgloc/http/UrlTemplateResolver.java

@@ -0,0 +1,115 @@
+package com.marianhello.bgloc.http;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TimeZone;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Resolves placeholders like {lat}, {lon}, {timestamp_iso}, {device_id}, ...
+ * in a URL template using a single BackgroundLocation and an optional queryParams map.
+ *
+ * Placeholders not found in the location/queryParams are left as-is so that
+ * partial templates (e.g. only static keys for batch mode) keep working.
+ *
+ * Usage:
+ *   String url = UrlTemplateResolver.resolve(template, location, queryParams);
+ *   // location may be null for batch mode (only queryParams keys are resolved).
+ */
+public final class UrlTemplateResolver {
+
+    private static final Pattern PLACEHOLDER = Pattern.compile("\\{([a-zA-Z0-9_]+)\\}");
+
+    private UrlTemplateResolver() { /* no instances */ }
+
+    public static String resolve(String template, BackgroundLocation location, Map<String, ?> queryParams) {
+        if (template == null || template.isEmpty()) return template;
+        Map<String, String> ctx = buildContext(location, queryParams);
+        Matcher m = PLACEHOLDER.matcher(template);
+        StringBuffer sb = new StringBuffer(template.length());
+        while (m.find()) {
+            String key = m.group(1);
+            String value = ctx.get(key);
+            if (value != null) {
+                m.appendReplacement(sb, Matcher.quoteReplacement(urlEncode(value)));
+            } else {
+                // Leave placeholder as-is if no value available.
+                m.appendReplacement(sb, Matcher.quoteReplacement(m.group(0)));
+            }
+        }
+        m.appendTail(sb);
+        return sb.toString();
+    }
+
+    public static boolean hasPlaceholders(String template) {
+        if (template == null) return false;
+        return PLACEHOLDER.matcher(template).find();
+    }
+
+    private static Map<String, String> buildContext(BackgroundLocation loc, Map<String, ?> queryParams) {
+        Map<String, String> ctx = new HashMap<String, String>();
+
+        // queryParams first so location-derived values can override if user wants
+        if (queryParams != null) {
+            for (Map.Entry<String, ?> e : queryParams.entrySet()) {
+                if (e.getValue() != null) {
+                    ctx.put(e.getKey(), String.valueOf(e.getValue()));
+                }
+            }
+        }
+
+        if (loc != null) {
+            ctx.put("latitude", String.valueOf(loc.getLatitude()));
+            ctx.put("longitude", String.valueOf(loc.getLongitude()));
+            ctx.put("lat", String.valueOf(loc.getLatitude()));
+            ctx.put("lon", String.valueOf(loc.getLongitude()));
+
+            long timeMs = loc.getTime();
+            ctx.put("time", String.valueOf(timeMs));
+            ctx.put("timestamp", String.valueOf(timeMs));
+            ctx.put("timestamp_iso", isoUtc(timeMs));
+
+            if (loc.hasSpeed()) ctx.put("speed", String.valueOf(loc.getSpeed()));
+            if (loc.hasAltitude()) ctx.put("altitude", String.valueOf(loc.getAltitude()));
+            if (loc.hasBearing()) ctx.put("bearing", String.valueOf(loc.getBearing()));
+            if (loc.hasAccuracy()) ctx.put("accuracy", String.valueOf(loc.getAccuracy()));
+
+            if (loc.getProvider() != null) ctx.put("provider", loc.getProvider());
+            // is_moving derived from speed when available (>0.5 m/s ~ walking pace).
+            if (loc.hasSpeed()) {
+                ctx.put("is_moving", loc.getSpeed() > 0.5f ? "true" : "false");
+            }
+            // {activity} is not produced by BackgroundLocation by default; the user can supply
+            // a value via queryParams (already populated above).
+        }
+
+        return ctx;
+    }
+
+    /**
+     * URL-encode a placeholder value for use in URL paths and query strings.
+     * Spaces become %20, not + (which is form-encoding).
+     */
+    private static String urlEncode(String s) {
+        if (s == null) return "";
+        try {
+            String enc = java.net.URLEncoder.encode(s, "UTF-8");
+            // URLEncoder uses application/x-www-form-urlencoded; convert "+" back to "%20" for URL safety.
+            return enc.replace("+", "%20");
+        } catch (Exception e) {
+            return s;
+        }
+    }
+
+    private static String isoUtc(long ms) {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US);
+        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
+        return sdf.format(new Date(ms));
+    }
+}

package/android/common/src/main/java/com/marianhello/bgloc/oem/BatteryOemHelper.java

@@ -0,0 +1,214 @@
+package com.marianhello.bgloc.oem;
+
+import android.app.Activity;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.PowerManager;
+import android.provider.Settings;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * v3.6 Phase 5: Battery / OEM helpers.
+ *
+ * Standard Android Doze whitelist:
+ *   - {@link #isIgnoringBatteryOptimizations(Context)}
+ *   - {@link #requestIgnoreBatteryOptimizations(Activity)}
+ *   - {@link #openBatterySettings(Activity)}
+ *
+ * OEM-specific "auto-start" / "background activity" screens (Xiaomi MIUI, Huawei
+ * EMUI, Oppo ColorOS, Vivo FunTouch, Samsung One UI). These cannot be granted
+ * programmatically — the user must toggle them in Settings.
+ */
+public final class BatteryOemHelper {
+
+    private BatteryOemHelper() { /* no instances */ }
+
+    public static boolean isIgnoringBatteryOptimizations(Context ctx) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return true;
+        try {
+            PowerManager pm = (PowerManager) ctx.getSystemService(Context.POWER_SERVICE);
+            return pm != null && pm.isIgnoringBatteryOptimizations(ctx.getPackageName());
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    /**
+     * Opens the system battery-optimisation prompt for the app.
+     * Does not throw; logs and silently returns if the system dialog is missing.
+     */
+    public static void requestIgnoreBatteryOptimizations(Activity activity) {
+        if (activity == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return;
+        try {
+            Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
+            intent.setData(Uri.parse("package:" + activity.getPackageName()));
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            activity.startActivity(intent);
+        } catch (Exception ignored) {
+            openBatterySettings(activity);
+        }
+    }
+
+    public static void openBatterySettings(Activity activity) {
+        if (activity == null) return;
+        // Try the per-app battery usage screen first; fall back to app-info.
+        try {
+            Intent intent = new Intent(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            activity.startActivity(intent);
+        } catch (Exception e) {
+            try {
+                Intent fallback = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+                fallback.setData(Uri.parse("package:" + activity.getPackageName()));
+                fallback.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                activity.startActivity(fallback);
+            } catch (Exception ignored) {}
+        }
+    }
+
+    /**
+     * Open the OEM-specific "auto-start" / "background activity" screen.
+     * Returns a JSON object describing what was opened so the JS layer can show
+     * appropriate copy: { opened, manufacturer, screen }.
+     */
+    public static JSONObject openAutoStartSettings(Activity activity) throws JSONException {
+        JSONObject out = new JSONObject();
+        String manufacturer = Build.MANUFACTURER != null ? Build.MANUFACTURER.toLowerCase() : "";
+        out.put("manufacturer", manufacturer);
+        out.put("opened", false);
+        out.put("screen", "");
+
+        if (activity == null) return out;
+
+        ComponentName component = autoStartComponent(manufacturer);
+        if (component != null) {
+            try {
+                Intent intent = new Intent();
+                intent.setComponent(component);
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                activity.startActivity(intent);
+                out.put("opened", true);
+                out.put("screen", component.flattenToShortString());
+                return out;
+            } catch (Exception ignored) { /* fall through to app-info */ }
+        }
+
+        // Fallback: standard application details page so the user can toggle background restrictions.
+        try {
+            Intent fallback = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+            fallback.setData(Uri.parse("package:" + activity.getPackageName()));
+            fallback.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            activity.startActivity(fallback);
+            out.put("opened", true);
+            out.put("screen", "android.settings.APPLICATION_DETAILS_SETTINGS");
+        } catch (Exception ignored) {}
+        return out;
+    }
+
+    /** Known OEM auto-start screen components. Verified against AOSP / OEM forks; may vary by ROM. */
+    private static ComponentName autoStartComponent(String manufacturer) {
+        if (manufacturer == null) return null;
+        if (manufacturer.contains("xiaomi") || manufacturer.contains("redmi") || manufacturer.contains("poco")) {
+            return new ComponentName("com.miui.securitycenter",
+                    "com.miui.permcenter.autostart.AutoStartManagementActivity");
+        }
+        if (manufacturer.contains("huawei") || manufacturer.contains("honor")) {
+            return new ComponentName("com.huawei.systemmanager",
+                    "com.huawei.systemmanager.startupmgr.ui.StartupNormalAppListActivity");
+        }
+        if (manufacturer.contains("oppo")) {
+            return new ComponentName("com.coloros.safecenter",
+                    "com.coloros.safecenter.permission.startup.StartupAppListActivity");
+        }
+        if (manufacturer.contains("vivo")) {
+            return new ComponentName("com.vivo.permissionmanager",
+                    "com.vivo.permissionmanager.activity.BgStartUpManagerActivity");
+        }
+        if (manufacturer.contains("samsung")) {
+            // Samsung does not expose a stable component for "Sleeping apps"; return null and
+            // let the caller fall back to app-info, where the user can disable battery optimisation.
+            return null;
+        }
+        if (manufacturer.contains("oneplus")) {
+            return new ComponentName("com.oneplus.security",
+                    "com.oneplus.security.chainlaunch.view.ChainLaunchAppListActivity");
+        }
+        if (manufacturer.contains("asus")) {
+            return new ComponentName("com.asus.mobilemanager",
+                    "com.asus.mobilemanager.entry.FunctionActivity");
+        }
+        return null;
+    }
+
+    /**
+     * Returns OEM-specific guidance steps. The caller renders them as a help screen.
+     */
+    public static JSONObject getManufacturerHelp() throws JSONException {
+        JSONObject out = new JSONObject();
+        String m = Build.MANUFACTURER != null ? Build.MANUFACTURER.toLowerCase() : "";
+        out.put("manufacturer", m);
+        out.put("steps", new JSONArray(stepsFor(m)));
+        return out;
+    }
+
+    private static String[] stepsFor(String manufacturer) {
+        if (manufacturer.contains("xiaomi") || manufacturer.contains("redmi") || manufacturer.contains("poco")) {
+            return new String[] {
+                "Settings → Apps → Manage apps → [your app] → Autostart → enable.",
+                "Settings → Apps → Manage apps → [your app] → Battery saver → No restrictions.",
+                "Settings → Apps → Manage apps → [your app] → Other permissions → Display pop-up windows while running in the background → Allow.",
+                "Lock the app in Recents (drag it down to keep it in memory)."
+            };
+        }
+        if (manufacturer.contains("huawei") || manufacturer.contains("honor")) {
+            return new String[] {
+                "Settings → Apps → [your app] → Battery → App launch → switch off Manage automatically and enable Auto-launch + Run in background.",
+                "Settings → Battery → App launch → [your app] → manage manually."
+            };
+        }
+        if (manufacturer.contains("oppo")) {
+            return new String[] {
+                "Settings → Battery → Power Consumption Protection → [your app] → Allow.",
+                "Settings → Apps → App management → [your app] → Permissions → Auto-start → Allow.",
+                "Settings → Privacy permissions → Startup manager → [your app] → enable."
+            };
+        }
+        if (manufacturer.contains("vivo")) {
+            return new String[] {
+                "Settings → Battery → High background power consumption → [your app] → Allow.",
+                "Settings → More settings → Permission management → Auto-start → [your app] → enable."
+            };
+        }
+        if (manufacturer.contains("samsung")) {
+            return new String[] {
+                "Settings → Apps → [your app] → Battery → Unrestricted.",
+                "Settings → Battery and device care → Battery → Background usage limits → Sleeping apps → make sure [your app] is NOT listed.",
+                "Settings → Battery and device care → Battery → Background usage limits → Never sleeping apps → add [your app]."
+            };
+        }
+        if (manufacturer.contains("oneplus")) {
+            return new String[] {
+                "Settings → Battery → Battery optimisation → [your app] → Don't optimise.",
+                "Settings → Apps → [your app] → Battery → Background activity → Allow."
+            };
+        }
+        if (manufacturer.contains("asus")) {
+            return new String[] {
+                "Settings → Apps → [your app] → Battery → Battery saver → Off.",
+                "Mobile Manager → Auto-start manager → [your app] → enable."
+            };
+        }
+        // Generic Android.
+        return new String[] {
+            "Settings → Apps → [your app] → Battery → Unrestricted.",
+            "Settings → Apps → [your app] → Permissions → Location → Allow all the time.",
+            "Disable battery optimisation for [your app] in Settings → Battery."
+        };
+    }
+}

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

@@ -21,6 +21,7 @@ import com.google.android.gms.location.LocationCallback;
 import com.google.android.gms.location.LocationRequest;
 import com.google.android.gms.location.LocationResult;
 import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.location.Priority;
 import com.marianhello.bgloc.Config;
 import com.marianhello.bgloc.data.BackgroundActivity;
 
@@ -136,10 +137,12 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
         if (fusedLocationClient == null || mConfig == null) { return; }
 
         int priority = translateDesiredAccuracy(mConfig.getDesiredAccuracy());
-        LocationRequest locationRequest = LocationRequest.create()
-                .setPriority(priority)
-                .setFastestInterval(mConfig.getFastestInterval())
-                .setInterval(mConfig.getInterval());
+        // 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())
+                .setMinUpdateIntervalMillis(mConfig.getFastestInterval())
+                .setWaitForAccurateLocation(false)
+                .build();
 
         try {
             fusedLocationClient.requestLocationUpdates(
@@ -213,19 +216,20 @@ public class ActivityRecognitionLocationProvider extends AbstractLocationProvide
      * 1000:  least aggressive, least accurate, best for battery.
      */
     private int translateDesiredAccuracy(Integer accuracy) {
+        // v3.4: Priority.* (play-services-location 21.0.0+) replaces deprecated LocationRequest.PRIORITY_*.
         if (accuracy == null) {
-            return LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;
+            return Priority.PRIORITY_BALANCED_POWER_ACCURACY;
         }
         if (accuracy >= 10000) {
-            return LocationRequest.PRIORITY_NO_POWER;
+            return Priority.PRIORITY_PASSIVE;
         }
         if (accuracy >= 1000) {
-            return LocationRequest.PRIORITY_LOW_POWER;
+            return Priority.PRIORITY_LOW_POWER;
         }
         if (accuracy >= 100) {
-            return LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;
+            return Priority.PRIORITY_BALANCED_POWER_ACCURACY;
         }
-        return LocationRequest.PRIORITY_HIGH_ACCURACY;
+        return Priority.PRIORITY_HIGH_ACCURACY;
     }
 
     public static DetectedActivity getProbableActivity(List<DetectedActivity> detectedActivities) {