@azatek/background-geolocation 1.0.0

package/android/src/main/java/com/equimaps/capacitor_background_geolocation/BackgroundGeolocation.java

@@ -0,0 +1,348 @@
+package com.equimaps.capacitor_background_geolocation;
+
+import android.Manifest;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.graphics.Color;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.content.pm.PackageManager;
+import android.location.Location;
+import android.location.LocationManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.IBinder;
+import android.provider.Settings;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Logger;
+import com.getcapacitor.PermissionState;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.annotation.PermissionCallback;
+import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.tasks.OnSuccessListener;
+
+import org.json.JSONObject;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+@CapacitorPlugin(
+        name = "BackgroundGeolocation",
+        permissions = {
+                @Permission(
+                        strings = {
+                                Manifest.permission.ACCESS_COARSE_LOCATION,
+                                Manifest.permission.ACCESS_FINE_LOCATION
+                        },
+                        alias = "location"
+                )
+        }
+)
+public class BackgroundGeolocation extends Plugin {
+    private BackgroundGeolocationService.LocalBinder service = null;
+    private Boolean stoppedWithoutPermissions = false;
+
+    private void fetchLastLocation(PluginCall call) {
+        try {
+            LocationServices.getFusedLocationProviderClient(
+                    getContext()
+            ).getLastLocation().addOnSuccessListener(
+                    getActivity(),
+                    new OnSuccessListener<Location>() {
+                        @Override
+                        public void onSuccess(Location location) {
+                            if (location != null) {
+                                call.resolve(formatLocation(location));
+                            }
+                        }
+                    }
+            );
+        } catch (SecurityException ignore) {}
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_CALLBACK)
+    public void addWatcher(final PluginCall call) {
+        if (service == null) {
+            call.reject("Service not running.");
+            return;
+        }
+        call.setKeepAlive(true);
+
+        if (getPermissionState("location") != PermissionState.GRANTED) {
+            if (call.getBoolean("requestPermissions", true)) {
+                requestPermissionForAlias("location", call, "locationPermissionsCallback");
+            } else {
+                call.reject("Permission denied.", "NOT_AUTHORIZED");
+            }
+        } else if (!isLocationEnabled(getContext())) {
+            call.reject("Location services disabled.", "NOT_AUTHORIZED");
+        }
+        if (call.getBoolean("stale", false)) {
+            fetchLastLocation(call);
+        }
+        Notification backgroundNotification = null;
+        String backgroundMessage = call.getString("backgroundMessage");
+
+        if (backgroundMessage != null) {
+            Notification.Builder builder = new Notification.Builder(getContext())
+                    .setContentTitle(
+                            call.getString(
+                                "backgroundTitle",
+                                "Using your location"
+                            )
+                    )
+                    .setContentText(backgroundMessage)
+                    .setOngoing(true)
+                    .setPriority(Notification.PRIORITY_HIGH)
+                    .setWhen(System.currentTimeMillis());
+
+            try {
+                String name = getAppString(
+                        "capacitor_background_geolocation_notification_icon",
+                        "mipmap/ic_launcher"
+                );
+                String[] parts = name.split("/");
+                // It is actually necessary to set a valid icon for the notification to behave
+                // correctly when tapped. If there is no icon specified, tapping it will open the
+                // app's settings, rather than bringing the application to the foreground.
+                builder.setSmallIcon(
+                        getAppResourceIdentifier(parts[1], parts[0])
+                );
+            } catch (Exception e) {
+                Logger.error("Could not set notification icon", e);
+            }
+
+            try {
+                String color = getAppString(
+                        "capacitor_background_geolocation_notification_color",
+                        null
+                );
+                if (color != null) {
+                    builder.setColor(Color.parseColor(color));
+                }
+            } catch (Exception e) {
+                Logger.error("Could not set notification color", e);
+            }
+
+            Intent launchIntent = getContext().getPackageManager().getLaunchIntentForPackage(
+                    getContext().getPackageName()
+            );
+            if (launchIntent != null) {
+                launchIntent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
+                builder.setContentIntent(
+                        PendingIntent.getActivity(
+                                getContext(),
+                                0,
+                                launchIntent,
+                                PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_IMMUTABLE
+                        )
+                );
+            }
+
+            // Set the Channel ID for Android O.
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                builder.setChannelId(BackgroundGeolocationService.class.getPackage().getName());
+            }
+
+            backgroundNotification = builder.build();
+        }
+		service.addWatcher(
+				call.getCallbackId(),
+				backgroundNotification,
+				call.getFloat("distanceFilter", 0f),
+				call.getInt("accuracy", 102)
+		);
+    }
+
+    @PermissionCallback
+    private void locationPermissionsCallback(PluginCall call) {
+
+        if (getPermissionState("location") != PermissionState.GRANTED) {
+            call.reject("User denied location permission", "NOT_AUTHORIZED");
+            return;
+        }
+        if (call.getBoolean("stale", false)) {
+            fetchLastLocation(call);
+        }
+        if (service != null) {
+            service.onPermissionsGranted();
+            // The handleOnResume method will now be called, and we don't need it to call
+            // service.onPermissionsGranted again so we reset this flag.
+            stoppedWithoutPermissions = false;
+        }
+    }
+
+    @PluginMethod()
+    public void removeWatcher(PluginCall call) {
+        String callbackId = call.getString("id");
+        if (callbackId == null) {
+            call.reject("Missing id.");
+            return;
+        }
+        service.removeWatcher(callbackId);
+        PluginCall savedCall = getBridge().getSavedCall(callbackId);
+        if (savedCall != null) {
+            savedCall.release(getBridge());
+        }
+        call.resolve();
+    }
+
+    @PluginMethod()
+    public void openSettings(PluginCall call) {
+        Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+        Uri uri = Uri.fromParts("package", getContext().getPackageName(), null);
+        intent.setData(uri);
+        getContext().startActivity(intent);
+        call.resolve();
+    }
+
+    // Checks if device-wide location services are disabled
+    private static Boolean isLocationEnabled(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            LocationManager lm = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
+            return lm != null && lm.isLocationEnabled();
+        } else {
+            return (
+                    Settings.Secure.getInt(
+                            context.getContentResolver(),
+                            Settings.Secure.LOCATION_MODE,
+                            Settings.Secure.LOCATION_MODE_OFF
+                    ) != Settings.Secure.LOCATION_MODE_OFF
+            );
+        }
+    }
+
+    private static JSObject formatLocation(Location location) {
+        JSObject obj = new JSObject();
+        obj.put("latitude", location.getLatitude());
+        obj.put("longitude", location.getLongitude());
+        // The docs state that all Location objects have an accuracy, but then why is there a
+        // hasAccuracy method? Better safe than sorry.
+        obj.put("accuracy", location.hasAccuracy() ? location.getAccuracy() : JSONObject.NULL);
+        obj.put("altitude", location.hasAltitude() ? location.getAltitude() : JSONObject.NULL);
+        if (Build.VERSION.SDK_INT >= 26 && location.hasVerticalAccuracy()) {
+            obj.put("altitudeAccuracy", location.getVerticalAccuracyMeters());
+        } else {
+            obj.put("altitudeAccuracy", JSONObject.NULL);
+        }
+        // In addition to mocking locations in development, Android allows the
+        // installation of apps which have the power to simulate location
+        // readings in other apps.
+        obj.put("simulated", location.isFromMockProvider());
+        obj.put("speed", location.hasSpeed() ? location.getSpeed() : JSONObject.NULL);
+        obj.put("bearing", location.hasBearing() ? location.getBearing() : JSONObject.NULL);
+        obj.put("time", location.getTime());
+        return obj;
+    }
+
+    // Receives messages from the service.
+    private class ServiceReceiver extends BroadcastReceiver {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String id = intent.getStringExtra("id");
+            PluginCall call = getBridge().getSavedCall(id);
+            if (call == null) {
+                return;
+            }
+            Location location = intent.getParcelableExtra("location");
+            if (location != null) {
+                call.resolve(formatLocation(location));
+            } else {
+                Logger.debug("No locations received");
+            }
+        }
+    }
+
+    // Gets the identifier of the app's resource by name, returning 0 if not found.
+    private int getAppResourceIdentifier(String name, String defType) {
+        return getContext().getResources().getIdentifier(
+                name,
+                defType,
+                getContext().getPackageName()
+        );
+    }
+
+    // Gets a string from the app's strings.xml file, resorting to a fallback if it is not defined.
+    private String getAppString(String name, String fallback) {
+        int id = getAppResourceIdentifier(name, "string");
+        return id == 0 ? fallback : getContext().getString(id);
+    }
+
+    @Override
+    public void load() {
+        super.load();
+
+        // Android O requires a Notification Channel.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationManager manager = (NotificationManager) getContext().getSystemService(
+                    Context.NOTIFICATION_SERVICE
+            );
+            NotificationChannel channel = new NotificationChannel(
+                    BackgroundGeolocationService.class.getPackage().getName(),
+                    getAppString(
+                            "capacitor_background_geolocation_notification_channel_name",
+                            "Background Tracking"
+                    ),
+                    NotificationManager.IMPORTANCE_DEFAULT
+            );
+            channel.enableLights(false);
+            channel.enableVibration(false);
+            channel.setSound(null, null);
+            manager.createNotificationChannel(channel);
+        }
+
+        this.getContext().bindService(
+                new Intent(this.getContext(), BackgroundGeolocationService.class),
+                new ServiceConnection() {
+                    @Override
+                    public void onServiceConnected(ComponentName name, IBinder binder) {
+                        BackgroundGeolocation.this.service = (BackgroundGeolocationService.LocalBinder) binder;
+                    }
+
+                    @Override
+                    public void onServiceDisconnected(ComponentName name) {
+                    }
+                },
+                Context.BIND_AUTO_CREATE
+        );
+
+        LocalBroadcastManager.getInstance(this.getContext()).registerReceiver(
+                new ServiceReceiver(),
+                new IntentFilter(BackgroundGeolocationService.ACTION_BROADCAST)
+        );
+    }
+
+    @Override
+    protected void handleOnResume() {
+        if (service != null) {
+            if (stoppedWithoutPermissions && getPermissionState("location") == PermissionState.GRANTED) {
+                service.onPermissionsGranted();
+            }
+        }
+        super.handleOnResume();
+    }
+
+    @Override
+    protected void handleOnPause() {
+        stoppedWithoutPermissions = getPermissionState("location") != PermissionState.GRANTED;
+        super.handleOnPause();
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        if (service != null) {
+            service.stopService();
+        }
+        super.handleOnDestroy();
+    }
+}

