@josuelmm/capacitor-background-geolocation 1.0.0

package/android/src/main/java/com/marianhello/bgloc/ConnectivityListener.java

@@ -0,0 +1,5 @@
+package com.marianhello.bgloc;
+
+public interface ConnectivityListener {
+    boolean hasConnectivity();
+}

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

@@ -0,0 +1,362 @@
+package com.marianhello.bgloc;
+
+import android.os.Build;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Iterator;
+
+import org.json.JSONTokener;
+
+import java.net.URL;
+import java.net.HttpURLConnection;
+import java.net.URLEncoder;
+
+public class HttpPostService {
+    public static final int BUFFER_SIZE = 1024;
+    /** Timeout to establish connection (ms). Prevents sync notification from staying stuck. */
+    private static final int CONNECT_TIMEOUT_MS = 30_000;
+    /** Timeout to read response (ms). Prevents sync notification from staying stuck. */
+    private static final int READ_TIMEOUT_MS = 120_000;
+
+    private String mUrl;
+    private String mMethod = "POST";
+    private HttpURLConnection mHttpURLConnection;
+
+    public interface UploadingProgressListener {
+        void onProgress(int progress);
+    }
+
+    public HttpPostService(String url) {
+        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();
+            mHttpURLConnection.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            mHttpURLConnection.setReadTimeout(READ_TIMEOUT_MS);
+        }
+        return mHttpURLConnection;
+    }
+
+    public int postJSON(JSONObject json, Map headers) throws IOException {
+        String jsonString = "null";
+        if (json != null) {
+            jsonString = json.toString();
+        }
+        return postJSONString(jsonString, headers);
+    }
+
+    public int postJSON(JSONArray json, Map headers) throws IOException {
+        String jsonString = "null";
+        if (json != null) {
+            if (json.length() == 1) {
+                JSONObject single = json.optJSONObject(0);
+                if (single != null) {
+                    jsonString = single.toString();
+                } else {
+                    jsonString = json.toString();
+                }
+            } else {
+                jsonString = json.toString();
+            }
+        }
+        return postJSONString(jsonString, headers);
+    }
+
+    public int postJSONString(String body, Map headers) throws IOException {
+        if (headers == null) {
+            headers = new HashMap();
+        }
+
+        String contentType = null;
+        for (Object keyObj : headers.keySet()) {
+            String key = (String) keyObj;
+            if (key.equalsIgnoreCase("Content-Type")) {
+                contentType = (String) headers.get(key);
+                break;
+            }
+        }
+        if (contentType == null) {
+            contentType = "application/json";
+        }
+
+        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 {
+                finalBody = jsonToUrlEncoded(body);
+            } catch (Exception e) {
+                finalBody = body;
+            }
+        }
+
+        // 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(outputBytes.length);
+
+        java.io.OutputStream os = null;
+        try {
+            os = conn.getOutputStream();
+            os.write(outputBytes);
+        } finally {
+            if (os != null) {
+                os.flush();
+                os.close();
+            }
+        }
+        return conn.getResponseCode();
+    }
+    
+    private static String getContentTypeFromHeaders(Map headers) {
+        if (headers == null) return null;
+        for (Object keyObj : headers.keySet()) {
+            String key = (String) keyObj;
+            if (key != null && key.equalsIgnoreCase("Content-Type")) {
+                return (String) headers.get(key);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Converts JSON string (object or array) to application/x-www-form-urlencoded.
+     * Object: flat key=value&key2=value2. Array: single key "locations" with URL-encoded JSON array.
+     */
+    private String jsonToUrlEncoded(String jsonString) throws Exception {
+        Object json = new JSONTokener(jsonString).nextValue();
+        if (json instanceof JSONArray) {
+            return "locations=" + URLEncoder.encode(jsonString, StandardCharsets.UTF_8.name());
+        }
+        JSONObject jsonObj = (JSONObject) json;
+        StringBuilder result = new StringBuilder();
+        Iterator<String> keys = jsonObj.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            String value = jsonObj.get(key).toString();
+            if (result.length() > 0) {
+                result.append("&");
+            }
+            result.append(URLEncoder.encode(key, StandardCharsets.UTF_8.name()));
+            result.append("=");
+            result.append(URLEncoder.encode(value, StandardCharsets.UTF_8.name()));
+        }
+        return result.toString();
+    }
+
+    public int postJSONFile(File file, Map headers, UploadingProgressListener listener) throws IOException {
+        long fileSize = file.length();
+        return postJSONFile(new FileInputStream(file), fileSize, headers, listener);
+    }
+
+    public int postJSONFile(InputStream stream, Map headers, UploadingProgressListener listener) throws IOException {
+        return postJSONFile(stream, stream.available(), headers, listener);
+    }
+
+    public int postJSONFile(InputStream stream, long streamSize, Map headers, UploadingProgressListener listener) throws IOException {
+        if (headers == null) {
+            headers = new HashMap();
+        }
+        String contentType = getContentTypeFromHeaders(headers);
+        if (contentType == null) {
+            contentType = "application/json";
+        }
+        final boolean isFormUrlEncoded = contentType.equalsIgnoreCase("application/x-www-form-urlencoded");
+        // Prepare body according to Content-Type (same as post to url): form body when form-urlencoded, else JSON
+        // Read full body so we can convert when needed
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        byte[] buffer = new byte[BUFFER_SIZE];
+        int bytesRead;
+        long progress = 0;
+        while ((bytesRead = stream.read(buffer)) != -1) {
+            baos.write(buffer, 0, bytesRead);
+            progress += bytesRead;
+            if (listener != null && streamSize > 0) {
+                int percentage = (int) ((progress * 100L) / streamSize);
+                listener.onProgress(percentage);
+            }
+        }
+        stream.close();
+        byte[] bodyBytes = baos.toByteArray();
+        String jsonString = new String(bodyBytes, StandardCharsets.UTF_8);
+
+        // When form-urlencoded and body is a JSON array, send one POST per location (same flat
+        // format as real-time posting) so the same server endpoint accepts both.
+        if (isFormUrlEncoded) {
+            try {
+                Object parsed = new JSONTokener(jsonString).nextValue();
+                if (parsed instanceof JSONArray) {
+                    JSONArray arr = (JSONArray) parsed;
+                    int len = arr.length();
+                    if (len == 0) {
+                        if (listener != null) listener.onProgress(100);
+                        return 200;
+                    }
+                    for (int i = 0; i < len; i++) {
+                        JSONObject item = arr.getJSONObject(i);
+                        HttpPostService perRequest = new HttpPostService(mUrl);
+                        int code = perRequest.postJSON(item, headers);
+                        if (listener != null && len > 0) {
+                            listener.onProgress((i + 1) * 100 / len);
+                        }
+                        if (code < 200 || code >= 300) {
+                            return code;
+                        }
+                    }
+                    if (listener != null) {
+                        listener.onProgress(100);
+                    }
+                    return 200;
+                }
+            } catch (Exception e) {
+                // Fall through to single-POST with jsonToUrlEncoded (e.g. array wrap)
+            }
+        }
+
+        byte[] outputBytes;
+        if (isFormUrlEncoded) {
+            try {
+                String formBody = jsonToUrlEncoded(jsonString);
+                outputBytes = formBody.getBytes(StandardCharsets.UTF_8);
+            } catch (Exception e) {
+                outputBytes = bodyBytes;
+            }
+        } else {
+            outputBytes = bodyBytes;
+        }
+
+        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) {
+            conn.setFixedLengthStreamingMode(outputBytes.length);
+        } else {
+            conn.setChunkedStreamingMode(0);
+        }
+        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());
+            }
+        }
+
+        BufferedOutputStream os = null;
+        try {
+            os = new BufferedOutputStream(conn.getOutputStream());
+            os.write(outputBytes);
+            if (listener != null) {
+                listener.onProgress(100);
+            }
+        } finally {
+            if (os != null) {
+                os.flush();
+                os.close();
+            }
+        }
+
+        return conn.getResponseCode();
+    }
+
+    public static int postJSON(String url, JSONObject json, Map headers) throws IOException {
+        return postJSON(url, json, headers, "POST");
+    }
+
+    public static int postJSON(String url, JSONArray json, Map headers) throws IOException {
+        return postJSON(url, json, headers, "POST");
+    }
+
+    public static int postJSONFile(String url, File file, Map headers, UploadingProgressListener listener) throws IOException {
+        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/src/main/java/com/marianhello/bgloc/LocationManager.java

@@ -0,0 +1,138 @@
+package com.marianhello.bgloc;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.location.Criteria;
+import android.location.Location;
+import android.location.LocationListener;
+import android.os.Bundle;
+import android.os.Looper;
+
+import com.github.jparkie.promise.Promise;
+import com.github.jparkie.promise.Promises;
+import com.intentfilter.androidpermissions.PermissionManager;
+import com.intentfilter.androidpermissions.models.DeniedPermissions;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class LocationManager {
+    private Context mContext;
+    private static LocationManager mLocationManager;
+
+    public static final String[] PERMISSIONS = {
+            Manifest.permission.ACCESS_COARSE_LOCATION,
+            Manifest.permission.ACCESS_FINE_LOCATION
+    };
+
+    private LocationManager(Context context) {
+        mContext = context;
+    }
+
+    public class PermissionDeniedException extends Exception {}
+
+    public static LocationManager getInstance(Context context) {
+        if (mLocationManager == null) {
+            mLocationManager = new LocationManager(context.getApplicationContext());
+        }
+        return mLocationManager;
+    }
+
+    public Promise<Location> getCurrentLocation(final int timeout, final long maximumAge, final boolean enableHighAccuracy) {
+        final Promise<Location> promise = Promises.promise();
+
+        PermissionManager permissionManager = PermissionManager.getInstance(mContext);
+        permissionManager.checkPermissions(Arrays.asList(PERMISSIONS), new PermissionManager.PermissionRequestListener() {
+            @Override
+            public void onPermissionGranted() {
+                try {
+                    Location currentLocation = getCurrentLocationNoCheck(timeout, maximumAge, enableHighAccuracy);
+                    promise.set(currentLocation);
+                } catch (TimeoutException e) {
+                    promise.setError(e);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+
+            @Override
+            public void onPermissionDenied(DeniedPermissions deniedPermissions) {
+                promise.setError(new PermissionDeniedException());
+            }
+        });
+
+        return promise;
+    }
+
+    /**
+     * Get current location without permission checking
+     *
+     * @param timeout
+     * @param maximumAge
+     * @param enableHighAccuracy
+     * @return
+     * @throws InterruptedException
+     * @throws TimeoutException
+     */
+    @SuppressLint("MissingPermission")
+    public Location getCurrentLocationNoCheck(int timeout, long maximumAge, boolean enableHighAccuracy) throws InterruptedException, TimeoutException {
+        final long minLocationTime = System.currentTimeMillis() - maximumAge;
+        final android.location.LocationManager locationManager = (android.location.LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
+
+        Location lastKnownGPSLocation = locationManager.getLastKnownLocation(android.location.LocationManager.GPS_PROVIDER);
+        if (lastKnownGPSLocation != null && lastKnownGPSLocation.getTime() >= minLocationTime) {
+            return lastKnownGPSLocation;
+        }
+
+        Location lastKnownNetworkLocation = locationManager.getLastKnownLocation(android.location.LocationManager.NETWORK_PROVIDER);
+        if (lastKnownNetworkLocation != null && lastKnownNetworkLocation.getTime() >= minLocationTime) {
+            return lastKnownNetworkLocation;
+        }
+
+        Criteria criteria = new Criteria();
+        criteria.setAccuracy(enableHighAccuracy ? Criteria.ACCURACY_FINE : Criteria.ACCURACY_COARSE);
+
+        CurrentLocationListener locationListener = new CurrentLocationListener();
+        locationManager.requestSingleUpdate(criteria, locationListener, Looper.getMainLooper());
+
+        if (!locationListener.mCountDownLatch.await(timeout, TimeUnit.MILLISECONDS)) {
+            locationManager.removeUpdates(locationListener);
+            throw new TimeoutException();
+        }
+
+        if (locationListener.mLocation != null) {
+            return locationListener.mLocation;
+        }
+
+        return null;
+    }
+
+    static class CurrentLocationListener implements LocationListener {
+        Location mLocation = null;
+        final CountDownLatch mCountDownLatch = new CountDownLatch(1);
+
+        @Override
+        public void onLocationChanged(Location location) {
+            mLocation = location;
+            mCountDownLatch.countDown();
+        }
+
+        @Override
+        public void onStatusChanged(String s, int i, Bundle bundle) {
+
+        }
+
+        @Override
+        public void onProviderEnabled(String s) {
+
+        }
+
+        @Override
+        public void onProviderDisabled(String s) {
+
+        }
+    }
+}

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

@@ -0,0 +1,45 @@
+package com.marianhello.bgloc;
+
+import com.marianhello.bgloc.data.BackgroundActivity;
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+/**
+ * Created by finch on 27.11.2017.
+ */
+
+public interface PluginDelegate {
+    void onAuthorizationChanged(int authStatus);
+    void onLocationChanged(BackgroundLocation location);
+    void onStationaryChanged(BackgroundLocation location);
+    void onActivityChanged(BackgroundActivity activity);
+    void onServiceStatusChanged(int status);
+    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/src/main/java/com/marianhello/bgloc/PluginException.java

@@ -0,0 +1,38 @@
+package com.marianhello.bgloc;
+
+import android.os.Bundle;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class PluginException extends Exception {
+    public static final int PERMISSION_DENIED_ERROR = 1000;
+    public static final int SETTINGS_ERROR = 1001;
+    public static final int CONFIGURE_ERROR = 1002;
+    public static final int SERVICE_ERROR = 1003;
+    public static final int JSON_ERROR = 1004;
+
+    private Integer code;
+
+    public PluginException(String message, Throwable cause, int code) {
+        super(message, cause);
+        this.code = code;
+    }
+
+    public PluginException(String message, int code) {
+        super(message);
+        this.code = code;
+    }
+
+    public Integer getCode() {
+        return code;
+    }
+
+    public Bundle toBundle() {
+        Bundle bundle = new Bundle();
+        bundle.putInt("code", this.code);
+        bundle.putString("message", this.getMessage());
+
+        return bundle;
+    }
+}