react-native-nitro-background-geolocation 0.1.0

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

@@ -0,0 +1,61 @@
+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();
+
+        if (mLocation.getLocationId() != null) params.putLong("id", mLocation.getLocationId());
+        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("altitudeAccuracy", 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/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/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/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/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/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/src/main/java/com/marianhello/bgloc/provider/ActivityRecognitionLocationProvider.java

@@ -0,0 +1,280 @@
+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.Bundle;
+import android.os.PowerManager;
+import androidx.core.app.ActivityCompat;
+import android.util.Log;
+
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.location.ActivityRecognition;
+import com.google.android.gms.location.ActivityRecognitionResult;
+import com.google.android.gms.location.DetectedActivity;
+import com.google.android.gms.location.LocationListener;
+import com.google.android.gms.location.LocationRequest;
+import com.google.android.gms.location.LocationServices;
+import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.data.BackgroundActivity;
+
+import java.util.ArrayList;
+
+public class ActivityRecognitionLocationProvider extends AbstractLocationProvider implements GoogleApiClient.ConnectionCallbacks,
+        GoogleApiClient.OnConnectionFailedListener, LocationListener {
+
+    private static final String TAG = ActivityRecognitionLocationProvider.class.getSimpleName();
+    private static final String P_NAME = " com.marianhello.bgloc";
+    private static final String DETECTED_ACTIVITY_UPDATE = P_NAME + ".DETECTED_ACTIVITY_UPDATE";
+
+    private GoogleApiClient googleApiClient;
+    private PendingIntent detectedActivitiesPI;
+
+    private boolean isStarted = true;
+    private boolean isTracking = false;
+    private boolean isWatchingActivity = false;
+    private Location lastLocation;
+    private DetectedActivity lastActivity = new DetectedActivity(DetectedActivity.UNKNOWN, 100);
+
+    public ActivityRecognitionLocationProvider(Context context) {
+        super(context);
+        PROVIDER_ID = Config.ACTIVITY_PROVIDER;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        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_MUTABLE
+                    : 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 onLocationChanged(Location location) {
+        logger.debug("Location change: {}", location.toString());
+
+        if (lastActivity.getType() == DetectedActivity.STILL) {
+            handleStationary(location);
+            stopTracking();
+            return;
+        }
+
+        showDebugToast("acy:" + location.getAccuracy() + ",v:" + location.getSpeed());
+
+        lastLocation = location;
+        handleLocation(location);
+    }
+
+    public void startTracking() {
+        if (isTracking) { return; }
+
+        Integer priority = translateDesiredAccuracy(mConfig.getDesiredAccuracy());
+        LocationRequest locationRequest = LocationRequest.create()
+                .setPriority(priority) // this.accuracy
+                .setFastestInterval(mConfig.getFastestInterval())
+                .setInterval(mConfig.getInterval());
+        // .setSmallestDisplacement(mConfig.getStationaryRadius());
+        try {
+            LocationServices.FusedLocationApi.requestLocationUpdates(googleApiClient, locationRequest, this);
+            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; }
+
+        LocationServices.FusedLocationApi.removeLocationUpdates(googleApiClient, this);
+        isTracking = false;
+    }
+
+    private void connectToPlayAPI() {
+        logger.debug("Connecting to Google Play Services");
+        googleApiClient =  new GoogleApiClient.Builder(mContext)
+                .addApi(LocationServices.API)
+                .addApi(ActivityRecognition.API)
+                .addConnectionCallbacks(this)
+                //.addOnConnectionFailedListener(this)
+                .build();
+        googleApiClient.connect();
+    }
+
+    private void disconnectFromPlayAPI() {
+        if (googleApiClient != null && googleApiClient.isConnected()) {
+            googleApiClient.disconnect();
+        }
+    }
+
+    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 (googleApiClient == null) {
+            connectToPlayAPI();
+        } else if (googleApiClient.isConnected()) {
+            if (isWatchingActivity) { return; }
+            startTracking();
+            if (mConfig.getStopOnStillActivity() && activityRecognitionPermitted()) {
+                ActivityRecognition.ActivityRecognitionApi.requestActivityUpdates(
+                        googleApiClient,
+                        mConfig.getActivitiesInterval(),
+                        detectedActivitiesPI
+                );
+                isWatchingActivity = true;
+            }
+        } else {
+            googleApiClient.connect();
+        }
+    }
+
+    private void detachRecorder() {
+        if (isWatchingActivity) {
+            logger.debug("Detaching recorder");
+            ActivityRecognition.ActivityRecognitionApi.removeActivityUpdates(googleApiClient, detectedActivitiesPI);
+            isWatchingActivity = false;
+        }
+    }
+
+    @Override
+    public void onConnected(Bundle connectionHint) {
+        logger.debug("Connected to Google Play Services");
+        if (this.isStarted) {
+            attachRecorder();
+        }
+    }
+
+    @Override
+    public void onConnectionSuspended(int cause) {
+        // googleApiClient.connect();
+        logger.info("Connection to Google Play Services suspended");
+    }
+
+    @Override
+    public void onConnectionFailed(ConnectionResult connectionResult) {
+        logger.error("Connection to Google Play Services failed");
+    }
+
+    /**
+     * 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 Integer translateDesiredAccuracy(Integer 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;
+        }
+        if (accuracy >= 10) {
+            return LocationRequest.PRIORITY_HIGH_ACCURACY;
+        }
+        if (accuracy >= 0) {
+            return LocationRequest.PRIORITY_HIGH_ACCURACY;
+        }
+
+        return LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY;
+    }
+
+
+    public static DetectedActivity getProbableActivity(ArrayList<DetectedActivity> detectedActivities) {
+        int highestConfidence = 0;
+        DetectedActivity mostLikelyActivity = new DetectedActivity(0, DetectedActivity.UNKNOWN);
+
+        for(DetectedActivity da: detectedActivities) {
+            if(da.getType() != DetectedActivity.TILTING || da.getType() != DetectedActivity.UNKNOWN) {
+                Log.w(TAG, "Received a Detected Activity that was not tilting / 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);
+            ArrayList<DetectedActivity> detectedActivities = (ArrayList) result.getProbableActivities();
+
+            //Find the activity with the highest percentage
+            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");
+                // stopTracking();
+                // we will delay stop tracking after position is found
+            } else {
+                showDebugToast("Detected ACTIVE Activity");
+                startTracking();
+            }
+            //else do nothing
+        }
+    }
+
+    private BroadcastReceiver detectedActivitiesReceiver = new DetectedActivitiesReceiver();
+
+    @Override
+    public void onDestroy() {
+        logger.info("Destroying ActivityRecognitionLocationProvider");
+        onStop();
+        disconnectFromPlayAPI();
+        unregisterReceiver(detectedActivitiesReceiver);
+        super.onDestroy();
+    }
+}