react-native-nitro-background-geolocation 0.1.0

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

@@ -0,0 +1,168 @@
+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.util.HashMap;
+import java.util.Map;
+import java.util.Iterator;
+
+import java.net.URL;
+import java.net.HttpURLConnection;
+import java.io.OutputStreamWriter;
+
+public class HttpPostService {
+    public static final int BUFFER_SIZE = 1024;
+
+    private String mUrl;
+    private HttpURLConnection mHttpURLConnection;
+
+    public interface UploadingProgressListener {
+        void onProgress(int progress);
+    }
+
+    public HttpPostService(String url) {
+        mUrl = url;
+    }
+
+    public HttpPostService(final HttpURLConnection httpURLConnection) {
+        mHttpURLConnection = httpURLConnection;
+    }
+
+    private HttpURLConnection openConnection() throws IOException {
+        if (mHttpURLConnection == null) {
+            mHttpURLConnection = (HttpURLConnection) new URL(mUrl).openConnection();
+        }
+        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) {
+            jsonString = json.toString();
+        }
+
+        return postJSONString(jsonString, headers);
+    }
+
+    public int postJSONString(String body, Map headers) throws IOException {
+        if (headers == null) {
+            headers = new HashMap();
+        }
+
+        HttpURLConnection conn = this.openConnection();
+        conn.setDoOutput(true);
+        conn.setFixedLengthStreamingMode(body.length());
+        conn.setRequestMethod("POST");
+        conn.setRequestProperty("Content-Type", "application/json");
+        Iterator<Map.Entry<String, String>> it = headers.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<String, String> pair = it.next();
+            conn.setRequestProperty(pair.getKey(), pair.getValue());
+        }
+
+        OutputStreamWriter os = null;
+        try {
+            os = new OutputStreamWriter(conn.getOutputStream());
+            os.write(body);
+
+        } finally {
+            if (os != null) {
+                os.flush();
+                os.close();
+            }
+        }
+
+        return conn.getResponseCode();
+    }
+
+    public int postJSONFile(File file, Map headers, UploadingProgressListener listener) throws IOException {
+        return postJSONFile(new FileInputStream(file), headers, listener);
+    }
+
+    public int postJSONFile(InputStream stream, Map headers, UploadingProgressListener listener) throws IOException {
+        if (headers == null) {
+            headers = new HashMap();
+        }
+
+        final long streamSize = stream.available();
+        HttpURLConnection conn = this.openConnection();
+
+        conn.setDoInput(false);
+        conn.setDoOutput(true);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+            conn.setFixedLengthStreamingMode(streamSize);
+        } else {
+            conn.setChunkedStreamingMode(0);
+        }
+        conn.setRequestMethod("POST");
+        conn.setRequestProperty("Content-Type", "application/json");
+        Iterator<Map.Entry<String, String>> it = headers.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<String, String> pair = it.next();
+            conn.setRequestProperty(pair.getKey(), pair.getValue());
+        }
+
+        long progress = 0;
+        int bytesRead = -1;
+        byte[] buffer = new byte[BUFFER_SIZE];
+
+        BufferedInputStream is = null;
+        BufferedOutputStream os = null;
+        try {
+            is = new BufferedInputStream(stream);
+            os = new BufferedOutputStream(conn.getOutputStream());
+            while ((bytesRead = is.read(buffer)) != -1) {
+                os.write(buffer, 0, bytesRead);
+                os.flush();
+                progress += bytesRead;
+                int percentage = (int) ((progress * 100L) / streamSize);
+                if (listener != null) {
+                    listener.onProgress(percentage);
+                }
+            }
+        } finally {
+            if (os != null) {
+                os.flush();
+                os.close();
+            }
+            if (is != null) {
+                is.close();
+            }
+        }
+
+        return conn.getResponseCode();
+    }
+
+    public static int postJSON(String url, JSONObject json, Map headers) throws IOException {
+        HttpPostService service = new HttpPostService(url);
+        return service.postJSON(json, headers);
+    }
+
+    public static int postJSON(String url, JSONArray json, Map headers) throws IOException {
+        HttpPostService service = new HttpPostService(url);
+        return service.postJSON(json, headers);
+    }
+
+    public static int postJSONFile(String url, File file, Map headers, UploadingProgressListener listener) throws IOException {
+        HttpPostService service = new HttpPostService(url);
+        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,19 @@
+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);
+}

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;
+    }
+}

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

@@ -0,0 +1,186 @@
+package com.marianhello.bgloc;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.LocationDAO;
+import com.marianhello.logging.LoggerManager;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+
+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 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) {
+        logger = LoggerManager.getLogger(PostLocationTask.class);
+        logger.info("Creating PostLocationTask");
+
+        mLocationDAO = dao;
+        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;
+        }
+
+        long locationId = mLocationDAO.persistLocation(location);
+        location.setLocationId(locationId);
+
+        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()) {
+            long syncLocationsCount = mLocationDAO.getLocationsForSyncCount(System.currentTimeMillis());
+            if (syncLocationsCount >= mConfig.getSyncThreshold()) {
+                logger.debug("Attempt to sync locations: {} threshold: {}", syncLocationsCount, mConfig.getSyncThreshold());
+                mTaskListener.onSyncRequested();
+            }
+        }
+    }
+
+    private boolean postLocation(BackgroundLocation location) {
+        logger.debug("Executing PostLocationTask#postLocation");
+        JSONArray jsonLocations = new JSONArray();
+
+        try {
+            jsonLocations.put(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());
+        int responseCode;
+
+        try {
+            responseCode = HttpPostService.postJSON(url, jsonLocations, mConfig.getHttpHeaders());
+        } 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 getApplicationContext().getPackageName() + ".bgloc.account";
+    }
+
+    public String getAuthority() {
+        return getApplicationContext().getPackageName() + ".bgloc.provider";
+    }
+
+    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;
+        }
+    }
+}