@josuelmm/cordova-background-geolocation 2.3.5

package/android/common/src/androidTest/java/com/marianhello/bgloc/SQLiteOpenHelperTest.java

@@ -0,0 +1,225 @@
+package com.marianhello.bgloc;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.location.Location;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.SmallTest;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationDAO;
+import com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper;
+import com.marianhello.bgloc.sqlite.SQLiteOpenHelper10;
+
+import junit.framework.Assert;
+
+import org.json.JSONObject;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by finch on 13/07/16.
+ */
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class SQLiteOpenHelperTest {
+    @Before
+    public void deleteDatabase() {
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        SQLiteOpenHelper.getHelper(ctx).close();
+        ctx.deleteDatabase(SQLiteOpenHelper.SQLITE_DATABASE_NAME);
+    }
+
+    @Test
+    public void upgradeDatabaseFromVersion10() {
+        Cursor cursor = null;
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        SQLiteDatabase db10 = new SQLiteOpenHelper10(ctx).getWritableDatabase();
+
+        Location location = new Location("fake");
+        location.setAccuracy(200);
+        location.setAltitude(900);
+        location.setBearing(2);
+        location.setLatitude(40.21);
+        location.setLongitude(23.45);
+        location.setSpeed(20);
+        location.setProvider("test");
+        location.setTime(1000);
+        BackgroundLocation bgLocation = new BackgroundLocation(location);
+
+        Config config = Config.getDefault();
+        config.setActivitiesInterval(1000);
+        config.setDesiredAccuracy(200);
+        config.setDistanceFilter(300);
+        config.setFastestInterval(5000);
+        config.setInterval(10000);
+        config.setLocationProvider(0);
+        config.setMaxLocations(15000);
+        config.setUrl("http://server:1234/locations");
+        config.setStopOnTerminate(false);
+        config.setStopOnStillActivity(false);
+        config.setStationaryRadius(50);
+        config.setStartOnBoot(false);
+        config.setStartForeground(false);
+        config.setSmallNotificationIcon("smallico");
+        config.setLargeNotificationIcon("largeico");
+        config.setNotificationTitle("test");
+        config.setNotificationText("in progress");
+        config.setNotificationIconColor("yellow");
+
+        ContentValues locationValues = new ContentValues();
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_TIME, bgLocation.getTime());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_ACCURACY, bgLocation.getAccuracy());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_SPEED, bgLocation.getSpeed());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_BEARING, bgLocation.getBearing());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_ALTITUDE, bgLocation.getAltitude());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_LATITUDE, bgLocation.getLatitude());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_LONGITUDE, bgLocation.getLongitude());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_PROVIDER, bgLocation.getProvider());
+        locationValues.put(SQLiteLocationContract.LocationEntry.COLUMN_NAME_LOCATION_PROVIDER, bgLocation.getLocationProvider());
+
+        db10.insert(SQLiteLocationContract.LocationEntry.TABLE_NAME, null, locationValues);
+        cursor = db10.query(SQLiteLocationContract.LocationEntry.TABLE_NAME, null, null, null, null, null, null);
+        Assert.assertEquals(1, cursor.getCount());
+        cursor.close();
+
+        ContentValues configValues = new ContentValues();
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_RADIUS, config.getStationaryRadius());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_DISTANCE_FILTER, config.getDistanceFilter());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_DESIRED_ACCURACY, config.getDesiredAccuracy());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_DEBUG, (config.isDebugging() == true) ? 1 : 0);
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_TITLE, config.getNotificationTitle());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_TEXT, config.getNotificationText());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_SMALL, config.getSmallNotificationIcon());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_LARGE, config.getLargeNotificationIcon());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_COLOR, config.getNotificationIconColor());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_STOP_TERMINATE, (config.getStopOnTerminate() == true) ? 1 : 0);
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_START_BOOT, (config.getStartOnBoot() == true) ? 1 : 0);
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_START_FOREGROUND, (config.getStartForeground() == true) ? 1 : 0);
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_LOCATION_PROVIDER, config.getLocationProvider());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_INTERVAL, config.getInterval());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_FASTEST_INTERVAL, config.getFastestInterval());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_ACTIVITIES_INTERVAL, config.getActivitiesInterval());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_URL, config.getUrl());
+        configValues.put(SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_HEADERS, new JSONObject(config.getHttpHeaders()).toString());
+
+        db10.insert(SQLiteConfigurationContract.ConfigurationEntry.TABLE_NAME, null, configValues);
+        cursor = db10.query(SQLiteConfigurationContract.ConfigurationEntry.TABLE_NAME, null, null, null, null, null, null);
+        Assert.assertEquals(1, cursor.getCount());
+        cursor.close();
+
+        db10.close();
+
+        // begin test
+
+        List<String> columnNames = null;
+        SQLiteDatabase db = new SQLiteOpenHelper(ctx).getWritableDatabase();
+
+        cursor = db.query(SQLiteLocationContract.LocationEntry.TABLE_NAME, null, null, null, null, null, null);
+        columnNames = Arrays.asList(cursor.getColumnNames());
+
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_TIME)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_ACCURACY)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_SPEED)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_BEARING)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_ALTITUDE)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_LATITUDE)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_LONGITUDE)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_RADIUS)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_HAS_ACCURACY)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_HAS_SPEED)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_HAS_BEARING)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_HAS_ALTITUDE)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_HAS_RADIUS)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_PROVIDER)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_LOCATION_PROVIDER)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_STATUS)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_BATCH_START_MILLIS)));
+        Assert.assertTrue(columnNames.contains((SQLiteLocationContract.LocationEntry.COLUMN_NAME_MOCK_FLAGS)));
+
+        cursor.close();
+
+        // locations should survive db upgrade
+        SQLiteLocationDAO dao = new SQLiteLocationDAO(db);
+        ArrayList<BackgroundLocation> locations = new ArrayList(dao.getAllLocations());
+        Assert.assertEquals(1, locations.size());
+
+        BackgroundLocation storedLocation = locations.get(0);
+        Assert.assertEquals(200, storedLocation.getAccuracy(), 0);
+        Assert.assertEquals(900, storedLocation.getAltitude(), 0);
+        Assert.assertEquals(2, storedLocation.getBearing(), 0);
+        Assert.assertEquals(40.21, storedLocation.getLatitude(), 0);
+        Assert.assertEquals(23.45, storedLocation.getLongitude(), 0);
+        Assert.assertEquals(20, storedLocation.getSpeed(), 0);
+        Assert.assertEquals("test", storedLocation.getProvider(), "test");
+        Assert.assertEquals(1000, storedLocation.getTime(), 0);
+
+
+        // test configuration table upgrade
+
+        cursor = db.query(SQLiteConfigurationContract.ConfigurationEntry.TABLE_NAME, null, null, null, null, null, null);
+        columnNames = Arrays.asList(cursor.getColumnNames());
+
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_RADIUS)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_DISTANCE_FILTER)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_DESIRED_ACCURACY)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_DEBUG)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_TITLE)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_TEXT)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_LARGE)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_SMALL)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_NOTIF_COLOR)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_START_BOOT)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_START_FOREGROUND)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_STOP_ON_STILL)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_STOP_TERMINATE)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_LOCATION_PROVIDER)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_INTERVAL)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_FASTEST_INTERVAL)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_ACTIVITIES_INTERVAL)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_URL)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_SYNC_URL)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_SYNC_THRESHOLD)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_HEADERS)));
+        Assert.assertTrue(columnNames.contains((SQLiteConfigurationContract.ConfigurationEntry.COLUMN_NAME_MAX_LOCATIONS)));
+
+        cursor.close();
+
+//        SQLiteConfigurationDAO configDAO = new SQLiteConfigurationDAO(db);
+//        try {
+//            Config storedConfig = configDAO.retrieveConfiguration();
+//            Assert.assertEquals(1000, storedConfig.getActivitiesInterval().intValue());
+//            Assert.assertEquals(200, storedConfig.getDesiredAccuracy().intValue());
+//            Assert.assertEquals(300, storedConfig.getDistanceFilter().intValue());
+//            Assert.assertEquals(5000, storedConfig.getFastestInterval().intValue());
+//            Assert.assertEquals(10000, storedConfig.getInterval().intValue());
+//            Assert.assertEquals(0, storedConfig.getLocationProvider().intValue());
+//            Assert.assertEquals(10000, storedConfig.getMaxLocations().intValue());
+//            Assert.assertEquals("http://server:1234/locations", storedConfig.getUrl());
+//            Assert.assertEquals(Boolean.FALSE, storedConfig.getStopOnTerminate());
+//            Assert.assertEquals(Boolean.FALSE, storedConfig.getStopOnStillActivity());
+//            Assert.assertEquals(50, storedConfig.getStationaryRadius(), 0);
+//            Assert.assertEquals(Boolean.FALSE, storedConfig.getStartOnBoot());
+//            Assert.assertEquals(Boolean.FALSE, storedConfig.getStartForeground());
+//            Assert.assertEquals("smallico", storedConfig.getSmallNotificationIcon());
+//            Assert.assertEquals("largeico", storedConfig.getLargeNotificationIcon());
+//            Assert.assertEquals("test", storedConfig.getNotificationTitle());
+//            Assert.assertEquals("in progress", storedConfig.getNotificationText());
+//            Assert.assertEquals("yellow", storedConfig.getNotificationIconColor());
+////            Assert.assertEquals("", storedConfig.getHttpHeaders());
+//
+//        } catch (JSONException e) {
+//            Assert.fail(e.getMessage());
+//        }
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/TestPluginDelegate.java

