@josuelmm/cordova-background-geolocation 3.2.0 → 4.2.2

package/android/common/src/main/java/com/marianhello/bgloc/Config.java

@@ -24,6 +24,7 @@ import org.json.JSONObject;
 
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Locale;
 
 /**
  * Config class
@@ -71,6 +72,39 @@ public class Config implements Parcelable
     private Boolean enableWatchdog;
     private Boolean showTime;
     private Boolean showDistance;
+    // v3.3 (Phase 2): backend-agnostic HTTP transport
+    private String httpMethod;       // POST | GET | PUT | PATCH (default POST)
+    private String syncHttpMethod;   // POST | GET | PUT | PATCH (default POST)
+    private String httpMode;         // batch | single (default batch)
+    private String syncMode;         // batch | single (default batch)
+    private HashMap queryParams;     // static placeholder values for URL templating
+    // v3.5 (Phase 4): diagnostics
+    private Integer heartbeatInterval;    // ms; 0 disables heartbeat events
+    private String mockLocationPolicy;    // allow | flag | drop (default allow)
+    // v4.0 (Phase 6): driver insights
+    private DrivingEventsOptions drivingEvents;
+
+    /** v4.0 Phase 6 + v4.1: driver-insights configuration. Plain holder; no Parcelable to keep this class diff small. */
+    public static class DrivingEventsOptions {
+        public boolean enabled = false;
+        public double speedLimitKmh = 0;
+        public double minMovingSpeedMps = 1.0;
+        public long stoppedDurationMs = 60_000L;
+        public double minTripSpeedMps = 3.0;
+        public long minTripDurationMs = 30_000L;
+        // v4.1 GPS-derived sensor-like events. 0 disables each one.
+        public double hardBrakeMps2 = 3.5;
+        public double rapidAccelMps2 = 3.5;
+        public double sharpTurnDegPerSec = 30;
+        public double crashImpactKmh = 25;
+        public long   crashWindowMs = 2_000L;
+        // v4.2 sensor fusion (real accelerometer + gyroscope).
+        public boolean sensorFusion = false;
+        public double  crashImpactG = 3.0;          // |a| threshold for sensor crash, in g
+        public long    sensorCrashCooldownMs = 10_000L;
+        public long    phoneUsageWindowMs = 4_000L;
+        public long    phoneUsageCooldownMs = 60_000L;
+    }
 
     public Config () {
     }
@@ -108,6 +142,33 @@ public class Config implements Parcelable
         this.enableWatchdog = config.enableWatchdog;
         this.showTime = config.showTime;
         this.showDistance = config.showDistance;
+        this.httpMethod = config.httpMethod;
+        this.syncHttpMethod = config.syncHttpMethod;
+        this.httpMode = config.httpMode;
+        this.syncMode = config.syncMode;
+        this.queryParams = CloneHelper.deepCopy(config.queryParams);
+        this.heartbeatInterval = config.heartbeatInterval;
+        this.mockLocationPolicy = config.mockLocationPolicy;
+        if (config.drivingEvents != null) {
+            DrivingEventsOptions de = new DrivingEventsOptions();
+            de.enabled            = config.drivingEvents.enabled;
+            de.speedLimitKmh      = config.drivingEvents.speedLimitKmh;
+            de.minMovingSpeedMps  = config.drivingEvents.minMovingSpeedMps;
+            de.stoppedDurationMs  = config.drivingEvents.stoppedDurationMs;
+            de.minTripSpeedMps    = config.drivingEvents.minTripSpeedMps;
+            de.minTripDurationMs  = config.drivingEvents.minTripDurationMs;
+            de.hardBrakeMps2      = config.drivingEvents.hardBrakeMps2;
+            de.rapidAccelMps2     = config.drivingEvents.rapidAccelMps2;
+            de.sharpTurnDegPerSec = config.drivingEvents.sharpTurnDegPerSec;
+            de.crashImpactKmh     = config.drivingEvents.crashImpactKmh;
+            de.crashWindowMs      = config.drivingEvents.crashWindowMs;
+            de.sensorFusion          = config.drivingEvents.sensorFusion;
+            de.crashImpactG          = config.drivingEvents.crashImpactG;
+            de.sensorCrashCooldownMs = config.drivingEvents.sensorCrashCooldownMs;
+            de.phoneUsageWindowMs    = config.drivingEvents.phoneUsageWindowMs;
+            de.phoneUsageCooldownMs  = config.drivingEvents.phoneUsageCooldownMs;
+            this.drivingEvents = de;
+        }
         if (config.template instanceof AbstractLocationTemplate) {
             this.template = ((AbstractLocationTemplate)config.template).clone();
         }
