@capgo/background-geolocation 8.0.32 → 8.0.34

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

@@ -9,13 +9,14 @@ 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 androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
 import com.getcapacitor.JSArray;
 import com.getcapacitor.JSObject;
@@ -27,7 +28,13 @@ 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.Geofence;
+import com.google.android.gms.location.GeofencingClient;
+import com.google.android.gms.location.GeofencingRequest;
 import com.google.android.gms.location.LocationServices;
+import java.net.URL;
+import java.util.Collections;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import org.json.JSONArray;
 import org.json.JSONException;
@@ -37,6 +44,7 @@ import org.json.JSONObject;
     name = "BackgroundGeolocation",
     permissions = {
         @Permission(strings = { Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION }, alias = "location"),
+        @Permission(strings = { Manifest.permission.ACCESS_BACKGROUND_LOCATION }, alias = "backgroundLocation"),
         @Permission(strings = { Manifest.permission.POST_NOTIFICATIONS }, alias = "notification")
     }
 )
@@ -46,6 +54,9 @@ public class BackgroundGeolocation extends Plugin {
 
     private CompletableFuture<BackgroundGeolocationService.LocalBinder> serviceConnectionFuture;
     private CompletableFuture<Void> locationPermissionFuture;
+    private CompletableFuture<Void> geofencePermissionFuture;
+    private BroadcastReceiver serviceReceiver;
+    private BroadcastReceiver geofenceEventReceiver;
 
     private void fetchLastLocation(PluginCall call) {
         try {
@@ -199,6 +210,236 @@ public class BackgroundGeolocation extends Plugin {
         }
     }
 
+    @PluginMethod
+    public void setupGeofencing(PluginCall call) {
+        String url = call.getString("url");
+        if (url != null && !url.isEmpty()) {
+            try {
+                URL urlObject = new URL(url);
+                String protocol = urlObject.getProtocol();
+                if (!"http".equalsIgnoreCase(protocol) && !"https".equalsIgnoreCase(protocol)) {
+                    call.reject("Given url is not valid");
+                    return;
+                }
+            } catch (Exception exception) {
+                call.reject("Given url is not valid");
+                return;
+            }
+        }
+
+        JSObject payload = call.getObject("payload", new JSObject());
+        GeofenceStore.saveSetup(getContext(), url, call.getBoolean("notifyOnEntry", true), call.getBoolean("notifyOnExit", true), payload);
+
+        if (!call.getBoolean("requestPermissions", true)) {
+            call.resolve();
+            return;
+        }
+
+        requestGeofencePermissions(call)
+            .thenRun(call::resolve)
+            .exceptionally((throwable) -> {
+                call.reject("Background location permission is required for geofencing", "NOT_AUTHORIZED");
+                return null;
+            });
+    }
+
+    @PluginMethod
+    public void addGeofence(PluginCall call) {
+        if (!hasGeofencePermissions()) {
+            call.reject("Background location permission is required for geofencing", "NOT_AUTHORIZED");
+            return;
+        }
+        if (!isLocationEnabled(getContext())) {
+            call.reject("Location services disabled.", "NOT_AUTHORIZED");
+            return;
+        }
+
+        Double latitude = call.getDouble("latitude");
+        Double longitude = call.getDouble("longitude");
+        String identifier = call.getString("identifier");
+        double radius = call.getDouble("radius", 50.0);
+        if (identifier == null || identifier.isEmpty()) {
+            call.reject("Identifier is required");
+            return;
+        }
+        if (latitude == null || latitude < -90 || latitude > 90) {
+            call.reject("Latitude must be between -90 and 90");
+            return;
+        }
+        if (longitude == null || longitude < -180 || longitude > 180) {
+            call.reject("Longitude must be between -180 and 180");
+            return;
+        }
+        if (radius <= 0) {
+            call.reject("Radius must be greater than 0");
+            return;
+        }
+
+        boolean notifyOnEntry = call.getBoolean("notifyOnEntry", GeofenceStore.getNotifyOnEntry(getContext()));
+        boolean notifyOnExit = call.getBoolean("notifyOnExit", GeofenceStore.getNotifyOnExit(getContext()));
+        int transitionTypes = 0;
+        int initialTrigger = 0;
+        if (notifyOnEntry) {
+            transitionTypes |= Geofence.GEOFENCE_TRANSITION_ENTER;
+            initialTrigger |= GeofencingRequest.INITIAL_TRIGGER_ENTER;
+        }
+        if (notifyOnExit) {
+            transitionTypes |= Geofence.GEOFENCE_TRANSITION_EXIT;
+        }
+        if (transitionTypes == 0) {
+            call.reject("At least one transition must be enabled");
+            return;
+        }
+
+        JSObject payload = call.getObject("payload", new JSObject());
+        Geofence geofence = new Geofence.Builder()
+            .setRequestId(identifier)
+            .setCircularRegion(latitude, longitude, (float) radius)
+            .setTransitionTypes(transitionTypes)
+            .setExpirationDuration(Geofence.NEVER_EXPIRE)
+            .build();
+        GeofencingRequest request = new GeofencingRequest.Builder().setInitialTrigger(initialTrigger).addGeofence(geofence).build();
+
+        try {
+            getGeofencingClient()
+                .addGeofences(request, getGeofencePendingIntent())
+                .addOnSuccessListener((unused) -> {
+                    try {
+                        GeofenceStore.saveRegion(
+                            getContext(),
+                            identifier,
+                            latitude,
+                            longitude,
+                            (float) radius,
+                            notifyOnEntry,
+                            notifyOnExit,
+                            payload
+                        );
+                        call.resolve();
+                    } catch (JSONException exception) {
+                        call.reject("Could not persist geofence", exception);
+                    }
+                })
+                .addOnFailureListener((exception) -> call.reject("Could not start monitoring the geofence", exception));
+        } catch (SecurityException exception) {
+            call.reject("Background location permission is required for geofencing", "NOT_AUTHORIZED", exception);
+        }
+    }
+
+    @PluginMethod
+    public void removeGeofence(PluginCall call) {
+        String identifier = call.getString("identifier");
+        if (identifier == null || identifier.isEmpty()) {
+            call.reject("Identifier is required");
+            return;
+        }
+        getGeofencingClient()
+            .removeGeofences(Collections.singletonList(identifier))
+            .addOnSuccessListener((unused) -> {
+                GeofenceStore.removeRegion(getContext(), identifier);
+                call.resolve();
+            })
+            .addOnFailureListener((exception) -> call.reject("Could not stop monitoring the geofence", exception));
+    }
+
+    @PluginMethod
+    public void removeAllGeofences(PluginCall call) {
+        getGeofencingClient()
+            .removeGeofences(getGeofencePendingIntent())
+            .addOnSuccessListener((unused) -> {
+                GeofenceStore.clearRegions(getContext());
+                call.resolve();
+            })
+            .addOnFailureListener((exception) -> call.reject("Could not stop monitoring geofences", exception));
+    }
+
+    @PluginMethod
+    public void getMonitoredGeofences(PluginCall call) {
+        JSObject result = new JSObject();
+        Set<String> regionIds = GeofenceStore.getRegionIds(getContext());
+        JSArray regions = new JSArray();
+        for (String regionId : regionIds) {
+            regions.put(regionId);
+        }
+        result.put("regions", regions);
+        call.resolve(result);
+    }
+
+    private CompletableFuture<Void> requestGeofencePermissions(PluginCall call) {
+        if (hasGeofencePermissions()) {
+            return CompletableFuture.completedFuture(null);
+        }
+        if (geofencePermissionFuture != null) {
+            return geofencePermissionFuture;
+        }
+        CompletableFuture<Void> future = new CompletableFuture<>();
+        geofencePermissionFuture = future;
+        if (getPermissionState("location") != PermissionState.GRANTED) {
+            requestPermissionForAlias("location", call, "geofenceLocationPermissionsCallback");
+            return future;
+        }
+        requestBackgroundLocationPermissionIfNeeded(call);
+        return future;
+    }
+
+    @PermissionCallback
+    private void geofenceLocationPermissionsCallback(PluginCall call) {
+        if (geofencePermissionFuture == null) {
+            return;
+        }
+        if (getPermissionState("location") != PermissionState.GRANTED) {
+            geofencePermissionFuture.completeExceptionally(new SecurityException("User denied location permission"));
+            geofencePermissionFuture = null;
+            return;
+        }
+        requestBackgroundLocationPermissionIfNeeded(call);
+    }
+
+    @PermissionCallback
+    private void geofenceBackgroundPermissionsCallback(PluginCall call) {
+        if (geofencePermissionFuture == null) {
+            return;
+        }
+        if (!hasBackgroundLocationPermission()) {
+            geofencePermissionFuture.completeExceptionally(new SecurityException("User denied background location permission"));
+            geofencePermissionFuture = null;
+            return;
+        }
+        geofencePermissionFuture.complete(null);
+        geofencePermissionFuture = null;
+    }
+
+    private void requestBackgroundLocationPermissionIfNeeded(PluginCall call) {
+        if (hasBackgroundLocationPermission()) {
+            geofencePermissionFuture.complete(null);
+            geofencePermissionFuture = null;
+            return;
+        }
+        requestPermissionForAlias("backgroundLocation", call, "geofenceBackgroundPermissionsCallback");
+    }
+
+    private boolean hasGeofencePermissions() {
+        return getPermissionState("location") == PermissionState.GRANTED && hasBackgroundLocationPermission();
+    }
+
+    private boolean hasBackgroundLocationPermission() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            return true;
+        }
+        return (
+            ContextCompat.checkSelfPermission(getContext(), Manifest.permission.ACCESS_BACKGROUND_LOCATION) ==
+            PackageManager.PERMISSION_GRANTED
+        );
+    }
+
+    private GeofencingClient getGeofencingClient() {
+        return LocationServices.getGeofencingClient(getContext());
+    }
+
+    private android.app.PendingIntent getGeofencePendingIntent() {
+        return GeofenceBroadcastReceiver.createPendingIntent(getContext());
+    }
+
     private static double[][] getJavaDoubleArray(JSArray jsArray) throws JSONException {
         int rows = jsArray.length();
         if (rows == 0) {
@@ -277,6 +518,27 @@ public class BackgroundGeolocation extends Plugin {
         }
     }
 
+    private class GeofenceEventReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            boolean errorEvent = GeofenceStore.ACTION_GEOFENCE_ERROR.equals(intent.getAction());
+            String payload = intent.getStringExtra(errorEvent ? GeofenceStore.EXTRA_GEOFENCE_ERROR : GeofenceStore.EXTRA_GEOFENCE_PAYLOAD);
+            if (payload == null || payload.isEmpty()) {
+                return;
+            }
+            try {
+                notifyListeners(
+                    errorEvent ? "geofenceError" : "geofenceTransition",
+                    GeofenceStore.toJSObject(new JSONObject(payload)),
+                    true
+                );
+            } catch (JSONException exception) {
+                Logger.error("Could not parse geofence payload", exception);
+            }
+        }
+    }
+
     @Override
     public void load() {
         super.load();
@@ -299,10 +561,16 @@ public class BackgroundGeolocation extends Plugin {
             manager.createNotificationChannel(channel);
         }
 
+        serviceReceiver = new ServiceReceiver();
         LocalBroadcastManager.getInstance(this.getContext()).registerReceiver(
-            new ServiceReceiver(),
+            serviceReceiver,
             new IntentFilter(BackgroundGeolocationService.ACTION_BROADCAST)
         );
+
+        geofenceEventReceiver = new GeofenceEventReceiver();
+        IntentFilter geofenceFilter = new IntentFilter(GeofenceStore.ACTION_GEOFENCE_EVENT);
+        geofenceFilter.addAction(GeofenceStore.ACTION_GEOFENCE_ERROR);
+        LocalBroadcastManager.getInstance(this.getContext()).registerReceiver(geofenceEventReceiver, geofenceFilter);
     }
 
     private CompletableFuture<BackgroundGeolocationService.LocalBinder> getServiceConnection() {
@@ -347,6 +615,17 @@ public class BackgroundGeolocation extends Plugin {
         if (locationPermissionFuture != null && !locationPermissionFuture.isDone()) {
             locationPermissionFuture.cancel(true);
         }
+        if (geofencePermissionFuture != null && !geofencePermissionFuture.isDone()) {
+            geofencePermissionFuture.cancel(true);
+        }
+        if (serviceReceiver != null) {
+            LocalBroadcastManager.getInstance(this.getContext()).unregisterReceiver(serviceReceiver);
+            serviceReceiver = null;
+        }
+        if (geofenceEventReceiver != null) {
+            LocalBroadcastManager.getInstance(this.getContext()).unregisterReceiver(geofenceEventReceiver);
+            geofenceEventReceiver = null;
+        }
         super.handleOnDestroy();
     }
 

package/android/src/main/java/com/capgo/capacitor_background_geolocation/GeofenceBootReceiver.java

@@ -0,0 +1,58 @@
+package com.capgo.capacitor_background_geolocation;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import com.getcapacitor.Logger;
+import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import java.util.ArrayList;
+import java.util.List;
+import org.json.JSONObject;
+
+public class GeofenceBootReceiver extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (intent == null || !shouldRestoreAction(intent.getAction())) {
+            return;
+        }
+
+        PendingResult pendingResult = goAsync();
+        List<Task<Void>> tasks = restorePersistedGeofences(context);
+        if (tasks.isEmpty()) {
+            pendingResult.finish();
+            return;
+        }
+        Tasks.whenAllComplete(tasks).addOnCompleteListener((unused) -> pendingResult.finish());
+    }
+
+    static boolean shouldRestoreAction(String action) {
+        return Intent.ACTION_BOOT_COMPLETED.equals(action) || Intent.ACTION_MY_PACKAGE_REPLACED.equals(action);
+    }
+
+    private static List<Task<Void>> restorePersistedGeofences(Context context) {
+        List<Task<Void>> tasks = new ArrayList<>();
+        var client = LocationServices.getGeofencingClient(context);
+        for (String identifier : GeofenceStore.getRegionIds(context)) {
+            JSONObject region = GeofenceStore.getRegion(context, identifier);
+            try {
+                tasks.add(
+                    client
+                        .addGeofences(GeofenceStore.buildGeofencingRequest(region), GeofenceBroadcastReceiver.createPendingIntent(context))
+                        .addOnSuccessListener((unused) -> Logger.debug("Restored geofence after boot: " + identifier))
+                        .addOnFailureListener((exception) ->
+                            Logger.error("Could not restore geofence after boot: " + identifier, exception)
+                        )
+                );
+            } catch (SecurityException exception) {
+                Logger.error("Missing permission to restore geofence after boot: " + identifier, exception);
+            } catch (Exception exception) {
+                GeofenceStore.removeRegion(context, identifier);
+                Logger.error("Invalid persisted geofence removed after boot: " + identifier, exception);
+            }
+        }
+        return tasks;
+    }
+}

