@josuelmm/cordova-background-geolocation 2.3.5

package/android/common/src/main/java/com/marianhello/bgloc/headless/ActivityTask.java

@@ -0,0 +1,48 @@
+package com.marianhello.bgloc.headless;
+
+import android.os.Bundle;
+
+import com.marianhello.bgloc.data.BackgroundActivity;
+
+import org.json.JSONException;
+
+public abstract class ActivityTask extends Task {
+    private BackgroundActivity mActivity;
+
+    public ActivityTask(BackgroundActivity activity) {
+        mActivity = activity;
+    }
+
+    @Override
+    public String getName() {
+        return "activity";
+    }
+
+    @Override
+    public Bundle getBundle() {
+        Bundle bundle = new Bundle();
+        Bundle params = new Bundle();
+
+        params.putInt("confidence", mActivity.getConfidence());
+        params.putString("type", BackgroundActivity.getActivityString(mActivity.getType()));
+
+        bundle.putString("name", getName());
+        bundle.putBundle("params", params);
+        return bundle;
+    }
+
+    @Override
+    public String toString() {
+        if (mActivity == null) {
+            return null;
+        }
+
+        try {
+            return mActivity.toJSONObject().toString();
+        } catch (JSONException e) {
+            onError("Error processing params: " + e.getMessage());
+        }
+
+        return null;
+    }
+}

package/android/common/src/main/java/com/marianhello/bgloc/headless/JsCallback.java

@@ -0,0 +1,10 @@
+package com.marianhello.bgloc.headless;
+
+/**
+ * Interface for passing code that will be executed after the JS has finished
+ */
+
+public interface JsCallback {
+	void onResult(String value);
+	void onError(String errorMessage);
+}

package/android/common/src/main/java/com/marianhello/bgloc/headless/LocationTask.java

@@ -0,0 +1,60 @@
+package com.marianhello.bgloc.headless;
+
+import android.os.Bundle;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+import org.json.JSONException;
+
+public abstract class LocationTask extends Task {
+    protected BackgroundLocation mLocation;
+
+    public LocationTask(BackgroundLocation location) {
+        mLocation = location;
+    }
+
+    @Override
+    public String getName() {
+        return "location";
+    }
+
+    @Override
+    public Bundle getBundle() {
+        Bundle bundle = new Bundle();
+        Bundle params = new Bundle();
+
+        params.putString("provider", mLocation.getProvider());
+        params.putInt("locationProvider", mLocation.getLocationProvider());
+        params.putLong("time", mLocation.getTime());
+        params.putDouble("latitude", mLocation.getLatitude());
+        params.putDouble("longitude", mLocation.getLongitude());
+        if (mLocation.hasAccuracy()) params.putFloat("accuracy", mLocation.getAccuracy());
+        if (mLocation.hasVerticalAccuracy()) params.putFloat("accuracy", mLocation.getVerticalAccuracy());
+        if (mLocation.hasSpeed()) params.putFloat("speed", mLocation.getSpeed());
+        if (mLocation.hasAltitude()) params.putDouble("altitude", mLocation.getAltitude());
+        if (mLocation.hasBearing()) params.putFloat("bearing", mLocation.getBearing());
+        if (mLocation.hasRadius()) params.putFloat("radius", mLocation.getRadius());
+        if (mLocation.hasIsFromMockProvider()) params.putBoolean("isFromMockProvider", mLocation.isFromMockProvider());
+        if (mLocation.hasMockLocationsEnabled()) params.putBoolean("mockLocationsEnabled", mLocation.areMockLocationsEnabled());
+
+        bundle.putString("name", getName());
+        bundle.putBundle("params", params);
+
+        return bundle;
+    }
+
+    @Override
+    public String toString() {
+        if (mLocation == null) {
+            return null;
+        }
+
+        try {
+            return mLocation.toJSONObject().toString();
+        } catch (JSONException e) {
+            onError("Error processing params: " + e.getMessage());
+        }
+
+        return null;
+    }
+}

package/android/common/src/main/java/com/marianhello/bgloc/headless/StationaryTask.java

