@josuelmm/capacitor-background-geolocation 1.0.0

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

@@ -0,0 +1,238 @@
+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;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Location task to post/sync locations from location providers
+ *
+ * All locations updates are recorded in local db at all times.
+ * Also location is also send to all messenger clients.
+ *
+ * If option.url is defined, each location is also immediately posted.
+ * If post is successful, the location is deleted from local db.
+ * All failed to post locations are coalesced and send in some time later in one single batch.
+ * Batch sync takes place only when number of failed to post locations reaches syncTreshold.
+ *
+ * If only option.syncUrl is defined, locations are send only in single batch,
+ * when number of locations reaches syncTreshold.
+ *
+ */
+public class PostLocationTask {
+    private final LocationDAO mLocationDAO;
+    private final SessionLocationDAO mSessionDAO;
+    private final PostLocationTaskListener mTaskListener;
+    private final ConnectivityListener mConnectivityListener;
+
+    private final ExecutorService mExecutor;
+
+    private volatile boolean mHasConnectivity = true;
+    private volatile Config mConfig;
+
+    private org.slf4j.Logger logger;
+
+    public interface PostLocationTaskListener
+    {
+        void onSyncRequested();
+        void onRequestedAbortUpdates();
+        void onHttpAuthorizationUpdates();
+    }
+
+    public PostLocationTask(LocationDAO dao, PostLocationTaskListener taskListener,
+                            ConnectivityListener connectivityListener) {
+        this(dao, null, taskListener, connectivityListener);
+    }
+
+    public PostLocationTask(LocationDAO dao, SessionLocationDAO sessionDAO,
+                            PostLocationTaskListener taskListener,
+                            ConnectivityListener connectivityListener) {
+        logger = LoggerManager.getLogger(PostLocationTask.class);
+        logger.info("Creating PostLocationTask");
+
+        mLocationDAO = dao;
+        mSessionDAO = sessionDAO;
+        mTaskListener = taskListener;
+        mConnectivityListener = connectivityListener;
+
+        mExecutor = Executors.newSingleThreadExecutor();
+    }
+
+    public void setConfig(Config config) {
+        mConfig = config;
+    }
+
+    public void setHasConnectivity(boolean hasConnectivity) {
+        mHasConnectivity = hasConnectivity;
+    }
+
+    public void clearQueue() {
+        mExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                mLocationDAO.deleteUnpostedLocations();
+            }
+        });
+    }
+
+    public void add(final BackgroundLocation location) {
+        if (mConfig == null) {
+            logger.warn("PostLocationTask has no config. Did you called setConfig? Skipping location.");
+            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);
+
+        if (mSessionDAO != null && mSessionDAO.isSessionActive()) {
+            mSessionDAO.persistSessionLocation(location);
+        }
+
+        try {
+            mExecutor.execute(new Runnable() {
+                @Override
+                public void run() {
+                    post(location);
+                }
+            });
+        } catch (RejectedExecutionException ex) {
+            mLocationDAO.updateLocationForSync(locationId);
+        }
+    }
+
+    public void shutdown() {
+        shutdown(60);
+    }
+
+    public void shutdown(int waitSeconds) {
+        mExecutor.shutdown();
+        try {
+            if (!mExecutor.awaitTermination(waitSeconds, TimeUnit.SECONDS)) {
+                mExecutor.shutdownNow();
+                mLocationDAO.deleteUnpostedLocations();
+            }
+        } catch (InterruptedException e) {
+            mExecutor.shutdownNow();
+        }
+    }
+
+    private void post(final BackgroundLocation location) {
+        long locationId = location.getLocationId();
+
+        if (mHasConnectivity && mConfig.hasValidUrl()) {
+            if (postLocation(location)) {
+                mLocationDAO.deleteLocationById(locationId);
+
+                return; // if posted successfully do nothing more
+            } else {
+                mLocationDAO.updateLocationForSync(locationId);
+            }
+        } else {
+            mLocationDAO.updateLocationForSync(locationId);
+        }
+
+        if (mConfig.hasValidSyncUrl()) {
+            Integer configThreshold = mConfig.getSyncThreshold();
+            int threshold = (configThreshold != null) ? configThreshold : 100;
+            long syncLocationsCount = mLocationDAO.getLocationsForSyncCount(System.currentTimeMillis());
+            if (syncLocationsCount >= threshold) {
+                logger.debug("Attempt to sync locations: {} threshold: {}", syncLocationsCount, threshold);
+                mTaskListener.onSyncRequested();
+            }
+        }
+    }
+
+    private boolean postLocation(BackgroundLocation location) {
+        logger.debug("Executing PostLocationTask#postLocation");
+
+        // 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 {
+            jsonLocation = mConfig.getTemplate().locationToJson(location);
+        } catch (JSONException e) {
+            logger.warn("Location to json failed: {}", location.toString());
+            return false;
+        }
+
+        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, mode, mConfig.getHttpHeaders());
+        int responseCode;
+
+        try {
+            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());
+            return false;
+        }
+
+        if (responseCode == 285) {
+            // Okay, but we don't need to continue sending these
+
+            logger.debug("Location was sent to the server, and received an \"HTTP 285 Updates Not Required\"");
+
+            if (mTaskListener != null)
+                mTaskListener.onRequestedAbortUpdates();
+        }
+
+        if (responseCode == 401) {
+            if (mTaskListener != null)
+                mTaskListener.onHttpAuthorizationUpdates();
+        }
+
+        // All 2xx statuses are okay
+        boolean isStatusOkay = responseCode >= 200 && responseCode < 300;
+
+        if (!isStatusOkay) {
+            logger.warn("Server error while posting locations responseCode: {}", responseCode);
+            return false;
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.marianhello.bgloc;
+
+import android.content.Context;
+
+/**
+ * Created by finch on 19/07/16.
+ */
+public class ResourceResolver {
+
+    private static final String RESOURCE_PREFIX = "plugin_bgloc_";
+    private static final String ACCOUNT_NAME_RESOURCE = RESOURCE_PREFIX + "account_name";
+    private static final String ACCOUNT_TYPE_RESOURCE = RESOURCE_PREFIX + "account_type";
+    private static final String AUTHORITY_TYPE_RESOURCE = RESOURCE_PREFIX + "content_authority";
+
+    private Context mContext;
+
+    protected ResourceResolver() {}
+
+    private ResourceResolver(Context context) {
+        mContext = context;
+    }
+
+    private Context getApplicationContext() {
+        return mContext.getApplicationContext();
+    }
+
+    public int getAppResource(String name, String type) {
+        Context appContext = getApplicationContext();
+        return appContext.getResources().getIdentifier(name, type, appContext.getPackageName());
+    }
+
+    public Integer getDrawable(String resourceName) {
+        return getAppResource(resourceName, "drawable");
+    }
+
+    public String getString(String name) {
+        return getApplicationContext().getString(getAppResource(name, "string"));
+    }
+
+    public String getAccountName() {
+        return getString(ACCOUNT_NAME_RESOURCE);
+    }
+
+    public String getAccountType() {
+        return getString(ACCOUNT_TYPE_RESOURCE);
+    }
+
+    public String getAuthority() {
+        return getString(AUTHORITY_TYPE_RESOURCE);
+    }
+
+    public static ResourceResolver newInstance(Context context) {
+        return new ResourceResolver(context);
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.marianhello.bgloc.data;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by finch on 9.12.2017.
+ */
+
+abstract public class AbstractLocationTemplate implements LocationTemplate, Serializable {
+    public static final String BUNDLE_KEY = "template";
+    public abstract LocationTemplate clone();
+
+    static class LocationMapper {
+        private BackgroundLocation location;
+
+        private LocationMapper() {}
+
+        private Object mapValue(Object value) throws JSONException {
+            if (value instanceof String) {
+                Object locationValue = location.getValueForKey((String) value);
+                return locationValue != null ? locationValue : value;
+            } else if (value instanceof Map) {
+                return withMap((Map) value);
+            } else if (value instanceof List) {
+                return withList((List) value);
+            }
+
+            return value;
+        }
+
+        public JSONArray withList(List values) throws JSONException {
+            JSONArray result = new JSONArray();
+            Iterator<?> it = values.iterator();
+            while (it.hasNext()) {
+                Object value = it.next();
+                result.put(mapValue(value));
+            }
+
+            return result;
+
+        }
+
+        public JSONObject withMap(Map values) throws JSONException {
+            JSONObject result = new JSONObject();
+            Iterator<?> it = values.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<String, Object> pair = (Map.Entry) it.next();
+                String key = pair.getKey();
+                Object value = pair.getValue();
+                result.put(key, mapValue(value));
+            }
+
+            return result;
+        }
+
+        public static LocationMapper map(BackgroundLocation location) {
+            LocationMapper instance = new LocationMapper();
+            instance.location = location;
+            return instance;
+        }
+    }
+}

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

@@ -0,0 +1,88 @@
+package com.marianhello.bgloc.data;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Created by finch on 15.12.2017.
+ */
+
+public class ArrayListLocationTemplate extends AbstractLocationTemplate implements Serializable {
+    private ArrayList mList;
+    private static final long serialVersionUID = 1234L;
+
+    // copy constructor
+    public ArrayListLocationTemplate(ArrayListLocationTemplate tpl) {
+        if (tpl == null || tpl.mList == null) {
+            return;
+        }
+
+        mList = new ArrayList();
+        Iterator it = tpl.mList.iterator();
+        while (it.hasNext()) {
+            mList.add(it.next());
+        }
+    }
+
+    public ArrayListLocationTemplate(ArrayList list) {
+        this.mList = list;
+    }
+
+    @Override
+    public Object locationToJson(BackgroundLocation location) throws JSONException {
+        return LocationMapper.map(location).withList(mList);
+    }
+
+    public Iterator iterator() {
+        return mList.iterator();
+    }
+
+    public boolean containsKey(String key) {
+        return mList.contains(key);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return mList == null || mList.isEmpty();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other == null) return false;
+        if (other == this) return true;
+        if (!(other instanceof ArrayListLocationTemplate)) return false;
+        return ((ArrayListLocationTemplate) other).mList.equals(this.mList);
+    }
+
+    @Override
+    public String toString() {
+        if (mList == null) {
+            return "null";
+        }
+
+        JSONArray jArray = new JSONArray(mList);
+        return jArray.toString();
+    }
+
+    public Object[] toArray() {
+        if (mList == null) {
+            return null;
+        }
+
+        return mList.toArray();
+    }
+
+    public List toList() {
+        return mList;
+    }
+
+    @Override
+    public LocationTemplate clone() {
+        return new ArrayListLocationTemplate(this);
+    }
+}

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

@@ -0,0 +1,108 @@
+package com.marianhello.bgloc.data;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import com.google.android.gms.location.DetectedActivity;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Created by finch on 5.12.2017.
+ */
+
+public class BackgroundActivity implements Parcelable {
+    private int confidence;
+    private int type;
+
+    public BackgroundActivity(Integer locationProvider, DetectedActivity activity) {
+        confidence = activity.getConfidence();
+        type = activity.getType();
+    }
+
+    private BackgroundActivity(Parcel in) {
+        confidence = in.readInt();
+        type = in.readInt();
+    }
+
+    /**
+     * Returns location as JSON object.
+     * @throws JSONException
+     */
+    public JSONObject toJSONObject() throws JSONException {
+        JSONObject json = new JSONObject();
+        json.put("confidence", confidence);
+        json.put("type", getActivityString(type));
+        return json;
+    }
+
+    public static String getActivityString(int detectedActivityType) {
+        switch(detectedActivityType) {
+            case DetectedActivity.IN_VEHICLE:
+                return "IN_VEHICLE";
+            case DetectedActivity.ON_BICYCLE:
+                return "ON_BICYCLE";
+            case DetectedActivity.ON_FOOT:
+                return "ON_FOOT";
+            case DetectedActivity.RUNNING:
+                return "RUNNING";
+            case DetectedActivity.STILL:
+                return "STILL";
+            case DetectedActivity.TILTING:
+                return "TILTING";
+            case DetectedActivity.UNKNOWN:
+                return "UNKNOWN";
+            case DetectedActivity.WALKING:
+                return "WALKING";
+            default:
+                return "UNKNOWN";
+        }
+    }
+
+    public int getConfidence() {
+        return confidence;
+    }
+
+    public void setConfidence(int confidence) {
+        this.confidence = confidence;
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    public void setType(int type) {
+        this.type = type;
+    }
+
+    public static final Parcelable.Creator<BackgroundActivity> CREATOR
+            = new Parcelable.Creator<BackgroundActivity>() {
+        public BackgroundActivity createFromParcel(Parcel in) {
+            return new BackgroundActivity(in);
+        }
+        public BackgroundActivity[] newArray(int size) {
+            return new BackgroundActivity[size];
+        }
+    };
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int i) {
+        dest.writeInt(confidence);
+        dest.writeInt(type);
+    }
+
+    @Override
+    public String toString () {
+        return new StringBuffer()
+                .append("BackgroundActivity[confidence=").append(confidence)
+                .append(" type=").append(getActivityString(type))
+                .append("]")
+                .toString();
+    }
+}