package/android/src/main/java/com/equimaps/capacitor_background_geolocation/BackgroundGeolocationService.java

@@ -0,0 +1,204 @@
+package com.equimaps.capacitor_background_geolocation;
+
+import android.app.Notification;
+import android.app.Service;
+import android.content.Intent;
+import android.content.pm.ServiceInfo;
+import android.location.Location;
+import android.os.Binder;
+import android.os.Build;
+import android.os.IBinder;
+
+import com.getcapacitor.Logger;
+import com.google.android.gms.location.FusedLocationProviderClient;
+import com.google.android.gms.location.LocationAvailability;
+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 java.util.HashSet;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+// A bound and started service that is promoted to a foreground service
+// (showing a persistent notification) when the first background watcher is
+// added, and demoted when the last background watcher is removed.
+public class BackgroundGeolocationService extends Service {
+    static final String ACTION_BROADCAST = (
+            BackgroundGeolocationService.class.getPackage().getName() + ".broadcast"
+    );
+    private final IBinder binder = new LocalBinder();
+
+    // Must be unique for this application.
+    private static final int NOTIFICATION_ID = 28351;
+
+    private class Watcher {
+        public String id;
+        public FusedLocationProviderClient client;
+        public LocationRequest locationRequest;
+        public LocationCallback locationCallback;
+        public Notification backgroundNotification;
+    }
+    private HashSet<Watcher> watchers = new HashSet<Watcher>();
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return binder;
+    }
+
+    // Some devices allow a foreground service to outlive the application's main
+    // activity, leading to nasty crashes as reported in issue #59. If we learn
+    // that the application has been killed, all watchers are stopped and the
+    // service is terminated immediately.
+    @Override
+    public boolean onUnbind(Intent intent) {
+        for (Watcher watcher : watchers) {
+            watcher.client.removeLocationUpdates(watcher.locationCallback);
+        }
+        watchers = new HashSet<Watcher>();
+        stopSelf();
+        return false;
+    }
+
+    Notification getNotification() {
+        for (Watcher watcher : watchers) {
+            if (watcher.backgroundNotification != null) {
+                return watcher.backgroundNotification;
+            }
+        }
+        return null;
+    }
+
+    // Handles requests from the activity.
+    public class LocalBinder extends Binder {
+		void addWatcher(
+				final String id,
+				Notification backgroundNotification,
+				float distanceFilter,
+				int accuracy
+		) {
+			FusedLocationProviderClient client = LocationServices.getFusedLocationProviderClient(
+					BackgroundGeolocationService.this
+			);
+			
+			// Map accuracy enum to Android Priority
+			int priority;
+			long interval;
+			
+			switch (accuracy) {
+				case 100: // HIGH
+					priority = Priority.PRIORITY_HIGH_ACCURACY;
+					interval = 5000; // 5 seconds
+					break;
+				case 102: // BALANCED (Default)
+					priority = Priority.PRIORITY_BALANCED_POWER_ACCURACY;
+					interval = 10000; // 10 seconds
+					break;
+				case 104: // LOW
+					priority = Priority.PRIORITY_LOW_POWER;
+					interval = 30000; // 30 seconds
+					break;
+				case 105: // PASSIVE
+					priority = Priority.PRIORITY_PASSIVE;
+					interval = 60000; // 60 seconds
+					break;
+				default:
+					priority = Priority.PRIORITY_BALANCED_POWER_ACCURACY;
+					interval = 10000;
+			}
+			
+			// Use modern LocationRequest.Builder API
+			LocationRequest locationRequest = new LocationRequest.Builder(priority, interval)
+					.setMinUpdateDistanceMeters(distanceFilter)
+					.setWaitForAccurateLocation(false)
+					.setMaxUpdateDelayMillis(interval)
+					.build();
+
+            LocationCallback callback = new LocationCallback(){
+                @Override
+                public void onLocationResult(LocationResult locationResult) {
+                    Location location = locationResult.getLastLocation();
+                    Intent intent = new Intent(ACTION_BROADCAST);
+                    intent.putExtra("location", location);
+                    intent.putExtra("id", id);
+                    LocalBroadcastManager.getInstance(
+                            getApplicationContext()
+                    ).sendBroadcast(intent);
+                }
+                @Override
+                public void onLocationAvailability(LocationAvailability availability) {
+                    if (!availability.isLocationAvailable()) {
+                        Logger.debug("Location not available");
+                    }
+                }
+            };
+
+            Watcher watcher = new Watcher();
+            watcher.id = id;
+            watcher.client = client;
+            watcher.locationRequest = locationRequest;
+            watcher.locationCallback = callback;
+            watcher.backgroundNotification = backgroundNotification;
+            watchers.add(watcher);
+
+            // According to Android Studio, this method can throw a Security Exception if
+            // permissions are not yet granted. Rather than check the permissions, which is fiddly,
+            // we simply ignore the exception.
+            try {
+                watcher.client.requestLocationUpdates(
+                        watcher.locationRequest,
+                        watcher.locationCallback,
+                        null
+                );
+            } catch (SecurityException ignore) {}
+
+            // Promote the service to the foreground if necessary.
+            // Ideally we would only call 'startForeground' if the service is not already
+            // foregrounded. Unfortunately, 'getForegroundServiceType' was only introduced
+            // in API level 29 and seems to behave weirdly, as reported in #120. However,
+            // it appears that 'startForeground' is idempotent, so we just call it repeatedly
+            // each time a background watcher is added.
+            if (backgroundNotification != null) {
+                try {
+                    // This method has been known to fail due to weird
+                    // permission bugs, so we prevent any exceptions from
+                    // crashing the app. See issue #86.
+                    startForeground(NOTIFICATION_ID, backgroundNotification);
+                } catch (Exception exception) {
+                    Logger.error("Failed to foreground service", exception);
+                }
+            }
+        }
+
+        void removeWatcher(String id) {
+            for (Watcher watcher : watchers) {
+                if (watcher.id.equals(id)) {
+                    watcher.client.removeLocationUpdates(watcher.locationCallback);
+                    watchers.remove(watcher);
+                    if (getNotification() == null) {
+                        stopForeground(true);
+                    }
+                    return;
+                }
+            }
+        }
+
+        void onPermissionsGranted() {
+            // If permissions were granted while the app was in the background, for example in
+            // the Settings app, the watchers need restarting.
+            for (Watcher watcher : watchers) {
+                watcher.client.removeLocationUpdates(watcher.locationCallback);
+                watcher.client.requestLocationUpdates(
+                        watcher.locationRequest,
+                        watcher.locationCallback,
+                        null
+                );
+            }
+        }
+
+        void stopService() {
+            BackgroundGeolocationService.this.stopSelf();
+        }
+    }
+}