@josuelmm/cordova-background-geolocation 2.3.5

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

@@ -0,0 +1,161 @@
+package com.marianhello.bgloc;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.os.IBinder;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.rule.ServiceTestRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.marianhello.bgloc.provider.TestLocationProviderFactory;
+import com.marianhello.bgloc.service.LocationServiceImpl;
+import com.marianhello.bgloc.service.LocationServiceProxy;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeoutException;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
+@RunWith(AndroidJUnit4.class)
+public class LocationServiceProxyTest {
+
+    @Rule
+    public final ServiceTestRule mServiceRule = new ServiceTestRule();
+
+    private LocationServiceProxy proxy;
+
+    @Before
+    public void setUp() {
+        LocationServiceImpl.setLocationProviderFactory(new TestLocationProviderFactory());
+        proxy = new LocationServiceProxy(InstrumentationRegistry.getTargetContext());
+    }
+
+    @After
+    public void tearDown() {
+        LocationServiceImpl.setLocationProviderFactory(null);
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        ctx.stopService(new Intent(ctx, LocationServiceImpl.class));
+    }
+
+    @Test(timeout = 5000)
+    public void testStart() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        BroadcastReceiver serviceBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Bundle bundle = intent.getExtras();
+                int action = bundle.getInt("action");
+
+                if (action == LocationServiceImpl.MSG_ON_SERVICE_STARTED) {
+                    latch.countDown();
+                }
+            }
+        };
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(InstrumentationRegistry.getTargetContext());
+        lbm.registerReceiver(serviceBroadcastReceiver, new IntentFilter(LocationServiceImpl.ACTION_BROADCAST));
+
+        proxy.start();
+        latch.await();
+        lbm.unregisterReceiver(serviceBroadcastReceiver);
+    }
+
+    @Test(timeout = 5000)
+    public void testStop() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        BroadcastReceiver serviceBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Bundle bundle = intent.getExtras();
+                int action = bundle.getInt("action");
+
+                if (action == LocationServiceImpl.MSG_ON_SERVICE_STOPPED) {
+                    latch.countDown();
+                }
+            }
+        };
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(InstrumentationRegistry.getTargetContext());
+        lbm.registerReceiver(serviceBroadcastReceiver, new IntentFilter(LocationServiceImpl.ACTION_BROADCAST));
+
+        proxy.start();
+        proxy.stop();
+        latch.await();
+        lbm.unregisterReceiver(serviceBroadcastReceiver);
+    }
+
+    @Test(timeout = 5000)
+    public void testConfigure() throws TimeoutException, InterruptedException {
+        Context context = InstrumentationRegistry.getTargetContext();
+        // Create the service Intent.
+        Intent serviceIntent = new Intent(context, LocationServiceImpl.class);
+        // Bind the service and grab a reference to the binder.
+        IBinder binder = mServiceRule.bindService(serviceIntent);
+        // Get the reference to the service, or you can call
+        // public methods on the binder directly.
+        LocationServiceImpl service = ((LocationServiceImpl.LocalBinder) binder).getService();
+
+        Config config = Config.getDefault();
+        config.setUrl("http://locationserviceproxy.net/");
+
+        proxy.start();
+        proxy.configure(config);
+        Thread.sleep(4000);
+        assertThat(service.getConfig().getUrl(), equalTo("http://locationserviceproxy.net/"));
+
+        mServiceRule.unbindService();
+    }
+
+    @Test(timeout = 5000)
+    public void testShouldNotBeRunningAfterConfigure() throws TimeoutException, InterruptedException {
+        assertThat(proxy.isStarted(), is(false));
+        assertThat(proxy.isRunning(), is(false));
+        proxy.configure(Config.getDefault());
+        assertThat(proxy.isStarted(), is(false));
+        assertThat(proxy.isRunning(), is(false));
+    }
+
+
+    @Ignore
+    @Test(timeout = 5000)
+    public void testRegisterHeadlessTask() {
+        // TODO
+    }
+
+    @Ignore
+    @Test(timeout = 5000)
+    public void testStartHeadlessTask() {
+        // TODO
+    }
+
+    @Ignore
+    @Test(timeout = 5000)
+    public void testExecuteProviderCommand() {
+        // TODO
+    }
+
+    @Ignore
+    @Test(timeout = 5000)
+    public void testStartForeground() {
+        // TODO
+    }
+
+    @Ignore
+    @Test(timeout = 5000)
+    public void testStopForeground() {
+        // TODO
+    }
+}

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

