react-native-nitro-background-geolocation 0.1.0

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+package com.marianhello.bgloc.data;
+
+import java.util.Collection;
+
+public interface LocationDAO {
+    Collection<BackgroundLocation> getAllLocations();
+    Collection<BackgroundLocation> getValidLocations();
+    Collection<BackgroundLocation> getValidLocationsAndDelete();
+    BackgroundLocation getLocationById(long id);
+    BackgroundLocation getFirstUnpostedLocation();
+    BackgroundLocation getNextUnpostedLocation(long fromId);
+    long getUnpostedLocationsCount();
+    long getLocationsForSyncCount(long millisSinceLastBatch);
+    long persistLocation(BackgroundLocation location);
+    long persistLocation(BackgroundLocation location, int maxRows);
+    long persistLocationForSync(BackgroundLocation location, int maxRows);
+    void updateLocationForSync(long locationId);
+    void deleteLocationById(long locationId);
+    BackgroundLocation deleteFirstUnpostedLocation();
+    int deleteAllLocations();
+    int deleteUnpostedLocations();
+}

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

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

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

@@ -0,0 +1,65 @@
+package com.marianhello.bgloc.data;
+
+import com.marianhello.utils.Convert;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.json.JSONTokener;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * Created by finch on 9.12.2017.
+ */
+
+public class LocationTemplateFactory {
+
+    public static LocationTemplate fromJSON(Object json) throws JSONException {
+        if (json instanceof JSONObject) {
+            JSONObject jsonObject = (JSONObject) json;
+
+            return new HashMapLocationTemplate((HashMap) Convert.toMap(jsonObject));
+        } else if (json instanceof JSONArray) {
+            JSONArray jsonArray = (JSONArray) json;
+
+            return new ArrayListLocationTemplate((ArrayList) Convert.toList(jsonArray));
+        }
+
+        return null;
+    }
+
+    public static LocationTemplate fromJSONString(String jsonString) throws JSONException {
+        if (jsonString == null) {
+            return null;
+        }
+        Object json = new JSONTokener(jsonString).nextValue();
+        return fromJSON(json);
+    }
+
+    public static LocationTemplate fromHashMap(HashMap template) {
+        return new HashMapLocationTemplate(template);
+    }
+
+    public static LocationTemplate fromArrayList(ArrayList template) {
+        return new ArrayListLocationTemplate(template);
+    }
+
+    public static LocationTemplate getDefault() {
+        HashMap attrs = new HashMap<String, String>();
+        attrs.put("provider", "@provider");
+        attrs.put("locationProvider", "@locationProvider");
+        attrs.put("time", "@time");
+        attrs.put("latitude", "@latitude");
+        attrs.put("longitude", "@longitude");
+        attrs.put("accuracy", "@accuracy");
+        attrs.put("altitudeAccuracy", "@altitudeAccuracy");
+        attrs.put("speed", "@speed");
+        attrs.put("altitude", "@altitude");
+        attrs.put("bearing", "@bearing");
+        attrs.put("radius", "@radius");
+        return new HashMapLocationTemplate(attrs);
+    }
+}

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

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

package/android/src/main/java/com/marianhello/bgloc/data/provider/ContentProviderLocationDAO.java

