@josuelmm/capacitor-background-geolocation 1.0.0

package/android/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/src/main/java/com/marianhello/bgloc/provider/AbstractLocationProvider.java

@@ -0,0 +1,218 @@
+/*
+According to apache license
+
+This is fork of christocracy cordova-plugin-background-geolocation plugin
+https://github.com/christocracy/cordova-plugin-background-geolocation
+
+This is a new class
+*/
+
+package com.marianhello.bgloc.provider;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.location.Location;
+import android.media.AudioManager;
+import android.provider.Settings;
+import android.widget.Toast;
+
+import com.google.android.gms.location.DetectedActivity;
+import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.PluginException;
+import com.marianhello.bgloc.data.BackgroundActivity;
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.logging.LoggerManager;
+import com.marianhello.utils.ToneGenerator;
+import com.marianhello.utils.ToneGenerator.Tone;
+
+/**
+ * AbstractLocationProvider
+ */
+public abstract class AbstractLocationProvider implements LocationProvider {
+
+    protected Integer PROVIDER_ID;
+    protected Config mConfig;
+    protected Context mContext;
+
+    protected ToneGenerator toneGenerator;
+    protected org.slf4j.Logger logger;
+
+    private ProviderDelegate mDelegate;
+
+    protected AbstractLocationProvider(Context context) {
+        mContext = context;
+        logger = LoggerManager.getLogger(getClass());
+        logger.info("Creating {}", getClass().getSimpleName());
+    }
+
+    @Override
+    public void onCreate() {
+        toneGenerator = new ToneGenerator(AudioManager.STREAM_NOTIFICATION, 100);
+    }
+
+    @Override
+    public void onDestroy() {
+        toneGenerator.release();
+        toneGenerator = null;
+    }
+
+    @Override
+    public void onConfigure(Config config) {
+        mConfig = config;
+    }
+
+    @Override
+    public void onCommand(int commandId, int arg1) {
+        // override in child class
+    }
+
+    public void setDelegate(ProviderDelegate delegate) {
+        mDelegate = delegate;
+    }
+
+    /**
+     * Register broadcast reciever
+     * @param receiver
+     */
+    protected Intent registerReceiver (BroadcastReceiver receiver, IntentFilter filter) {
+        return mContext.registerReceiver(receiver, filter);
+    }
+
+    /**
+     * Unregister broadcast reciever
+     * @param receiver
+     */
+    protected void unregisterReceiver (BroadcastReceiver receiver) {
+        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);
+            bgLocation.setMockLocationsEnabled(hasMockLocationsEnabled());
+            mDelegate.onLocation(bgLocation);
+        }
+    }
+
+    /**
+     * Handle stationary location with radius
+     *
+     * @param location
+     * @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);
+            bgLocation.setRadius(radius);
+            bgLocation.setMockLocationsEnabled(hasMockLocationsEnabled());
+            mDelegate.onStationary(bgLocation);
+        }
+    }
+
+    /**
+     * Handle stationary location without radius
+     *
+     * @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);
+            bgLocation.setMockLocationsEnabled(hasMockLocationsEnabled());
+            mDelegate.onStationary(bgLocation);
+        }
+    }
+
+    protected void handleActivity(DetectedActivity activity) {
+        if (mDelegate != null) {
+            mDelegate.onActivity(new BackgroundActivity(PROVIDER_ID, activity));
+        }
+    }
+
+    /**
+     * Handle security exception
+     * @param exception
+     */
+    protected void handleSecurityException (SecurityException exception) {
+        PluginException error = new PluginException(exception.getMessage(), PluginException.PERMISSION_DENIED_ERROR);
+        if (mDelegate != null) {
+            mDelegate.onError(error);
+        }
+    }
+
+    /**
+     * 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();
+        }
+    }
+
+    public Boolean hasMockLocationsEnabled() {
+        // 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);
+    }
+
+    /**
+     * Plays debug sound
+     * @param name toneGenerator
+     */
+    protected void playDebugTone (int name) {
+        if (toneGenerator == null || !mConfig.isDebugging()) return;
+
+        int duration = 1000;
+        toneGenerator.startTone(name, duration);
+    }
+}