@@ -0,0 +1,25 @@
+package com.marianhello.bgloc.headless;
+
+import android.os.Bundle;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+import org.json.JSONException;
+
+public abstract class StationaryTask extends LocationTask {
+    public StationaryTask(BackgroundLocation location) {
+        super(location);
+    }
+
+    @Override
+    public String getName() {
+        return "stationary";
+    }
+
+    @Override
+    public Bundle getBundle() {
+        Bundle bundle = super.getBundle();
+
+        return bundle;
+    }
+}

package/android/common/src/main/java/com/marianhello/bgloc/headless/Task.java

@@ -0,0 +1,8 @@
+package com.marianhello.bgloc.headless;
+
+import android.os.Bundle;
+
+public abstract class Task implements JsCallback {
+    public abstract String getName();
+    public abstract Bundle getBundle();
+}

package/android/common/src/main/java/com/marianhello/bgloc/headless/TaskRunner.java

@@ -0,0 +1,5 @@
+package com.marianhello.bgloc.headless;
+
+public interface TaskRunner {
+    void runTask(Task task);
+}

package/android/common/src/main/java/com/marianhello/bgloc/headless/TaskRunnerFactory.java

@@ -0,0 +1,8 @@
+package com.marianhello.bgloc.headless;
+
+public class TaskRunnerFactory {
+
+    public TaskRunner getTaskRunner(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
+        return (TaskRunner) Class.forName(className).newInstance();
+    }
+}

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

@@ -0,0 +1,171 @@
+/*
+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);
+    }
+
+    /**
+     * Handle location as recorder by provider
+     * @param location
+     */
+    protected void handleLocation (Location location) {
+        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) {
+        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) {
+        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);
+        }
+    }
+
+    protected void showDebugToast (String text) {
+        if (mConfig.isDebugging()) {
+            Toast.makeText(mContext, text, Toast.LENGTH_LONG).show();
+        }
+    }
+
+    public Boolean hasMockLocationsEnabled() {
+        return Settings.Secure.getString(mContext.getContentResolver(), android.provider.Settings.Secure.ALLOW_MOCK_LOCATION).equals("1");
+    }
+
+    /**
+     * Plays debug sound
+     * @param name toneGenerator
+     */
+    protected void playDebugTone (int name) {
+        if (toneGenerator == null || !mConfig.isDebugging()) return;
+
+        int duration = 1000;
+        toneGenerator.startTone(name, duration);
+    }
+}

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