@@ -0,0 +1,247 @@
+package com.marianhello.bgloc;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.location.Location;
+import android.os.Bundle;
+import android.os.IBinder;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.rule.ServiceTestRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.provider.MockLocationProvider;
+import com.marianhello.bgloc.provider.TestLocationProviderFactory;
+import com.marianhello.bgloc.service.LocationServiceImpl;
+import com.marianhello.bgloc.service.LocationServiceIntentBuilder;
+import com.marianhello.bgloc.data.LocationTransform;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.Is.isA;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsInstanceOf.any;
+import static org.junit.Assert.assertThat;
+
+@RunWith(AndroidJUnit4.class)
+public class LocationServiceTest {
+
+    @Rule
+    public final ServiceTestRule mServiceRule = new ServiceTestRule();
+
+    private LocationServiceImpl mService;
+    private TestLocationProviderFactory mLocationProviderFactory = new TestLocationProviderFactory();
+
+    @Before
+    public void setUp() {
+        mLocationProviderFactory.setProvider(new MockLocationProvider());
+        LocationServiceImpl.setLocationProviderFactory(mLocationProviderFactory);
+
+        try {
+            Context context = InstrumentationRegistry.getTargetContext();
+            // Create the mService Intent.
+            Intent serviceIntent = new Intent(context, LocationServiceImpl.class);
+            // Bind the mService and grab a reference to the binder.
+            IBinder binder = mServiceRule.bindService(serviceIntent);
+            // Get the reference to the mService, or you can call
+            // public methods on the binder directly.
+            mService = ((LocationServiceImpl.LocalBinder) binder).getService();
+        } catch (TimeoutException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @After
+    public void tearDown() {
+        LocationServiceImpl.setLocationProviderFactory(null);
+        LocationServiceImpl.setLocationTransform(null);
+        mService.stop();
+        mServiceRule.unbindService();
+    }
+
+    @Test(timeout = 5000)
+    public void testWithStartedService() throws TimeoutException, InterruptedException {
+        final Context context = InstrumentationRegistry.getTargetContext();
+        final CountDownLatch latch = new CountDownLatch(1);
+
+        BroadcastReceiver serviceBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Bundle bundle = intent.getExtras();
+                int action = bundle.getInt("action");
+
+                if (action == LocationServiceImpl.MSG_ON_SERVICE_STARTED) {
+                    latch.countDown();
+                }
+            }
+        };
+        LocalBroadcastManager.getInstance(context)
+                .registerReceiver(serviceBroadcastReceiver, new IntentFilter(LocationServiceImpl.ACTION_BROADCAST));
+
+
+        //assertThat(mService.isBound(), is(false));
+        assertThat(mService.isRunning(), is(false));
+        Intent intent = LocationServiceIntentBuilder
+                .getInstance(context)
+                .setCommand(0)
+                .build();
+        mServiceRule.startService(intent);
+
+        latch.await(5, TimeUnit.SECONDS);
+        assertThat(mService.isRunning(), is(true));
+    }
+
+    @Test(timeout = 5000)
+    public void testWithBoundService() {
+        // Verify that the mService is working correctly.
+        assertThat(mService.isRunning(), is(false));
+        assertThat(mService.isBound(), is(true));
+        assertThat(mService.getConfig(), is(any(Config.class)));
+    }
+
+    @Test(timeout = 5000)
+    public void testStartStop() {
+        assertThat(mService.isRunning(), is(false));
+        mService.start();
+        assertThat(mService.isRunning(), is(true));
+        mService.stop();
+        assertThat(mService.isRunning(), is(false));
+    }
+
+    @Test(timeout = 5000)
+    public void testOnLocation() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        BroadcastReceiver serviceBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Bundle bundle = intent.getExtras();
+                int action = bundle.getInt("action");
+
+                if (action == LocationServiceImpl.MSG_ON_LOCATION) {
+                    bundle.setClassLoader(LocationServiceImpl.class.getClassLoader());
+                    BackgroundLocation location = bundle.getParcelable("payload");
+
+                    assertThat(location, isA(BackgroundLocation.class));
+                    assertThat(location.getAltitude(), equalTo(666.0));
+                    latch.countDown();
+                }
+            }
+        };
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(InstrumentationRegistry.getTargetContext());
+        lbm.registerReceiver(serviceBroadcastReceiver, new IntentFilter(LocationServiceImpl.ACTION_BROADCAST));
+
+        mService.start();
+        BackgroundLocation location = new BackgroundLocation();
+        location.setAltitude(666.0);
+        mService.onLocation(location);
+
+        latch.await();
+        lbm.unregisterReceiver(serviceBroadcastReceiver);
+    }
+
+    @Test(timeout = 5000)
+    public void testOnLocationOnStoppedService() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(3);
+        BroadcastReceiver serviceBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Bundle bundle = intent.getExtras();
+                int action = bundle.getInt("action");
+
+                if (action == LocationServiceImpl.MSG_ON_SERVICE_STARTED) {
+                    latch.countDown();
+                    mService.stop();
+                    //mService.onDestroy();
+                }
+                if (action == LocationServiceImpl.MSG_ON_SERVICE_STOPPED) {
+                    latch.countDown();
+                    mService.onLocation(new BackgroundLocation());
+                }
+                if (action == LocationServiceImpl.MSG_ON_LOCATION) {
+                    latch.countDown();
+                }
+            }
+        };
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(InstrumentationRegistry.getTargetContext());
+        lbm.registerReceiver(serviceBroadcastReceiver, new IntentFilter(LocationServiceImpl.ACTION_BROADCAST));
+
+        Config config = Config.getDefault();
+        config.setStartForeground(false);
+
+        MockLocationProvider provider = new MockLocationProvider();
+        Location location = new Location("gps");
+        location.setProvider("mock");
+        location.setElapsedRealtimeNanos(2000000000L);
+        location.setAltitude(100);
+        location.setLatitude(49);
+        location.setLongitude(5);
+        location.setAccuracy(105);
+        location.setSpeed(50);
+        location.setBearing(1);
+
+        provider.setMockLocations(Arrays.asList(location));
+        mLocationProviderFactory.setProvider(provider);
+
+        mService.setLocationProviderFactory(mLocationProviderFactory);
+        mService.configure(config);
+        mService.start();
+
+        latch.await();
+        lbm.unregisterReceiver(serviceBroadcastReceiver);
+    }
+
+    @Test(timeout = 5000)
+    public void testTransform() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(1);
+        BroadcastReceiver serviceBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                Bundle bundle = intent.getExtras();
+                int action = bundle.getInt("action");
+
+                if (action == LocationServiceImpl.MSG_ON_LOCATION) {
+                    latch.countDown();
+
+                    bundle.setClassLoader(LocationServiceImpl.class.getClassLoader());
+                    BackgroundLocation location = (BackgroundLocation) bundle.getParcelable("payload");
+
+                    assertThat(location.getAltitude(), equalTo(8848.0));
+                }
+            }
+        };
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(InstrumentationRegistry.getTargetContext());
+        lbm.registerReceiver(serviceBroadcastReceiver, new IntentFilter(LocationServiceImpl.ACTION_BROADCAST));
+
+        LocationServiceImpl.setLocationTransform(new LocationTransform() {
+            @Nullable
+            @Override
+            public BackgroundLocation transformLocationBeforeCommit(@NonNull Context context, @NonNull BackgroundLocation location) {
+                location.setAltitude(8848.0);
+                return location;
+            }
+        });
+
+        mService.onLocation(new BackgroundLocation());
+        latch.await();
+        lbm.unregisterReceiver(serviceBroadcastReceiver);
+        LocationServiceImpl.setLocationTransform(null);
+    }
+}

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

