@josuelmm/capacitor-background-geolocation 1.0.0

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

@@ -0,0 +1,406 @@
+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);
+    }
+
+    @Override
+    public int deletePendingSyncLocations() {
+        ContentValues values = new ContentValues();
+        values.put(LocationEntry.COLUMN_NAME_STATUS, BackgroundLocation.DELETED);
+
+        String whereClause = LocationEntry.COLUMN_NAME_STATUS + " = ?";
+        String[] whereArgs = { String.valueOf(BackgroundLocation.SYNC_PENDING) };
+
+        return mResolver.update(mContentUri, values, whereClause, whereArgs);
+    }
+}