@@ -0,0 +1,46 @@
+package com.marianhello.bgloc;
+
+import com.marianhello.bgloc.data.BackgroundActivity;
+import com.marianhello.bgloc.data.BackgroundLocation;
+
+public class TestPluginDelegate implements PluginDelegate {
+    @Override
+    public void onAuthorizationChanged(int authStatus) {
+
+    }
+
+    @Override
+    public void onLocationChanged(BackgroundLocation location) {
+
+    }
+
+    @Override
+    public void onStationaryChanged(BackgroundLocation location) {
+
+    }
+
+    @Override
+    public void onActivityChanged(BackgroundActivity activity) {
+
+    }
+
+    @Override
+    public void onServiceStatusChanged(int status) {
+
+    }
+
+    @Override
+    public void onAbortRequested() {
+
+    }
+
+    @Override
+    public void onHttpAuthorization() {
+
+    }
+
+    @Override
+    public void onError(PluginException error) {
+
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/TestResourceResolver.java

@@ -0,0 +1,14 @@
+package com.marianhello.bgloc;
+
+import com.marianhello.bgloc.test.TestConstants;
+
+public class TestResourceResolver extends ResourceResolver {
+
+    public TestResourceResolver() {
+
+    }
+
+    public String getAuthority() {
+        return TestConstants.Authority;
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/provider/MockLocationProvider.java

@@ -0,0 +1,50 @@
+package com.marianhello.bgloc.provider;
+
+import android.location.Location;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class MockLocationProvider extends AbstractLocationProvider {
+    private boolean mIsStarted = false;
+    private List<Location> mMockLocations = new ArrayList();
+
+    public MockLocationProvider() {
+        super(null);
+        PROVIDER_ID = 99;
+    }
+
+    @Override
+    public void onStart() {
+        mIsStarted = true;
+        Iterator<Location> it = mMockLocations.iterator();
+        while(mIsStarted && it.hasNext()) {
+            handleLocation(it.next());
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                mIsStarted = false;
+            }
+        }
+    }
+
+    @Override
+    public void onStop() {
+        mIsStarted = false;
+    }
+
+    @Override
+    public boolean isStarted() {
+        return false;
+    }
+
+    @Override
+    public Boolean hasMockLocationsEnabled() {
+        return true;
+    }
+
+    public void setMockLocations(List<Location> locations) {
+        mMockLocations = locations;
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/provider/TestLocationProviderFactory.java

@@ -0,0 +1,17 @@
+package com.marianhello.bgloc.provider;
+
+public class TestLocationProviderFactory extends LocationProviderFactory {
+    private LocationProvider mProvider = new MockLocationProvider();
+
+    public TestLocationProviderFactory() {
+        super(null);
+    }
+
+    public LocationProvider getInstance (Integer locationProvider) {
+        return mProvider;
+    }
+
+    public void setProvider(LocationProvider provider) {
+        mProvider = mProvider;
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/sqlite/SQLiteOpenHelper10.java

@@ -0,0 +1,92 @@
+package com.marianhello.bgloc.sqlite;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.util.Log;
+
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry;
+import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract.ConfigurationEntry;
+
+/**
+ * Created by finch on 13/07/16.
+ */
+public class SQLiteOpenHelper10 extends android.database.sqlite.SQLiteOpenHelper {
+    private static final String SQLITE_DATABASE_NAME = "cordova_bg_geolocation.db";
+    private static final int DATABASE_VERSION = 10;
+    private static final String TEXT_TYPE = " TEXT";
+    private static final String INTEGER_TYPE = " INTEGER";
+    private static final String REAL_TYPE = " REAL";
+    private static final String COMMA_SEP = ",";
+
+    private static final String SQL_CREATE_LOCATION_TABLE =
+            "CREATE TABLE " + LocationEntry.TABLE_NAME + " (" +
+                    LocationEntry._ID + " INTEGER PRIMARY KEY," +
+                    LocationEntry.COLUMN_NAME_TIME + INTEGER_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_ACCURACY + REAL_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_SPEED + REAL_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_BEARING + REAL_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_ALTITUDE + REAL_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_LATITUDE + REAL_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_LONGITUDE + REAL_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_PROVIDER + TEXT_TYPE + COMMA_SEP +
+                    LocationEntry.COLUMN_NAME_LOCATION_PROVIDER + INTEGER_TYPE + COMMA_SEP +
+                    "debug" + INTEGER_TYPE +
+                    " )";
+
+    private static final String SQL_CREATE_CONFIG_TABLE =
+            "CREATE TABLE " + ConfigurationEntry.TABLE_NAME + " (" +
+                    ConfigurationEntry._ID + " INTEGER PRIMARY KEY," +
+                    ConfigurationEntry.COLUMN_NAME_RADIUS + REAL_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_DISTANCE_FILTER + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_DESIRED_ACCURACY + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_DEBUG + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_NOTIF_TITLE + TEXT_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_NOTIF_TEXT + TEXT_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_SMALL + TEXT_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_LARGE + TEXT_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_NOTIF_COLOR + TEXT_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_STOP_TERMINATE + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_START_BOOT + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_START_FOREGROUND + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_LOCATION_PROVIDER + TEXT_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_INTERVAL + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_FASTEST_INTERVAL + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_ACTIVITIES_INTERVAL + INTEGER_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_URL + TEXT_TYPE + COMMA_SEP +
+                    ConfigurationEntry.COLUMN_NAME_HEADERS + TEXT_TYPE +
+                    " )";
+
+    private static final String SQL_DELETE_CONFIG_TABLE =
+            "DROP TABLE IF EXISTS " + ConfigurationEntry.TABLE_NAME;
+
+    private static final String SQL_DELETE_LOCATION_TABLE =
+            "DROP TABLE IF EXISTS " + LocationEntry.TABLE_NAME;
+
+    public SQLiteOpenHelper10(Context context) {
+        super(context, SQLITE_DATABASE_NAME, null, DATABASE_VERSION);
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        db.execSQL(SQL_CREATE_LOCATION_TABLE);
+        Log.d(this.getClass().getName(), SQL_CREATE_LOCATION_TABLE);
+        db.execSQL(SQL_CREATE_CONFIG_TABLE);
+        Log.d(this.getClass().getName(), SQL_CREATE_CONFIG_TABLE);
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        // This database is only a cache for online data, so its upgrade policy is
+        // to simply to discard the data and start over
+        db.execSQL(SQL_DELETE_LOCATION_TABLE);
+        Log.d(this.getClass().getName(), SQL_DELETE_LOCATION_TABLE);
+        db.execSQL(SQL_DELETE_CONFIG_TABLE);
+        Log.d(this.getClass().getName(), SQL_DELETE_CONFIG_TABLE);
+        onCreate(db);
+    }
+
+    @Override
+    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        onUpgrade(db, oldVersion, newVersion);
+    }
+}

package/android/common/src/androidTest/java/com/marianhello/bgloc/test/LocationProviderTestCase.java

@@ -0,0 +1,107 @@
+package com.marianhello.bgloc.test;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.ProviderInfo;
+import android.content.res.Resources;
+import android.test.AndroidTestCase;
+import android.test.IsolatedContext;
+import android.test.RenamingDelegatingContext;
+import android.test.mock.MockContentResolver;
+import android.test.mock.MockContext;
+
+import com.marianhello.bgloc.data.provider.LocationContentProvider;
+import com.marianhello.bgloc.test.TestConstants;
+
+/**
+ * @author diego
+ * https://stackoverflow.com/a/5281044
+ *
+ */
+public class LocationProviderTestCase extends AndroidTestCase {
+    Class<LocationContentProvider> mProviderClass;
+    String mProviderAuthority;
+
+    private IsolatedContext mProviderContext;
+    private LocationContentProvider mProvider;
+    private MockContentResolver mResolver;
+
+    /**
+     * The renaming prefix.
+     */
+    private static final String filenamePrefix = "test.";
+
+    public LocationProviderTestCase() {
+        mProviderClass = LocationContentProvider.class;
+        mProviderAuthority = TestConstants.Authority;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        mResolver = new MockContentResolver();
+        RenamingDelegatingContext targetContextWrapper = new RenamingDelegatingContext(
+                new DelegatedMockContext(getContext()), // The context that most methods are delegated to
+                getContext(), // The context that file methods are delegated to
+                filenamePrefix);
+        mProviderContext = new IsolatedContext(mResolver, targetContextWrapper);
+
+        ProviderInfo providerInfo = new ProviderInfo();
+        providerInfo.authority = mProviderAuthority;
+
+        mProvider = mProviderClass.newInstance();
+        mProvider.attachInfo(mProviderContext, providerInfo);
+        assertNotNull(mProvider);
+        mResolver.addProvider(mProviderAuthority, mProvider);
+    }
+
+    public LocationContentProvider getProvider() {
+        return mProvider;
+    }
+
+    public MockContentResolver getMockContentResolver() {
+        return mResolver;
+    }
+
+    public IsolatedContext getMockContext() {
+        return mProviderContext;
+    }
+
+    public void testProviderSampleCreation() {
+        LocationContentProvider provider = getProvider();
+        assertNotNull(provider);
+    }
+
+    /**
+     * The DelegatedMockContext.
+     *
+     */
+    private static class DelegatedMockContext extends MockContext {
+
+        private Context mDelegatedContext;
+
+        public DelegatedMockContext(Context context) {
+            mDelegatedContext = context;
+        }
+
+        @Override
+        public SharedPreferences getSharedPreferences(String name, int mode) {
+            return mDelegatedContext.getSharedPreferences(filenamePrefix + name, mode);
+        }
+
+        @Override
+        public Context getApplicationContext() {
+            return mDelegatedContext.getApplicationContext();
+        }
+
+        @Override
+        public Resources getResources() {
+            return mDelegatedContext.getResources();
+        }
+
+        @Override
+        public String getPackageName() {
+            return mDelegatedContext.getPackageName();
+        }
+    }}

package/android/common/src/androidTest/java/com/marianhello/bgloc/test/TestConstants.java

@@ -0,0 +1,5 @@
+package com.marianhello.bgloc.test;
+
+abstract public class TestConstants {
+    public static final String Authority = "com.marianhello.app.plugin.bgloc.provider";
+}

package/android/common/src/main/AndroidManifest.xml

@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.marianhello.backgroundgeolocation" android:versionName="1.0" android:versionCode="1">
+    <application>
+        <service
+            android:name="com.marianhello.bgloc.sync.SyncService"
+            android:exported="true"
+            android:process=":sync">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+            <meta-data android:name="android.content.SyncAdapter"
+                android:resource="@xml/syncadapter"/>
+        </service>
+        <service
+            android:exported="false"
+            android:name="com.marianhello.bgloc.sync.AuthenticatorService">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator"/>
+            </intent-filter>
+            <meta-data
+                android:name="android.accounts.AccountAuthenticator"
+                android:resource="@xml/authenticator" />
+        </service>
+        <provider
+            android:name="com.marianhello.bgloc.data.provider.LocationContentProvider"
+            android:authorities="@string/plugin_bgloc_content_authority"
+            android:exported="false"
+            android:syncable="true"/>
+        <service android:enabled="true" android:exported="false" android:name="com.marianhello.bgloc.service.LocationServiceImpl" />
+        <receiver android:enabled="true" android:exported="true" android:name="com.marianhello.bgloc.BootCompletedReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+        <uses-library android:name="org.apache.http.legacy" android:required="true" />
+    </application>
+
+    <uses-permission android:name="android.hardware.location" />
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS" />
+    <uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+</manifest>