@@ -144,8 +205,55 @@ public class Config implements Parcelable
         setEnableWatchdog((Boolean) in.readValue(null));
         setShowTime((Boolean) in.readValue(null));
         setShowDistance((Boolean) in.readValue(null));
+        setHttpMethod(in.readString());
+        setSyncHttpMethod(in.readString());
+        setHttpMode(in.readString());
+        setSyncMode(in.readString());
+        setHeartbeatInterval((Integer) in.readValue(null));
+        setMockLocationPolicy(in.readString());
+        // v4.0 + v4.1: driver-insights options serialised as primitives.
+        boolean deEnabled = in.readInt() != 0;
+        double deSpeedLimit = in.readDouble();
+        double deMinMove = in.readDouble();
+        long   deStoppedDur = in.readLong();
+        double deMinTrip = in.readDouble();
+        long   deMinTripDur = in.readLong();
+        // v4.1
+        double deHardBrake = in.readDouble();
+        double deRapidAccel = in.readDouble();
+        double deSharpTurn = in.readDouble();
+        double deCrashKmh = in.readDouble();
+        long   deCrashWin = in.readLong();
+        // v4.2 sensor fusion
+        boolean deSensorFusion = in.readInt() != 0;
+        double  deCrashImpactG = in.readDouble();
+        long    deSensorCrashCooldown = in.readLong();
+        long    dePhoneUsageWindow = in.readLong();
+        long    dePhoneUsageCooldown = in.readLong();
+        boolean deHasOptions = in.readInt() != 0;
+        if (deHasOptions) {
+            DrivingEventsOptions de = new DrivingEventsOptions();
+            de.enabled = deEnabled;
+            de.speedLimitKmh = deSpeedLimit;
+            de.minMovingSpeedMps = deMinMove;
+            de.stoppedDurationMs = deStoppedDur;
+            de.minTripSpeedMps = deMinTrip;
+            de.minTripDurationMs = deMinTripDur;
+            de.hardBrakeMps2 = deHardBrake;
+            de.rapidAccelMps2 = deRapidAccel;
+            de.sharpTurnDegPerSec = deSharpTurn;
+            de.crashImpactKmh = deCrashKmh;
+            de.crashWindowMs = deCrashWin;
+            de.sensorFusion = deSensorFusion;
+            de.crashImpactG = deCrashImpactG;
+            de.sensorCrashCooldownMs = deSensorCrashCooldown;
+            de.phoneUsageWindowMs = dePhoneUsageWindow;
+            de.phoneUsageCooldownMs = dePhoneUsageCooldown;
+            this.drivingEvents = de;
+        }
         Bundle bundle = in.readBundle();
         setHttpHeaders((HashMap<String, String>) bundle.getSerializable("httpHeaders"));
+        setQueryParams((HashMap<String, String>) bundle.getSerializable("queryParams"));
         setTemplate((LocationTemplate) bundle.getSerializable(AbstractLocationTemplate.BUNDLE_KEY));
     }
 
@@ -183,6 +291,13 @@ public class Config implements Parcelable
         config.enableWatchdog = false;
         config.showTime = false;
         config.showDistance = false;
+        config.httpMethod = "POST";
+        config.syncHttpMethod = "POST";
+        config.httpMode = "batch";
+        config.syncMode = "batch";
+        config.queryParams = null;
+        config.heartbeatInterval = 0;
+        config.mockLocationPolicy = "allow";
 
         return config;
     }
@@ -223,8 +338,36 @@ public class Config implements Parcelable
         out.writeValue(getEnableWatchdog());
         out.writeValue(getShowTime());
         out.writeValue(getShowDistance());