@@ -0,0 +1,395 @@
+package com.marianhello.bgloc.data.provider;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.text.TextUtils;
+
+import com.marianhello.bgloc.ResourceResolver;
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.LocationDAO;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry;
+import com.marianhello.logging.LoggerManager;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import ru.andremoniy.sqlbuilder.SqlExpression;
+import ru.andremoniy.sqlbuilder.SqlSelectStatement;
+
+public class ContentProviderLocationDAO implements LocationDAO {
+    private org.slf4j.Logger logger;
+    private ContentResolver mResolver;
+    private Uri mContentUri;
+    private String mAuthority;
+
+    public ContentProviderLocationDAO(Context context) {
+        logger = LoggerManager.getLogger(ContentProviderLocationDAO.class);
+        ResourceResolver resourceResolver = ResourceResolver.newInstance(context);
+        mAuthority = resourceResolver.getAuthority();
+        mContentUri = LocationContentProvider.getContentUri(mAuthority);
+        mResolver = context.getApplicationContext().getContentResolver();
+    }
+
+    /**
+     * Get locations that match whereClause
+     *
+     * @param whereClause
+     * @param whereArgs
+     * @return collection of locations
+     */
+    private Collection<BackgroundLocation> getLocations(String whereClause, String[] whereArgs) {
+        Collection<BackgroundLocation> locations = new ArrayList<BackgroundLocation>();
+        Cursor cursor = null;
+
+        try {
+            cursor = mResolver.query(
+                    mContentUri,
+                    null,
+                    whereClause,
+                    whereArgs,
+                    LocationEntry.COLUMN_NAME_TIME + " ASC"
+            );
+            while (cursor.moveToNext()) {
+                locations.add(BackgroundLocation.fromCursor(cursor));
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        return locations;
+    }
+
+    @Override
+    public Collection<BackgroundLocation> getAllLocations() {
+        return getLocations(null, null);
+    }
+
+    @Override
+    public Collection<BackgroundLocation> getValidLocations() {
+        String whereClause = LocationEntry.COLUMN_NAME_STATUS + " <> ?";
+        String[] whereArgs = { String.valueOf(BackgroundLocation.DELETED) };
+
+        return getLocations(whereClause, whereArgs);
+    }
+
+    @Override
+    public Collection<BackgroundLocation> getValidLocationsAndDelete() {
+        // HM TODO: should be in a transaction but I'm not sure how to implement this...
+        Collection<BackgroundLocation> locations = getValidLocations();
+        deleteAllLocations();
+        return locations;
+    }
+
+    @Override
+    public BackgroundLocation getLocationById(long id) {
+        BackgroundLocation location = null;
+
+        Cursor cursor = null;
+        try {
+            cursor = mResolver.query(
+                    LocationContentProvider.buildUriWithId(mAuthority, id),
+                    null,
+                    null,
+                    null,
+                    null
+            );
+            while (cursor.moveToNext()) {
+                location = BackgroundLocation.fromCursor(cursor);
+                if (!cursor.isLast()) {
+                    throw new RuntimeException("Location " + id + " is not unique");
+                }
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        return location;
+
+    }
+
+    public int getLocationsCount() {
+        Cursor cursor = mResolver.query(
+                mContentUri,
+                null,
+                null,
+                null,
+                ""
+        );
+
+        int count = cursor.getCount();
+        cursor.close();
+        return count;
+    }
+
+    @Override
+    public BackgroundLocation getFirstUnpostedLocation() {
+        SqlSelectStatement subsql = new SqlSelectStatement();
+        subsql.column(new SqlExpression(String.format("MIN(%s)", LocationEntry._ID)), LocationEntry._ID);
+        subsql.from(LocationEntry.TABLE_NAME);
+        subsql.where(LocationEntry.COLUMN_NAME_STATUS, SqlExpression.SqlOperatorEqualTo, BackgroundLocation.POST_PENDING);
+        subsql.orderBy(LocationEntry.COLUMN_NAME_TIME);
+
+        String substmt = subsql.statement();
+        substmt = com.marianhello.utils.TextUtils.removeLastChar(substmt, ";");
+
+        BackgroundLocation location = null;
+        Cursor cursor = null;
+        try {
+            cursor = mResolver.query(
+                    mContentUri,
+                    null,
+                    LocationEntry._ID + " = (" + substmt + ")",
+                    null,
+                    null
+                    );
+
+            while (cursor.moveToNext()) {
+                location = BackgroundLocation.fromCursor(cursor);
+                if (!cursor.isLast()) {
+                    throw new RuntimeException("Expected single location");
+                }
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        return location;
+    }
+
+    @Override
+    public BackgroundLocation getNextUnpostedLocation(long fromId) {
+        SqlSelectStatement subsql = new SqlSelectStatement();
+        subsql.column(new SqlExpression(String.format("MIN(%s)", LocationEntry._ID)), LocationEntry._ID);
+        subsql.from(LocationEntry.TABLE_NAME);
+        subsql.where(LocationEntry.COLUMN_NAME_STATUS, SqlExpression.SqlOperatorEqualTo, BackgroundLocation.POST_PENDING);
+        subsql.where(LocationEntry._ID, SqlExpression.SqlOperatorNotEqualTo, fromId);
+        subsql.orderBy(LocationEntry.COLUMN_NAME_TIME);
+
+        String substmt = subsql.statement();
+        substmt = com.marianhello.utils.TextUtils.removeLastChar(substmt, ";");
+
+        BackgroundLocation location = null;
+        Cursor cursor = null;
+        try {
+            cursor = mResolver.query(
+                    mContentUri,
+                    null,
+                    LocationEntry._ID + " = (" + substmt + ")",
+                    null,
+                    null
+            );
+
+            while (cursor.moveToNext()) {
+                location = BackgroundLocation.fromCursor(cursor);
+                if (!cursor.isLast()) {
+                    throw new RuntimeException("Expected single location");
+                }
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        return location;
+    }
+
+    @Override
+    public long getUnpostedLocationsCount() {
+        String whereClause = SQLiteLocationContract.LocationEntry.COLUMN_NAME_STATUS + " = ?";
+        String[] whereArgs = { String.valueOf(BackgroundLocation.POST_PENDING) };
+
+        Cursor cursor = mResolver.query(
+                mContentUri,
+                null,
+                whereClause,
+                whereArgs,
+                null);
+
+        int count = cursor.getCount();
+        cursor.close();
+        return count;
+    }
+
+    @Override
+    public long getLocationsForSyncCount(long millisSinceLastBatch) {
+        String whereClause = TextUtils.join("", new String[]{
+                SQLiteLocationContract.LocationEntry.COLUMN_NAME_STATUS + " = ? AND ( ",
+                SQLiteLocationContract.LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " IS NULL OR ",
+                SQLiteLocationContract.LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " < ? )",
+        });
+        String[] whereArgs = {
+                String.valueOf(BackgroundLocation.SYNC_PENDING),
+                String.valueOf(millisSinceLastBatch)
+        };
+
+        Cursor cursor = mResolver.query(
+                mContentUri,
+                null,
+                whereClause,
+                whereArgs,
+                null);
+
+        int count = cursor.getCount();
+        cursor.close();
+        return count;
+    }
+
+    public Uri getOldestLocationUri() {
+        Cursor cursor = null;
+        try {
+            cursor = mResolver.query(
+                    mContentUri,
+                    new String[]{"min(" + LocationEntry._ID + ")"},
+                    TextUtils.join("", new String[]{
+                            LocationEntry.COLUMN_NAME_TIME,
+                            "= (SELECT min(",
+                            LocationEntry.COLUMN_NAME_TIME,
+                            ") FROM ",
+                            LocationEntry.TABLE_NAME,
+                            ")"
+                    }),
+                    null,
+                    null
+            );
+
+            cursor.moveToFirst();
+            return LocationContentProvider.buildUriWithId(mAuthority, cursor.getLong(0));
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+    }
+
+    /**
+     * Persist location into database
+     *
+     * @param location
+     * @return rowId or -1 when error occured
+     */
+    @Override
+    public long persistLocation(BackgroundLocation location) {
+        Uri locationUri = mResolver.insert(mContentUri, location.toContentValues());
+        return Integer.valueOf(locationUri.getLastPathSegment());
+    }
+
+    @Override
+    public long persistLocation(BackgroundLocation location, int maxRows) {
+        if (maxRows == 0) {
+            return -1;
+        }
+
+        long rowCount = getLocationsCount();
+
+        if (rowCount < maxRows) {
+            return persistLocation(location);
+        }
+
+        ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>();
+
+        // TODO: move this logic as separate action somewhere else
+        // TODO: add db vaccum
+        if (rowCount > maxRows) {
+            // delete some locations to reduce their count to maxRows
+            String selection = new StringBuilder()
+                    .append(LocationEntry._ID)
+                    .append(" IN (SELECT ").append(LocationEntry._ID)
+                    .append(" FROM ").append(LocationEntry.TABLE_NAME)
+                    .append(" ORDER BY ").append(LocationEntry.COLUMN_NAME_TIME)
+                    .append(" LIMIT ?)")
+                    .toString();
+
+            operations.add(
+                    ContentProviderOperation.newDelete(mContentUri)
+                    .withSelection(selection, new String[] {(String.valueOf(rowCount - maxRows))})
+                    .build()
+            );
+        }
+
+        operations.add(
+                ContentProviderOperation.newUpdate(getOldestLocationUri())
+                    .withValues(location.toContentValues())
+                    .build()
+        );
+
+        try {
+            mResolver.applyBatch(mAuthority, operations);
+        } catch (Exception e) {
+            logger.error("Error persisting location (maxRows: {}): {}", maxRows, e.getMessage());
+            return -1;
+        }
+
+        return 0;
+    }
+
+    @Override
+    public long persistLocationForSync(BackgroundLocation location, int maxRows) {
+        Long locationId = location.getLocationId();
+
+        if (locationId == null) {
+            location.setStatus(BackgroundLocation.SYNC_PENDING);
+            return persistLocation(location, maxRows);
+        } else {
+            ContentValues values = new ContentValues();
+            values.put(LocationEntry.COLUMN_NAME_STATUS, BackgroundLocation.SYNC_PENDING);
+
+            String whereClause = LocationEntry._ID + " = ?";
+            String[] whereArgs = { String.valueOf(locationId) };
+
+            mResolver.update(mContentUri, values, whereClause, whereArgs);
+            return locationId;
+        }
+    }
+
+    @Override
+    public void updateLocationForSync(long locationId) {
+        ContentValues values = new ContentValues();
+        values.put(LocationEntry.COLUMN_NAME_STATUS, BackgroundLocation.SYNC_PENDING);
+
+        String whereClause = LocationEntry._ID + " = ?";
+        String[] whereArgs = { String.valueOf(locationId) };
+
+        mResolver.update(mContentUri, values, whereClause, whereArgs);
+    }
+
+    @Override
+    public void deleteLocationById(long locationId) {
+        mResolver.delete(LocationContentProvider.buildUriWithId(mAuthority, locationId), null, null);
+    }
+
+    @Override
+    public BackgroundLocation deleteFirstUnpostedLocation() {
+        BackgroundLocation location = getFirstUnpostedLocation();
+        deleteLocationById(location.getLocationId());
+
+        return location;
+    }
+
+    @Override
+    public int deleteAllLocations() {
+        return mResolver.delete(mContentUri, null, null);
+    }
+
+    @Override
+    public int deleteUnpostedLocations() {
+        ContentValues values = new ContentValues();
+        values.put(LocationEntry.COLUMN_NAME_STATUS, BackgroundLocation.SYNC_PENDING);
+
+        String whereClause = LocationEntry.COLUMN_NAME_STATUS + " = ?";
+        String[] whereArgs = { String.valueOf(BackgroundLocation.POST_PENDING) };
+
+        return mResolver.update(mContentUri, values, whereClause, whereArgs);
+    }
+}