@@ -0,0 +1,200 @@
+package com.marianhello.bgloc;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.filters.SmallTest;
+
+import com.marianhello.bgloc.data.HashMapLocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplateFactory;
+import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract;
+import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationDAO;
+import com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+/**
+ * Created by finch on 13/07/16.
+ */
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class SQLiteConfigurationDAOTest {
+    @Before
+    public void deleteDatabase() {
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        SQLiteOpenHelper.getHelper(ctx).close();
+        ctx.deleteDatabase(SQLiteOpenHelper.SQLITE_DATABASE_NAME);
+    }
+
+    @Test
+    public void persistConfiguration() {
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        SQLiteDatabase db = new SQLiteOpenHelper(ctx).getWritableDatabase();
+        SQLiteConfigurationDAO dao = new SQLiteConfigurationDAO(db);
+
+        Config config = new Config();
+        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.setSyncUrl("http://server:1234/syncLocations");
+        config.setSyncThreshold(200);
+        config.setStopOnTerminate(false);
+        config.setStopOnStillActivity(false);
+        config.setStationaryRadius(50);
+        config.setStartOnBoot(true);
+        config.setStartForeground(true);
+        config.setSmallNotificationIcon("smallico");
+        config.setLargeNotificationIcon("largeico");
+        config.setNotificationTitle("test");
+        config.setNotificationText("in progress");
+        config.setNotificationIconColor("yellow");
+        config.setNotificationsEnabled(true);
+
+        dao.persistConfiguration(config);
+        dao.persistConfiguration(config); // try once more
+
+        Cursor cursor = db.query(SQLiteConfigurationContract.ConfigurationEntry.TABLE_NAME, null, null, null, null, null, null);
+        Assert.assertEquals(1, cursor.getCount());
+        cursor.close();
+
+        try {
+            Config storedConfig = dao.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(15000, storedConfig.getMaxLocations().intValue());
+            Assert.assertEquals("http://server:1234/locations", storedConfig.getUrl());
+            Assert.assertEquals("http://server:1234/syncLocations", storedConfig.getSyncUrl());
+            Assert.assertEquals(200, storedConfig.getSyncThreshold().intValue());
+            Assert.assertEquals(Boolean.FALSE, storedConfig.getStopOnTerminate());
+            Assert.assertEquals(Boolean.FALSE, storedConfig.getStopOnStillActivity());
+            Assert.assertEquals(50, storedConfig.getStationaryRadius(), 0);
+            Assert.assertEquals(Boolean.TRUE, storedConfig.getStartOnBoot());
+            Assert.assertEquals(Boolean.TRUE, 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());
+
+        } catch (JSONException e) {
+            Assert.fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void persistConfigurationWithArrayListTemplate() {
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        SQLiteDatabase db = new SQLiteOpenHelper(ctx).getWritableDatabase();
+        SQLiteConfigurationDAO dao = new SQLiteConfigurationDAO(db);
+
+        Config config = Config.getDefault();
+        ArrayList props = new ArrayList();
+        props.add("@id");
+        props.add("@provider");
+        props.add("@time");
+        props.add("@altitude");
+        props.add("@latitude");
+        props.add("@longitude");
+        props.add("foo");
+        props.add("@locationProvider");
+        props.add("@accuracy");
+        props.add("@speed");
+        props.add("@bearing");
+
+        config.setTemplate(LocationTemplateFactory.fromArrayList(props));
+        dao.persistConfiguration(config);
+
+        try {
+            Config storedConfig = dao.retrieveConfiguration();
+            Assert.assertEquals(config.getTemplate(), storedConfig.getTemplate());
+        } catch (JSONException e) {
+            Assert.fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void persistConfigurationWithHashMapTemplate() {
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        SQLiteDatabase db = new SQLiteOpenHelper(ctx).getWritableDatabase();
+        SQLiteConfigurationDAO dao = new SQLiteConfigurationDAO(db);
+
+        Config config = Config.getDefault();
+        HashMap props = new HashMap<String, String>();
+        props.put("@id", "Id");
+        props.put("@provider", "Provider");
+        props.put("@time", "Time");
+        props.put("@altitude", "Altitude");
+        props.put("@latitude", "Latitude");
+        props.put("@longitude", "Longitude");
+        props.put("Bar", "Foo");
+        props.put("@locationProvider", "LocationProvider");
+        props.put("@accuracy", "Accuracy");
+        props.put("@speed", "Speed");
+        props.put("@bearing", "Bearing");
+
+        config.setTemplate(new HashMapLocationTemplate(props));
+        dao.persistConfiguration(config);
+
+        try {
+            Config storedConfig = dao.retrieveConfiguration();
+            Assert.assertEquals(config.getTemplate(), storedConfig.getTemplate());
+        } catch (JSONException e) {
+            Assert.fail(e.getMessage());
+        }
+    }
+
+    @Test
+    public void persistConfigurationWithComplexTemplate() throws JSONException {
+        Context ctx = InstrumentationRegistry.getTargetContext();
+        SQLiteDatabase db = new SQLiteOpenHelper(ctx).getWritableDatabase();
+        SQLiteConfigurationDAO dao = new SQLiteConfigurationDAO(db);
+
+        Config config = Config.getDefault();
+        JSONObject template = new JSONObject(
+                "{\"data\":{\"Id\":\"@id\"," +
+                        "\"Provider\":\"@provider\"," +
+                        "\"Time\":\"@time\"," +
+                        "\"Altitude\":\"@altitude\"," +
+                        "\"Latitude\":\"@latitude\"," +
+                        "\"Longitude\":\"@longitude\"," +
+                        "\"Foo\":\"bar\"," +
+                        "\"LocationProvider\":\"@locationProvider\"," +
+                        "\"Accuracy\":\"@accuracy\"," +
+                        "\"Speed\":\"@speed\"," +
+                        "\"Bearing\":\"@bearing\"}" +
+                        "}"
+        );
+
+        LocationTemplate tpl = LocationTemplateFactory.fromJSON(template);
+        config.setTemplate(tpl);
+        dao.persistConfiguration(config);
+
+        try {
+            Config storedConfig = dao.retrieveConfiguration();
+            Assert.assertEquals(config.getTemplate(), storedConfig.getTemplate());
+        } catch (JSONException e) {
+            Assert.fail(e.getMessage());
+        }
+    }
+
+}