+        out.writeString(getHttpMethod());
+        out.writeString(getSyncHttpMethod());
+        out.writeString(getHttpMode());
+        out.writeString(getSyncMode());
+        out.writeValue(getHeartbeatInterval());
+        out.writeString(getMockLocationPolicy());
+        // v4.0 + v4.1: drivingEvents primitives (always written; "hasOptions" flag at end).
+        DrivingEventsOptions de = drivingEvents;
+        out.writeInt(de != null && de.enabled ? 1 : 0);
+        out.writeDouble(de != null ? de.speedLimitKmh     : 0.0);
+        out.writeDouble(de != null ? de.minMovingSpeedMps : 1.0);
+        out.writeLong  (de != null ? de.stoppedDurationMs : 60_000L);
+        out.writeDouble(de != null ? de.minTripSpeedMps   : 3.0);
+        out.writeLong  (de != null ? de.minTripDurationMs : 30_000L);
+        // v4.1
+        out.writeDouble(de != null ? de.hardBrakeMps2     : 3.5);
+        out.writeDouble(de != null ? de.rapidAccelMps2    : 3.5);
+        out.writeDouble(de != null ? de.sharpTurnDegPerSec: 30.0);
+        out.writeDouble(de != null ? de.crashImpactKmh    : 25.0);
+        out.writeLong  (de != null ? de.crashWindowMs     : 2_000L);
+        // v4.2 sensor fusion
+        out.writeInt   (de != null && de.sensorFusion ? 1 : 0);
+        out.writeDouble(de != null ? de.crashImpactG          : 3.0);
+        out.writeLong  (de != null ? de.sensorCrashCooldownMs : 10_000L);
+        out.writeLong  (de != null ? de.phoneUsageWindowMs    : 4_000L);
+        out.writeLong  (de != null ? de.phoneUsageCooldownMs  : 60_000L);
+        out.writeInt   (de != null ? 1 : 0);
         Bundle bundle = new Bundle();
         bundle.putSerializable("httpHeaders", getHttpHeaders());
+        bundle.putSerializable("queryParams", getQueryParams());
         bundle.putSerializable(AbstractLocationTemplate.BUNDLE_KEY, (AbstractLocationTemplate) getTemplate());
         out.writeBundle(bundle);
     }
@@ -645,6 +788,102 @@ public class Config implements Parcelable
         this.showDistance = showDistance;
     }
 
