@josuelmm/capacitor-background-geolocation 1.0.0

package/android/src/main/java/com/marianhello/bgloc/data/ConfigJsonMapper.java

@@ -0,0 +1,211 @@
+package com.marianhello.bgloc.data;
+
+import com.marianhello.bgloc.Config;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * v4.4.1 — JSON serializer/deserializer for the full {@link Config} state.
+ *
+ * Lives in {@code common} so both the SQLite DAO (also common) and the Cordova
+ * {@code ConfigMapper} (cordova) can reuse it without creating a common→cordova
+ * dependency. Used to persist a single {@code config_json} TEXT column instead of
+ * adding one schema column per new field on every release.
+ *
+ * Round-trip: every JS-configurable key the plugin understands is preserved.
+ * Anything not present in the input JSON keeps the {@link Config} default.
+ */
+public final class ConfigJsonMapper {
+
+    private ConfigJsonMapper() {}
+
+    /** Serialize the current Config state to a JSONObject suitable for storage.
+     *  String fields use {@link JSONObject#NULL} when the user explicitly cleared them
+     *  (i.e. equals {@link Config#NullString}) so the sentinel survives the round-trip. */
+    public static JSONObject toJSONObject(Config c) throws JSONException {
+        JSONObject j = new JSONObject();
+        if (c == null) return j;
+        j.put("stationaryRadius", c.getStationaryRadius());
+        j.put("distanceFilter", c.getDistanceFilter());
+        j.put("desiredAccuracy", c.getDesiredAccuracy());
+        j.put("debug", c.isDebugging());
+        j.put("notificationTitle", nullable(c.getNotificationTitle()));
+        j.put("notificationText", nullable(c.getNotificationText()));
+        j.put("notificationSyncTitle", nullable(c.getNotificationSyncTitle()));
+        j.put("notificationSyncText", nullable(c.getNotificationSyncText()));
+        j.put("notificationSyncCompletedText", nullable(c.getNotificationSyncCompletedText()));
+        j.put("notificationSyncFailedText", nullable(c.getNotificationSyncFailedText()));
+        j.put("notificationIconLarge", nullable(c.getLargeNotificationIcon()));
+        j.put("notificationIconSmall", nullable(c.getSmallNotificationIcon()));
+        j.put("notificationIconColor", nullable(c.getNotificationIconColor()));
+        j.put("locationProvider", c.getLocationProvider());
+        j.put("interval", c.getInterval());
+        j.put("fastestInterval", c.getFastestInterval());
+        j.put("activitiesInterval", c.getActivitiesInterval());
+        j.put("stopOnTerminate", c.getStopOnTerminate());
+        j.put("startOnBoot", c.getStartOnBoot());
+        j.put("startForeground", c.getStartForeground());
+        j.put("notificationsEnabled", c.getNotificationsEnabled());
+        j.put("stopOnStillActivity", c.getStopOnStillActivity());
+        j.put("url", nullable(c.getUrl()));
+        j.put("syncUrl", nullable(c.getSyncUrl()));
+        j.put("syncThreshold", c.getSyncThreshold());
+        j.put("syncEnabled", c.getSyncEnabled());
+        j.put("maxLocations", c.getMaxLocations());
+        j.put("enableWatchdog", c.getEnableWatchdog());
+        j.put("showTime", c.getShowTime());
+        j.put("showDistance", c.getShowDistance());
+        j.put("httpMethod", c.getHttpMethod());
+        j.put("syncHttpMethod", c.getSyncHttpMethod());
+        j.put("httpMode", c.getHttpMode());
+        j.put("syncMode", c.getSyncMode());
+        j.put("heartbeatInterval", c.getHeartbeatInterval());
+        j.put("mockLocationPolicy", c.getMockLocationPolicy());
+        j.put("includeBattery", c.getIncludeBattery());
+        // v4.5.1: battery knobs
+        j.put("wakeLockMode", c.getWakeLockMode());
+        j.put("stationaryTimeout", c.getStationaryTimeout());
+        j.put("stationaryPollInterval", c.getStationaryPollInterval());
+        j.put("stationaryPollFast", c.getStationaryPollFast());
+        // v4.5.2: provider hardening knobs
+        j.put("activityConfidenceThreshold", c.getActivityConfidenceThreshold());
+        j.put("maxAcceptedAccuracy", c.getMaxAcceptedAccuracy());
+
+        if (c.getHttpHeaders() != null) {
+            j.put("httpHeaders", new JSONObject(c.getHttpHeaders()));
+        }
+        if (c.getQueryParams() != null) {
+            j.put("queryParams", new JSONObject(c.getQueryParams()));
+        }
+
+        Config.DrivingEventsOptions de = c.getDrivingEvents();
+        if (de != null) {
+            JSONObject deJson = new JSONObject();
+            deJson.put("enabled", de.enabled);
+            deJson.put("speedLimit", de.speedLimitKmh);
+            deJson.put("minMovingSpeed", de.minMovingSpeedMps);
+            deJson.put("stoppedDuration", de.stoppedDurationMs);
+            deJson.put("minTripSpeed", de.minTripSpeedMps);
+            deJson.put("minTripDuration", de.minTripDurationMs);
+            deJson.put("hardBrakeMps2", de.hardBrakeMps2);
+            deJson.put("rapidAccelMps2", de.rapidAccelMps2);
+            deJson.put("sharpTurnDegPerSec", de.sharpTurnDegPerSec);
+            deJson.put("crashImpactKmh", de.crashImpactKmh);
+            deJson.put("crashWindowMs", de.crashWindowMs);
+            deJson.put("sensorFusion", de.sensorFusion);
+            deJson.put("crashImpactG", de.crashImpactG);
+            deJson.put("sensorCrashCooldownMs", de.sensorCrashCooldownMs);
+            deJson.put("phoneUsageWindowMs", de.phoneUsageWindowMs);
+            deJson.put("phoneUsageCooldownMs", de.phoneUsageCooldownMs);
+            j.put("drivingEvents", deJson);
+        }
+        return j;
+    }
+
+    /** Deserialize a previously serialized config JSON. Missing keys are skipped (defaults preserved). */
+    public static Config fromJSONObject(JSONObject j) throws JSONException {
+        Config c = Config.getDefault();
+        if (j == null) return c;
+        if (j.has("stationaryRadius")) c.setStationaryRadius((float) j.getDouble("stationaryRadius"));
+        if (j.has("distanceFilter")) c.setDistanceFilter(j.getInt("distanceFilter"));
+        if (j.has("desiredAccuracy")) c.setDesiredAccuracy(j.getInt("desiredAccuracy"));
+        if (j.has("debug")) c.setDebugging(j.getBoolean("debug"));
+        if (j.has("notificationTitle")) c.setNotificationTitle(readNullable(j, "notificationTitle"));
+        if (j.has("notificationText")) c.setNotificationText(readNullable(j, "notificationText"));
+        if (j.has("notificationSyncTitle")) c.setNotificationSyncTitle(readNullable(j, "notificationSyncTitle"));
+        if (j.has("notificationSyncText")) c.setNotificationSyncText(readNullable(j, "notificationSyncText"));
+        if (j.has("notificationSyncCompletedText")) c.setNotificationSyncCompletedText(readNullable(j, "notificationSyncCompletedText"));
+        if (j.has("notificationSyncFailedText")) c.setNotificationSyncFailedText(readNullable(j, "notificationSyncFailedText"));
+        if (j.has("notificationIconLarge")) c.setLargeNotificationIcon(readNullable(j, "notificationIconLarge"));
+        if (j.has("notificationIconSmall")) c.setSmallNotificationIcon(readNullable(j, "notificationIconSmall"));
+        if (j.has("notificationIconColor")) c.setNotificationIconColor(readNullable(j, "notificationIconColor"));
+        if (j.has("locationProvider")) c.setLocationProvider(j.getInt("locationProvider"));
+        if (j.has("interval")) c.setInterval(j.getInt("interval"));
+        if (j.has("fastestInterval")) c.setFastestInterval(j.getInt("fastestInterval"));
+        if (j.has("activitiesInterval")) c.setActivitiesInterval(j.getInt("activitiesInterval"));
+        if (j.has("stopOnTerminate")) c.setStopOnTerminate(j.getBoolean("stopOnTerminate"));
+        if (j.has("startOnBoot")) c.setStartOnBoot(j.getBoolean("startOnBoot"));
+        if (j.has("startForeground")) c.setStartForeground(j.getBoolean("startForeground"));
+        if (j.has("notificationsEnabled")) c.setNotificationsEnabled(j.getBoolean("notificationsEnabled"));
+        if (j.has("stopOnStillActivity")) c.setStopOnStillActivity(j.getBoolean("stopOnStillActivity"));
+        if (j.has("url")) c.setUrl(readNullable(j, "url"));
+        if (j.has("syncUrl")) c.setSyncUrl(readNullable(j, "syncUrl"));
+        if (j.has("syncThreshold")) c.setSyncThreshold(j.getInt("syncThreshold"));
+        if (j.has("syncEnabled")) c.setSyncEnabled(j.getBoolean("syncEnabled"));
+        if (j.has("maxLocations")) c.setMaxLocations(j.getInt("maxLocations"));
+        if (j.has("enableWatchdog")) c.setEnableWatchdog(j.getBoolean("enableWatchdog"));
+        if (j.has("showTime")) c.setShowTime(j.getBoolean("showTime"));
+        if (j.has("showDistance")) c.setShowDistance(j.getBoolean("showDistance"));
+        if (has(j, "httpMethod")) c.setHttpMethod(j.getString("httpMethod"));
+        if (has(j, "syncHttpMethod")) c.setSyncHttpMethod(j.getString("syncHttpMethod"));
+        if (has(j, "httpMode")) c.setHttpMode(j.getString("httpMode"));
+        if (has(j, "syncMode")) c.setSyncMode(j.getString("syncMode"));
+        if (j.has("heartbeatInterval")) c.setHeartbeatInterval(j.getInt("heartbeatInterval"));
+        if (has(j, "mockLocationPolicy")) c.setMockLocationPolicy(j.getString("mockLocationPolicy"));
+        if (j.has("includeBattery")) c.setIncludeBattery(j.getBoolean("includeBattery"));
+        // v4.5.1: battery knobs
+        if (has(j, "wakeLockMode"))  c.setWakeLockMode(j.getString("wakeLockMode"));
+        if (j.has("stationaryTimeout") && !j.isNull("stationaryTimeout")) c.setStationaryTimeout(j.getInt("stationaryTimeout"));
+        if (j.has("stationaryPollInterval") && !j.isNull("stationaryPollInterval")) c.setStationaryPollInterval(j.getInt("stationaryPollInterval"));
+        if (j.has("stationaryPollFast") && !j.isNull("stationaryPollFast")) c.setStationaryPollFast(j.getInt("stationaryPollFast"));
+        // v4.5.2
+        if (j.has("activityConfidenceThreshold") && !j.isNull("activityConfidenceThreshold")) c.setActivityConfidenceThreshold(j.getInt("activityConfidenceThreshold"));
+        if (j.has("maxAcceptedAccuracy") && !j.isNull("maxAcceptedAccuracy")) c.setMaxAcceptedAccuracy((float) j.getDouble("maxAcceptedAccuracy"));
+
+        if (has(j, "httpHeaders")) c.setHttpHeaders(jsonToHashMap(j.getJSONObject("httpHeaders")));
+        if (has(j, "queryParams")) c.setQueryParams(jsonToHashMap(j.getJSONObject("queryParams")));
+
+        if (has(j, "drivingEvents")) {
+            JSONObject de = j.getJSONObject("drivingEvents");
+            Config.DrivingEventsOptions o = new Config.DrivingEventsOptions();
+            if (de.has("enabled"))               o.enabled               = de.getBoolean("enabled");
+            if (de.has("speedLimit"))            o.speedLimitKmh         = de.getDouble("speedLimit");
+            if (de.has("minMovingSpeed"))        o.minMovingSpeedMps     = de.getDouble("minMovingSpeed");
+            if (de.has("stoppedDuration"))       o.stoppedDurationMs     = de.getLong("stoppedDuration");
+            if (de.has("minTripSpeed"))          o.minTripSpeedMps       = de.getDouble("minTripSpeed");
+            if (de.has("minTripDuration"))       o.minTripDurationMs     = de.getLong("minTripDuration");
+            if (de.has("hardBrakeMps2"))         o.hardBrakeMps2         = de.getDouble("hardBrakeMps2");
+            if (de.has("rapidAccelMps2"))        o.rapidAccelMps2        = de.getDouble("rapidAccelMps2");
+            if (de.has("sharpTurnDegPerSec"))    o.sharpTurnDegPerSec    = de.getDouble("sharpTurnDegPerSec");
+            if (de.has("crashImpactKmh"))        o.crashImpactKmh        = de.getDouble("crashImpactKmh");
+            if (de.has("crashWindowMs"))         o.crashWindowMs         = de.getLong("crashWindowMs");
+            if (de.has("sensorFusion"))          o.sensorFusion          = de.getBoolean("sensorFusion");
+            if (de.has("crashImpactG"))          o.crashImpactG          = de.getDouble("crashImpactG");
+            if (de.has("sensorCrashCooldownMs")) o.sensorCrashCooldownMs = de.getLong("sensorCrashCooldownMs");
+            if (de.has("phoneUsageWindowMs"))    o.phoneUsageWindowMs    = de.getLong("phoneUsageWindowMs");
+            if (de.has("phoneUsageCooldownMs")) o.phoneUsageCooldownMs   = de.getLong("phoneUsageCooldownMs");
+            c.setDrivingEvents(o);
+        }
+        return c;
+    }
+
+    private static HashMap<String, String> jsonToHashMap(JSONObject obj) throws JSONException {
+        HashMap<String, String> map = new HashMap<>();
+        Iterator<String> keys = obj.keys();
+        while (keys.hasNext()) {
+            String k = keys.next();
+            map.put(k, String.valueOf(obj.get(k)));
+        }
+        return map;
+    }
+
+    private static boolean has(JSONObject j, String key) {
+        return j.has(key) && !j.isNull(key);
+    }
+
+    /** Map {@link Config#NullString} or null to JSONObject.NULL so the sentinel survives. */
+    private static Object nullable(String s) {
+        if (s == null || s == Config.NullString) return JSONObject.NULL;
+        return s;
+    }
+
+    /** Inverse of {@link #nullable(String)}. JSON null → {@link Config#NullString}. */
+    private static String readNullable(JSONObject j, String key) throws JSONException {
+        if (j.isNull(key)) return Config.NullString;
+        return j.getString(key);
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/data/ConfigurationDAO.java

@@ -0,0 +1,13 @@
+package com.marianhello.bgloc.data;
+
+import java.util.Date;
+import java.util.Collection;
+
+import org.json.JSONException;
+
+import com.marianhello.bgloc.Config;
+
+public interface ConfigurationDAO {
+    boolean persistConfiguration(Config config) throws NullPointerException;
+    Config retrieveConfiguration() throws JSONException;
+}

package/android/src/main/java/com/marianhello/bgloc/data/DAOFactory.java

@@ -0,0 +1,17 @@
+package com.marianhello.bgloc.data;
+
+import android.content.Context;
+
+import com.marianhello.bgloc.data.provider.ContentProviderLocationDAO;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationDAO;
+import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationDAO;
+
+public abstract class DAOFactory {
+    public static LocationDAO createLocationDAO(Context context) {
+        return new ContentProviderLocationDAO(context);
+    }
+
+    public static ConfigurationDAO createConfigurationDAO(Context context) {
+        return new SQLiteConfigurationDAO(context);
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/data/HashMapLocationTemplate.java

@@ -0,0 +1,82 @@
+package com.marianhello.bgloc.data;
+
+import com.marianhello.utils.CloneHelper;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * Created by finch on 9.12.2017.
+ */
+
+public class HashMapLocationTemplate extends AbstractLocationTemplate implements Serializable {
+    private HashMap<?, String> mMap;
+    private static final long serialVersionUID = 1234L;
+
+    // copy constructor
+    public HashMapLocationTemplate(HashMapLocationTemplate tpl) {
+        if (tpl == null || tpl.mMap == null) {
+            return;
+        }
+
+        mMap = CloneHelper.deepCopy(tpl.mMap);
+    }
+
+    public HashMapLocationTemplate(HashMap map) {
+        this.mMap = map;
+    }
+
+    @Override
+    public Object locationToJson(BackgroundLocation location) throws JSONException {
+        return LocationMapper.map(location).withMap(mMap);
+    }
+
+    public Iterator iterator() {
+        return mMap.entrySet().iterator();
+    }
+
+    public boolean containsKey(String propName) {
+        return mMap.containsKey(propName);
+    }
+
+    public String get(String key) {
+        return mMap.get(key);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return mMap == null || mMap.isEmpty();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other == null) return false;
+        if (other == this) return true;
+        if (!(other instanceof HashMapLocationTemplate)) return false;
+        return ((HashMapLocationTemplate) other).mMap.equals(this.mMap);
+    }
+
+    @Override
+    public String toString() {
+        if (mMap == null) {
+            return "null";
+        }
+
+        JSONObject jObject = new JSONObject(mMap);
+        return jObject.toString();
+    }
+
+    public Map toMap() {
+        return mMap;
+    }
+
+    @Override
+    public LocationTemplate clone() {
+        return new HashMapLocationTemplate(this);
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/data/LocationDAO.java

@@ -0,0 +1,27 @@
+package com.marianhello.bgloc.data;
+
+import java.util.Collection;
+
+public interface LocationDAO {
+    Collection<BackgroundLocation> getAllLocations();
+    Collection<BackgroundLocation> getValidLocations();
+    Collection<BackgroundLocation> getValidLocationsAndDelete();
+    BackgroundLocation getLocationById(long id);
+    BackgroundLocation getFirstUnpostedLocation();
+    BackgroundLocation getNextUnpostedLocation(long fromId);
+    long getUnpostedLocationsCount();
+    long getLocationsForSyncCount(long millisSinceLastBatch);
+    long persistLocation(BackgroundLocation location);
+    long persistLocation(BackgroundLocation location, int maxRows);
+    long persistLocationForSync(BackgroundLocation location, int maxRows);
+    void updateLocationForSync(long locationId);
+    void deleteLocationById(long locationId);
+    BackgroundLocation deleteFirstUnpostedLocation();
+    int deleteAllLocations();
+    int deleteUnpostedLocations();
+    /**
+     * Delete (mark as deleted) all locations that are pending sync to syncUrl.
+     * Same effect as discarding the pending sync queue without sending to server.
+     */
+    int deletePendingSyncLocations();
+}

package/android/src/main/java/com/marianhello/bgloc/data/LocationTemplate.java

@@ -0,0 +1,12 @@
+package com.marianhello.bgloc.data;
+
+import org.json.JSONException;
+
+/**
+ * Created by finch on 9.12.2017.
+ */
+
+public interface LocationTemplate {
+    Object locationToJson(BackgroundLocation location) throws JSONException;
+    boolean isEmpty();
+}

package/android/src/main/java/com/marianhello/bgloc/data/LocationTemplateFactory.java

@@ -0,0 +1,71 @@
+package com.marianhello.bgloc.data;
+
+import com.marianhello.utils.Convert;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * Created by finch on 9.12.2017.
+ */
+
+public class LocationTemplateFactory {
+
+    public static LocationTemplate fromJSON(Object json) throws JSONException {
+        if (json instanceof JSONObject) {
+            JSONObject jsonObject = (JSONObject) json;
+
+            return new HashMapLocationTemplate((HashMap) Convert.toMap(jsonObject));
+        } else if (json instanceof JSONArray) {
+            JSONArray jsonArray = (JSONArray) json;
+
+            return new ArrayListLocationTemplate((ArrayList) Convert.toList(jsonArray));
+        }
+
+        return null;
+    }
+
+    public static LocationTemplate fromJSONString(String jsonString) throws JSONException {
+        if (jsonString == null) {
+            return null;
+        }
+        Object json = new JSONTokener(jsonString).nextValue();
+        return fromJSON(json);
+    }
+
+    public static LocationTemplate fromHashMap(HashMap template) {
+        return new HashMapLocationTemplate(template);
+    }
+
+    public static LocationTemplate fromArrayList(ArrayList template) {
+        return new ArrayListLocationTemplate(template);
+    }
+
+    public static LocationTemplate getDefault() {
+        HashMap attrs = new HashMap<String, String>();
+        attrs.put("provider", "@provider");
+        attrs.put("locationProvider", "@locationProvider");
+        attrs.put("time", "@time");
+        attrs.put("latitude", "@latitude");
+        attrs.put("longitude", "@longitude");
+        attrs.put("accuracy", "@accuracy");
+        attrs.put("altitudeAccuracy", "@altitudeAccuracy");
+        attrs.put("speed", "@speed");
+        attrs.put("altitude", "@altitude");
+        attrs.put("bearing", "@bearing");
+        attrs.put("radius", "@radius");
+        // v4.5.1 — README/CHANGELOG promete que el payload default incluye events/battery/isCharging.
+        // Como Config.getTemplate() siempre cae a este default si no hay postTemplate custom, hay
+        // que añadirlos aquí para que PostLocationTask + BatchManager los serialicen al backend.
+        attrs.put("events", "@events");
+        attrs.put("battery", "@battery");
+        attrs.put("isCharging", "@isCharging");
+        return new HashMapLocationTemplate(attrs);
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/data/LocationTransform.java

@@ -0,0 +1,19 @@
+package com.marianhello.bgloc.data;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public interface LocationTransform
+{
+    /**
+     * Return a <code>BackgroundLocation</code>, either a new one or the same one after modification.
+     * Return <code>null</code> to prevent this location from being committed.
+     * @param context
+     * @param location - the input location
+     * @return the location that you want to actually commit
+     */
+
+    @Nullable
+    BackgroundLocation transformLocationBeforeCommit(@NonNull Context context, @NonNull BackgroundLocation location);
+}

package/android/src/main/java/com/marianhello/bgloc/data/SessionLocationDAO.java

@@ -0,0 +1,18 @@
+package com.marianhello.bgloc.data;
+
+import java.util.Collection;
+
+/**
+ * DAO for the current recording session locations.
+ * Session is independent of sync: locations are kept until startSession() or clearSession().
+ */
+public interface SessionLocationDAO {
+    /** Clear session table and set session active. Call when user starts a route. */
+    void startSession();
+    /** Clear session table and set session inactive. Call when route is finished and sync OK. */
+    void clearSession();
+    boolean isSessionActive();
+    void persistSessionLocation(BackgroundLocation location);
+    Collection<BackgroundLocation> getSessionLocations();
+    int getSessionLocationsCount();
+}