package/android/src/main/java/com/capgo/capacitor_background_geolocation/GeofenceBroadcastReceiver.java

@@ -0,0 +1,83 @@
+package com.capgo.capacitor_background_geolocation;
+
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+import com.getcapacitor.Logger;
+import com.google.android.gms.location.Geofence;
+import com.google.android.gms.location.GeofenceStatusCodes;
+import com.google.android.gms.location.GeofencingEvent;
+import java.util.List;
+import org.json.JSONObject;
+
+public class GeofenceBroadcastReceiver extends BroadcastReceiver {
+
+    private static final int GEOFENCE_PENDING_INTENT_REQUEST_CODE = 83620;
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        GeofencingEvent event = GeofencingEvent.fromIntent(intent);
+        if (event == null) {
+            return;
+        }
+        if (event.hasError()) {
+            int errorCode = event.getErrorCode();
+            String message = GeofenceStatusCodes.getStatusCodeString(errorCode);
+            Logger.error("Geofence event failed with code: " + errorCode);
+            if (shouldClearStoredRegions(errorCode)) {
+                GeofenceStore.clearRegions(context);
+            }
+            try {
+                JSONObject data = new JSONObject();
+                data.put("code", errorCode);
+                data.put("message", message);
+                Intent localIntent = new Intent(GeofenceStore.ACTION_GEOFENCE_ERROR);
+                localIntent.putExtra(GeofenceStore.EXTRA_GEOFENCE_ERROR, data.toString());
+                LocalBroadcastManager.getInstance(context).sendBroadcast(localIntent);
+            } catch (Exception exception) {
+                Logger.error("Failed to emit geofence error", exception);
+            }
+            return;
+        }
+
+        int transition = event.getGeofenceTransition();
+        if (transition != Geofence.GEOFENCE_TRANSITION_ENTER && transition != Geofence.GEOFENCE_TRANSITION_EXIT) {
+            return;
+        }
+
+        List<Geofence> triggeringGeofences = event.getTriggeringGeofences();
+        if (triggeringGeofences == null || triggeringGeofences.isEmpty()) {
+            return;
+        }
+
+        boolean enter = transition == Geofence.GEOFENCE_TRANSITION_ENTER;
+        try {
+            for (Geofence geofence : triggeringGeofences) {
+                JSONObject data = GeofenceStore.buildTransitionData(context, geofence.getRequestId(), enter);
+                Intent localIntent = new Intent(GeofenceStore.ACTION_GEOFENCE_EVENT);
+                localIntent.putExtra(GeofenceStore.EXTRA_GEOFENCE_PAYLOAD, data.toString());
+                LocalBroadcastManager.getInstance(context).sendBroadcast(localIntent);
+                GeofenceStore.enqueueTransition(context, data);
+            }
+        } catch (Exception exception) {
+            Logger.error("Failed to handle geofence transition", exception);
+        }
+    }
+
+    static boolean shouldClearStoredRegions(int errorCode) {
+        return errorCode == GeofenceStatusCodes.GEOFENCE_NOT_AVAILABLE;
+    }
+
+    static PendingIntent createPendingIntent(Context context) {
+        Intent intent = new Intent(context, GeofenceBroadcastReceiver.class);
+        intent.setPackage(context.getPackageName());
+        int flags = PendingIntent.FLAG_UPDATE_CURRENT;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            flags |= PendingIntent.FLAG_MUTABLE;
+        }
+        return PendingIntent.getBroadcast(context, GEOFENCE_PENDING_INTENT_REQUEST_CODE, intent, flags);
+    }
+}