+    /** HTTP method for the main `url`. Default POST. */
+    @Nullable
+    public String getHttpMethod() {
+        return httpMethod != null ? httpMethod : "POST";
+    }
+
+    public void setHttpMethod(@Nullable String httpMethod) {
+        this.httpMethod = (httpMethod == null || httpMethod.isEmpty()) ? null : httpMethod.toUpperCase(Locale.US);
+    }
+
+    /** HTTP method for the `syncUrl`. Default POST. */
+    @Nullable
+    public String getSyncHttpMethod() {
+        return syncHttpMethod != null ? syncHttpMethod : "POST";
+    }
+
+    public void setSyncHttpMethod(@Nullable String syncHttpMethod) {
+        this.syncHttpMethod = (syncHttpMethod == null || syncHttpMethod.isEmpty()) ? null : syncHttpMethod.toUpperCase(Locale.US);
+    }
+
+    /** Real-time post mode. "batch" (default) or "single". */
+    @Nullable
+    public String getHttpMode() {
+        return httpMode != null ? httpMode : "batch";
+    }
+
+    public void setHttpMode(@Nullable String httpMode) {
+        this.httpMode = (httpMode == null || httpMode.isEmpty()) ? null : httpMode.toLowerCase(Locale.US);
+    }
+
+    /** Sync queue mode. "batch" (default) or "single". */
+    @Nullable
+    public String getSyncMode() {
+        return syncMode != null ? syncMode : "batch";
+    }
+
+    public void setSyncMode(@Nullable String syncMode) {
+        this.syncMode = (syncMode == null || syncMode.isEmpty()) ? null : syncMode.toLowerCase(Locale.US);
+    }
+
+    public boolean hasQueryParams() {
+        return queryParams != null && !queryParams.isEmpty();
+    }
+
+    public HashMap<String, String> getQueryParams() {
+        return queryParams;
+    }
+
+    public void setQueryParams(HashMap queryParams) {
+        this.queryParams = queryParams;
+    }
+
+    public void setQueryParams(JSONObject queryParams) throws JSONException {
+        this.queryParams = new HashMap<String, String>();
+        if (queryParams == null) return;
+        Iterator<?> it = queryParams.keys();
+        while (it.hasNext()) {
+            String key = (String) it.next();
+            // queryParams accepts string | number (per d.ts). Convert numbers to string.
+            Object value = queryParams.get(key);
+            this.queryParams.put(key, value == null || value == JSONObject.NULL ? "" : String.valueOf(value));
+        }
+    }
+
+    /** Heartbeat emit interval in ms. 0 disables. */
+    @Nullable
+    public Integer getHeartbeatInterval() {
+        return heartbeatInterval != null ? heartbeatInterval : 0;
+    }
+
+    public void setHeartbeatInterval(Integer heartbeatInterval) {
+        this.heartbeatInterval = heartbeatInterval;
+    }
+
+    /** Mock location policy: "allow" | "flag" | "drop". Default "allow". */
+    @Nullable
+    public String getMockLocationPolicy() {
+        return mockLocationPolicy != null ? mockLocationPolicy : "allow";
+    }
+
+    public void setMockLocationPolicy(@Nullable String mockLocationPolicy) {
+        this.mockLocationPolicy = (mockLocationPolicy == null || mockLocationPolicy.isEmpty())
+                ? null
+                : mockLocationPolicy.toLowerCase(Locale.US);
+    }
+
+    /** v4.0 Phase 6: driver-insights options. */
+    @Nullable
+    public DrivingEventsOptions getDrivingEvents() {
+        return drivingEvents;
+    }
+
+    public void setDrivingEvents(@Nullable DrivingEventsOptions drivingEvents) {
+        this.drivingEvents = drivingEvents;
+    }
+
     @Override
     public String toString () {
         return new StringBuffer()
@@ -675,6 +914,11 @@ public class Config implements Parcelable
                 .append(" postTemplate=").append(hasTemplate() ? getTemplate().toString() : null)
                 .append(" showTime=").append(getShowTime())
                 .append(" showDistance=").append(getShowDistance())
+                .append(" httpMethod=").append(getHttpMethod())
+                .append(" syncHttpMethod=").append(getSyncHttpMethod())
+                .append(" httpMode=").append(getHttpMode())
+                .append(" syncMode=").append(getSyncMode())
+                .append(" queryParams=").append(hasQueryParams() ? getQueryParams().toString() : null)
                 .append("]")
                 .toString();
     }
@@ -788,6 +1032,30 @@ public class Config implements Parcelable
         if (config2.hasShowDistance()) {
             merger.setShowDistance(config2.getShowDistance());
         }
+        if (config2.httpMethod != null) {
+            merger.setHttpMethod(config2.getHttpMethod());
+        }
+        if (config2.syncHttpMethod != null) {
+            merger.setSyncHttpMethod(config2.getSyncHttpMethod());
+        }
+        if (config2.httpMode != null) {
+            merger.setHttpMode(config2.getHttpMode());
+        }
+        if (config2.syncMode != null) {
+            merger.setSyncMode(config2.getSyncMode());
+        }
+        if (config2.hasQueryParams()) {
+            merger.setQueryParams(config2.getQueryParams());
+        }
+        if (config2.heartbeatInterval != null) {
+            merger.setHeartbeatInterval(config2.getHeartbeatInterval());
+        }
+        if (config2.mockLocationPolicy != null) {
+            merger.setMockLocationPolicy(config2.getMockLocationPolicy());
+        }
+        if (config2.drivingEvents != null) {
+            merger.setDrivingEvents(config2.drivingEvents);
+        }
 
         return merger;
     }

package/android/common/src/main/java/com/marianhello/bgloc/HttpPostService.java

@@ -21,7 +21,6 @@ import org.json.JSONTokener;
 
 import java.net.URL;
 import java.net.HttpURLConnection;