@@ -0,0 +1,282 @@
+package com.marianhello.bgloc.provider;
+
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.Manifest;
+import android.os.Build;
+import android.os.Looper;
+import androidx.core.app.ActivityCompat;
+
+import com.google.android.gms.location.ActivityRecognition;
+import com.google.android.gms.location.ActivityRecognitionClient;
+import com.google.android.gms.location.ActivityRecognitionResult;
+import com.google.android.gms.location.DetectedActivity;
+import com.google.android.gms.location.FusedLocationProviderClient;
+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.marianhello.bgloc.Config;
+import com.marianhello.bgloc.data.BackgroundActivity;
+
+import java.util.List;
+
+
+public class ActivityRecognitionLocationProvider extends AbstractLocationProvider {
+
+    private static final String P_NAME = "com.marianhello.bgloc";
+    private static final String DETECTED_ACTIVITY_UPDATE = P_NAME + ".DETECTED_ACTIVITY_UPDATE";
+
+    private FusedLocationProviderClient fusedLocationClient;
+    private ActivityRecognitionClient activityRecognitionClient;
+    private PendingIntent detectedActivitiesPI;
+
+    // Must default to false: onConfigure() is called before onStart() by LocationServiceImpl.
+    private boolean isStarted = false;
+    private boolean isTracking = false;
+    private boolean isWatchingActivity = false;
+    private DetectedActivity lastActivity = new DetectedActivity(DetectedActivity.UNKNOWN, 100);
+
+    private final LocationCallback locationCallback = new LocationCallback() {
+        @Override
+        public void onLocationResult(LocationResult result) {
+            if (result == null) return;
+            List<Location> locations = result.getLocations();
+            if (locations == null) return;
+            for (Location location : locations) {
+                onLocationReceived(location);
+            }
+        }
+    };
+
+    public ActivityRecognitionLocationProvider(Context context) {
+        super(context);
+        PROVIDER_ID = Config.ACTIVITY_PROVIDER;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        fusedLocationClient = LocationServices.getFusedLocationProviderClient(mContext);
+        activityRecognitionClient = ActivityRecognition.getClient(mContext);
+
+        Intent detectedActivitiesIntent = new Intent(mContext, DetectedActivitiesReceiver.class);
+        detectedActivitiesIntent.setAction(DETECTED_ACTIVITY_UPDATE);
+
+        int updateCurrentFlag = android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+                ? PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+                : PendingIntent.FLAG_UPDATE_CURRENT;
+        detectedActivitiesPI = PendingIntent.getBroadcast(mContext, 9002, detectedActivitiesIntent, updateCurrentFlag);
+        registerReceiver(detectedActivitiesReceiver, new IntentFilter(DETECTED_ACTIVITY_UPDATE));
+    }
+
+    @Override
+    public void onStart() {
+        logger.info("Start recording");
+        this.isStarted = true;
+        attachRecorder();
+    }
+
+    @Override
+    public void onStop() {
+        logger.info("Stop recording");
+        this.isStarted = false;
+        detachRecorder();
+        stopTracking();
+    }
+
+    @Override
+    public void onConfigure(Config config) {
+        super.onConfigure(config);
+        if (isStarted) {
+            onStop();
+            onStart();
+        }
+    }
+
+    @Override
+    public boolean isStarted() {
+        return isStarted;
+    }
+
+    @Override
+    public void onCommand(int commandId, int arg1) {
+        if (commandId == LocationProvider.CMD_SWITCH_MODE && isStarted) {
+            // Foreground: ensure tracking; background: keep current behavior (activity still drives start/stop).
+            if (arg1 == LocationProvider.FOREGROUND_MODE) {
+                startTracking();
+            }
+        }
+    }
+
+    /**
+     * Same logic as former onLocationChanged: STILL -> stationary + stopTracking, else handleLocation.
+     */
+    private void onLocationReceived(Location location) {
+        logger.debug("Location change: {}", location.toString());
+
+        if (lastActivity.getType() == DetectedActivity.STILL) {
+            handleStationary(location);
+            stopTracking();
+            return;
+        }
+
+        showDebugToast("acy:" + location.getAccuracy() + ",v:" + location.getSpeed());
+
+        handleLocation(location);
+    }
+
+    public void startTracking() {
+        if (isTracking) { return; }
+        if (fusedLocationClient == null || mConfig == null) { return; }
+
+        int priority = translateDesiredAccuracy(mConfig.getDesiredAccuracy());
+        LocationRequest locationRequest = LocationRequest.create()
+                .setPriority(priority)
+                .setFastestInterval(mConfig.getFastestInterval())
+                .setInterval(mConfig.getInterval());
+
+        try {
+            fusedLocationClient.requestLocationUpdates(
+                    locationRequest,
+                    locationCallback,
+                    Looper.getMainLooper()
+            );
+            isTracking = true;
+            logger.debug("Start tracking with priority={} fastestInterval={} interval={} activitiesInterval={} stopOnStillActivity={}",
+                    priority, mConfig.getFastestInterval(), mConfig.getInterval(), mConfig.getActivitiesInterval(), mConfig.getStopOnStillActivity());
+        } catch (SecurityException e) {
+            logger.error("Security exception: {}", e.getMessage());
+            this.handleSecurityException(e);
+        }
+    }
+
+    public void stopTracking() {
+        if (!isTracking) { return; }
+        if (fusedLocationClient == null) {
+            isTracking = false;
+            return;
+        }
+        try {
+            fusedLocationClient.removeLocationUpdates(locationCallback);
+        } catch (SecurityException e) {
+            logger.warn("Security exception removing location updates: {}", e.getMessage());
+        } finally {
+            isTracking = false;
+        }
+    }
+
+    private boolean activityRecognitionPermitted() {
+        return Build.VERSION.SDK_INT < Build.VERSION_CODES.Q
+                || ActivityCompat.checkSelfPermission(mContext, Manifest.permission.ACTIVITY_RECOGNITION) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    private void attachRecorder() {
+        if (fusedLocationClient == null || activityRecognitionClient == null) { return; }
+        if (mConfig == null) { return; }
+
+        startTracking();
+
+        if (!isWatchingActivity && mConfig.getStopOnStillActivity() && activityRecognitionPermitted()) {
+            activityRecognitionClient.requestActivityUpdates(
+                    mConfig.getActivitiesInterval(),
+                    detectedActivitiesPI
+            ).addOnFailureListener(e -> logger.error("requestActivityUpdates failed: {}", e.getMessage()));
+            isWatchingActivity = true;
+        }
+    }
+
+    private void detachRecorder() {
+        if (!isWatchingActivity) { return; }
+        if (activityRecognitionClient == null) {
+            isWatchingActivity = false;
+            return;
+        }
+        try {
+            logger.debug("Detaching recorder");
+            activityRecognitionClient.removeActivityUpdates(detectedActivitiesPI)
+                    .addOnSuccessListener(v -> logger.debug("removeActivityUpdates ok"))
+                    .addOnFailureListener(e -> logger.warn("removeActivityUpdates failed: {}", e.getMessage()));
+        } finally {
+            isWatchingActivity = false;
+        }
+    }
+
+    /**
+     * Translates a number representing desired accuracy of Geolocation system from set [0, 10, 100, 1000].
+     * 0:  most aggressive, most accurate, worst battery drain
+     * 1000:  least aggressive, least accurate, best for battery.
+     */
+    private int translateDesiredAccuracy(Integer accuracy) {
+        if (accuracy == null) {
+            return LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;
+        }
+        if (accuracy >= 10000) {
+            return LocationRequest.PRIORITY_NO_POWER;
+        }
+        if (accuracy >= 1000) {
+            return LocationRequest.PRIORITY_LOW_POWER;
+        }
+        if (accuracy >= 100) {
+            return LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;
+        }
+        return LocationRequest.PRIORITY_HIGH_ACCURACY;
+    }
+
+    public static DetectedActivity getProbableActivity(List<DetectedActivity> detectedActivities) {
+        int highestConfidence = 0;
+        DetectedActivity mostLikelyActivity = new DetectedActivity(DetectedActivity.UNKNOWN, 0);
+
+        for (DetectedActivity da : detectedActivities) {
+            if (da.getType() != DetectedActivity.TILTING && da.getType() != DetectedActivity.UNKNOWN) {
+                if (highestConfidence < da.getConfidence()) {
+                    highestConfidence = da.getConfidence();
+                    mostLikelyActivity = da;
+                }
+            }
+        }
+        return mostLikelyActivity;
+    }
+
+    private class DetectedActivitiesReceiver extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            ActivityRecognitionResult result = ActivityRecognitionResult.extractResult(intent);
+            if (result == null) return;
+            List<DetectedActivity> detectedActivities = result.getProbableActivities();
+            if (detectedActivities == null || detectedActivities.isEmpty()) return;
+
+            lastActivity = getProbableActivity(detectedActivities);
+
+            logger.debug("Detected activity={} confidence={}", BackgroundActivity.getActivityString(lastActivity.getType()), lastActivity.getConfidence());
+
+            handleActivity(lastActivity);
+
+            if (lastActivity.getType() == DetectedActivity.STILL) {
+                showDebugToast("Detected STILL Activity");
+            } else {
+                showDebugToast("Detected ACTIVE Activity");
+                startTracking();
+            }
+        }
+    }
+
+    private final BroadcastReceiver detectedActivitiesReceiver = new DetectedActivitiesReceiver();
+
+    @Override
+    public void onDestroy() {
+        logger.info("Destroying ActivityRecognitionLocationProvider");
+        onStop();
+        try {
+            unregisterReceiver(detectedActivitiesReceiver);
+        } catch (Exception ignored) {
+            // Receiver may not be registered if onCreate/onStart never completed
+        }
+        super.onDestroy();
+    }
+}