-import java.io.OutputStreamWriter;
 import java.net.URLEncoder;
 
 public class HttpPostService {
@@ -32,6 +31,7 @@ public class HttpPostService {
     private static final int READ_TIMEOUT_MS = 120_000;
 
     private String mUrl;
+    private String mMethod = "POST";
     private HttpURLConnection mHttpURLConnection;
 
     public interface UploadingProgressListener {
@@ -42,10 +42,31 @@ public class HttpPostService {
         mUrl = url;
     }
 
+    public HttpPostService(String url, String method) {
+        mUrl = url;
+        mMethod = normalizeMethod(method);
+    }
+
     public HttpPostService(final HttpURLConnection httpURLConnection) {
         mHttpURLConnection = httpURLConnection;
     }
 
+    public void setMethod(String method) {
+        mMethod = normalizeMethod(method);
+    }
+
+    private static String normalizeMethod(String method) {
+        if (method == null || method.isEmpty()) return "POST";
+        String m = method.trim().toUpperCase();
+        if (m.equals("POST") || m.equals("GET") || m.equals("PUT") || m.equals("PATCH")) return m;
+        return "POST";
+    }
+
+    /** Returns true when the HTTP method has no request body (GET). */
+    private boolean isBodyless() {
+        return "GET".equals(mMethod);
+    }
+
     private HttpURLConnection openConnection() throws IOException {
         if (mHttpURLConnection == null) {
             mHttpURLConnection = (HttpURLConnection) new URL(mUrl).openConnection();
@@ -84,7 +105,7 @@ public class HttpPostService {
         if (headers == null) {
             headers = new HashMap();
         }
-        
+
         String contentType = null;
         for (Object keyObj : headers.keySet()) {
             String key = (String) keyObj;
@@ -96,7 +117,29 @@ public class HttpPostService {
         if (contentType == null) {
             contentType = "application/json";
         }
-        // Prepare body according to Content-Type so header and body always match
+
+        HttpURLConnection conn = this.openConnection();
+        conn.setRequestMethod(mMethod);
+
+        // Set headers (including Content-Type) up-front; needed for both bodyless and body requests.
+        if (!isBodyless()) {
+            conn.setRequestProperty("Content-Type", contentType);
+        }
+        Iterator<Map.Entry<String, String>> it = headers.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<String, String> pair = it.next();
+            if (!pair.getKey().equalsIgnoreCase("Content-Type")) {
+                conn.setRequestProperty(pair.getKey(), pair.getValue());
+            }
+        }
+
+        // GET: no body; data is expected to live in the URL (URL templating).
+        if (isBodyless()) {
+            conn.setDoOutput(false);
+            return conn.getResponseCode();
+        }
+
+        // Prepare body according to Content-Type so header and body always match.
         String finalBody = body;
         if (contentType.equalsIgnoreCase("application/x-www-form-urlencoded")) {
             try {
@@ -105,25 +148,17 @@ public class HttpPostService {
                 finalBody = body;
             }
         }
-        
-        HttpURLConnection conn = this.openConnection();
+
+        // Use byte length, not String.length(), so multi-byte UTF-8 characters
+        // (ñ, é, emoji, ...) match the Content-Length the server expects.
+        byte[] outputBytes = finalBody.getBytes(StandardCharsets.UTF_8);
         conn.setDoOutput(true);
-        conn.setFixedLengthStreamingMode(finalBody.length());
-        conn.setRequestMethod("POST");
-        conn.setRequestProperty("Content-Type", contentType);
-        
-        Iterator<Map.Entry<String, String>> it = headers.entrySet().iterator();
-        while (it.hasNext()) {
-            Map.Entry<String, String> pair = it.next();
-            if (!pair.getKey().equalsIgnoreCase("Content-Type")) {
-                conn.setRequestProperty(pair.getKey(), pair.getValue());
-            }
-        }
-        
-        OutputStreamWriter os = null;
+        conn.setFixedLengthStreamingMode(outputBytes.length);
+
+        java.io.OutputStream os = null;
         try {
-            os = new OutputStreamWriter(conn.getOutputStream());
-            os.write(finalBody);
+            os = conn.getOutputStream();
+            os.write(outputBytes);
         } finally {
             if (os != null) {
                 os.flush();
@@ -251,6 +286,20 @@ public class HttpPostService {
         }
 
         HttpURLConnection conn = this.openConnection();
+        conn.setRequestMethod(mMethod);
+        if (isBodyless()) {
+            conn.setDoOutput(false);
+            // No headers loop / body for GET; we just consume the response.
+            Iterator<Map.Entry<String, String>> hit = headers.entrySet().iterator();
+            while (hit.hasNext()) {
+                Map.Entry<String, String> pair = hit.next();
+                if (!pair.getKey().equalsIgnoreCase("Content-Type")) {
+                    conn.setRequestProperty(pair.getKey(), pair.getValue());
+                }
+            }
+            if (listener != null) listener.onProgress(100);
+            return conn.getResponseCode();
+        }
         conn.setDoInput(false);
         conn.setDoOutput(true);
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
@@ -258,7 +307,6 @@ public class HttpPostService {
         } else {
             conn.setChunkedStreamingMode(0);
         }
-        conn.setRequestMethod("POST");
         conn.setRequestProperty("Content-Type", contentType);
         Iterator<Map.Entry<String, String>> it = headers.entrySet().iterator();
         while (it.hasNext()) {
@@ -286,17 +334,29 @@ public class HttpPostService {
     }
 
     public static int postJSON(String url, JSONObject json, Map headers) throws IOException {
-        HttpPostService service = new HttpPostService(url);
-        return service.postJSON(json, headers);
+        return postJSON(url, json, headers, "POST");
     }
 
     public static int postJSON(String url, JSONArray json, Map headers) throws IOException {
-        HttpPostService service = new HttpPostService(url);
-        return service.postJSON(json, headers);
+        return postJSON(url, json, headers, "POST");
     }
 
     public static int postJSONFile(String url, File file, Map headers, UploadingProgressListener listener) throws IOException {
-        HttpPostService service = new HttpPostService(url);
+        return postJSONFile(url, file, headers, listener, "POST");
+    }
+
+    public static int postJSON(String url, JSONObject json, Map headers, String method) throws IOException {
+        HttpPostService service = new HttpPostService(url, method);
+        return service.postJSON(json, headers);
+    }
+
+    public static int postJSON(String url, JSONArray json, Map headers, String method) throws IOException {
+        HttpPostService service = new HttpPostService(url, method);
+        return service.postJSON(json, headers);
+    }
+
+    public static int postJSONFile(String url, File file, Map headers, UploadingProgressListener listener, String method) throws IOException {
+        HttpPostService service = new HttpPostService(url, method);
         return service.postJSONFile(file, headers, listener);
     }
 }

package/android/common/src/main/java/com/marianhello/bgloc/PluginDelegate.java

@@ -16,4 +16,30 @@ public interface PluginDelegate {
     void onAbortRequested();
     void onHttpAuthorization();
     void onError(PluginException error);
+    /** v3.5 Phase 4: sync queue events. Default no-op so existing implementations keep compiling. */
+    default void onSyncStart() {}
+    default void onSyncSuccess(int locationsSent) {}
+    default void onSyncError(int httpStatus, String message) {}
+    default void onSyncProgress(int progress) {}
+    default void onHeartbeat(BackgroundLocation location) {}
+    // v4.0 Phase 6: driver insights
+    default void onTripStart(BackgroundLocation location) {}
+    default void onTripEnd(BackgroundLocation location, double distance, long durationMs) {}
+    default void onMoving(BackgroundLocation location) {}
+    default void onStopped(BackgroundLocation location) {}
+    default void onSpeeding(BackgroundLocation location, double speedKmh, double limitKmh) {}
+    default void onProviderChange(String provider) {}
+    default void onSOS(BackgroundLocation location, org.json.JSONObject payload) {}
+    // v4.1 GPS-derived sensor-like events
+    default void onHardBrake(BackgroundLocation location, double decelMps2) {}
+    default void onRapidAcceleration(BackgroundLocation location, double accelMps2) {}
+    default void onSharpTurn(BackgroundLocation location, double degPerSec) {}
+    default void onPossibleCrash(BackgroundLocation location, double velocityDropKmh) {}
+    /** v4.2: same event, but enriched with the source ("gps" | "sensor") and impact value. */
+    default void onPossibleCrash(BackgroundLocation location, double value, String source) {
+        // Backward-compat default: forward to the legacy 2-arg overload.
+        onPossibleCrash(location, value);
+    }
+    /** v4.2 sensor fusion: emitted when device interaction is detected during an active trip. */
+    default void onPhoneUsageWhileDriving(BackgroundLocation location) {}
 }

package/android/common/src/main/java/com/marianhello/bgloc/PostLocationTask.java

@@ -3,10 +3,12 @@ package com.marianhello.bgloc;
 import com.marianhello.bgloc.data.BackgroundLocation;
 import com.marianhello.bgloc.data.LocationDAO;
 import com.marianhello.bgloc.data.SessionLocationDAO;
+import com.marianhello.bgloc.http.UrlTemplateResolver;
 import com.marianhello.logging.LoggerManager;
 
 import org.json.JSONArray;
 import org.json.JSONException;
+import org.json.JSONObject;
 
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -90,6 +92,18 @@ public class PostLocationTask {
             return;
         }
 
+        // v3.5 Phase 4: mock location policy. Detection is already in BackgroundLocation
+        // (isFromMockProvider). Here we apply the policy.
+        if (location != null && location.isFromMockProvider()) {
+            String policy = mConfig.getMockLocationPolicy(); // "allow" | "flag" | "drop"
+            if ("drop".equals(policy)) {
+                logger.info("Mock location dropped (mockLocationPolicy=drop)");
+                return;
+            }
+            // "flag": leave it but caller can read isFromMockProvider() / mocked field.
+            // "allow": no-op.
+        }
+
         long locationId = mLocationDAO.persistLocation(location);
         location.setLocationId(locationId);
 
@@ -153,21 +167,44 @@ public class PostLocationTask {
 
     private boolean postLocation(BackgroundLocation location) {
         logger.debug("Executing PostLocationTask#postLocation");
-        JSONArray jsonLocations = new JSONArray();
 
+        // LocationTemplate.locationToJson returns Object (JSONObject for HashMapLocationTemplate,
+        // JSONArray for ArrayListLocationTemplate). Resolve to the concrete type before calling
+        // the matching HttpPostService.postJSON overload.
+        Object jsonLocation;
         try {
-            jsonLocations.put(mConfig.getTemplate().locationToJson(location));
+            jsonLocation = mConfig.getTemplate().locationToJson(location);
         } catch (JSONException e) {
             logger.warn("Location to json failed: {}", location.toString());
             return false;
         }
 
-        String url = mConfig.getUrl();
-        logger.debug("Posting json to url: {} headers: {}", url, mConfig.getHttpHeaders());
+        String urlTemplate = mConfig.getUrl();
+        // URL templating: substitute {lat}, {lon}, {timestamp_iso}, {device_id}, ... using the
+        // current location plus any static queryParams. For "single" mode this is per-location;
+        // for "batch" mode only static queryParams placeholders apply (location-derived ones
+        // would not make sense for an array).
+        String resolvedUrl = UrlTemplateResolver.resolve(urlTemplate, location, mConfig.getQueryParams());
+
+        String method = mConfig.getHttpMethod();
+        String mode = mConfig.getHttpMode();
+        logger.debug("Posting to url: {} method: {} mode: {} headers: {}",
+                resolvedUrl, method, mConfig.getHttpHeaders());
         int responseCode;
 
         try {
-            responseCode = HttpPostService.postJSON(url, jsonLocations, mConfig.getHttpHeaders());
+            if ("single".equals(mode) || "GET".equals(method)) {
+                // GET cannot carry a JSON array body; force per-location request.
+                if (jsonLocation instanceof JSONArray) {
+                    responseCode = HttpPostService.postJSON(resolvedUrl, (JSONArray) jsonLocation, mConfig.getHttpHeaders(), method);
+                } else {
+                    responseCode = HttpPostService.postJSON(resolvedUrl, (JSONObject) jsonLocation, mConfig.getHttpHeaders(), method);
+                }
+            } else {
+                JSONArray jsonLocations = new JSONArray();
+                jsonLocations.put(jsonLocation);
+                responseCode = HttpPostService.postJSON(resolvedUrl, jsonLocations, mConfig.getHttpHeaders(), method);
+            }
         } catch (Exception e) {
             mHasConnectivity = mConnectivityListener.hasConnectivity();
             logger.warn("Error while posting locations: {}", e.getMessage());