@josuelmm/cordova-background-geolocation 3.1.0 → 3.2.0

package/android/common/src/main/java/com/marianhello/bgloc/data/sqlite/SQLiteSessionContract.java

@@ -0,0 +1,74 @@
+package com.marianhello.bgloc.data.sqlite;
+
+import android.provider.BaseColumns;
+
+import static com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper.COMMA_SEP;
+import static com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper.INTEGER_TYPE;
+import static com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper.REAL_TYPE;
+import static com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper.TEXT_TYPE;
+
+/**
+ * Contract for the "session" location table.
+ * Stores all locations for the current recording session (route).
+ * Cleared on startSession() and clearSession(); not cleared when sync succeeds.
+ */
+public final class SQLiteSessionContract {
+
+    public SQLiteSessionContract() {}
+
+    public static abstract class SessionEntry implements BaseColumns {
+        public static final String TABLE_NAME = "location_session";
+        public static final String COLUMN_NAME_NULLABLE = "NULLHACK";
+        public static final String COLUMN_NAME_TIME = "time";
+        public static final String COLUMN_NAME_ACCURACY = "accuracy";
+        public static final String COLUMN_NAME_VERTICAL_ACCURACY = "vertical_accuracy";
+        public static final String COLUMN_NAME_SPEED = "speed";
+        public static final String COLUMN_NAME_BEARING = "bearing";
+        public static final String COLUMN_NAME_ALTITUDE = "altitude";
+        public static final String COLUMN_NAME_LATITUDE = "latitude";
+        public static final String COLUMN_NAME_LONGITUDE = "longitude";
+        public static final String COLUMN_NAME_RADIUS = "radius";
+        public static final String COLUMN_NAME_HAS_ACCURACY = "has_accuracy";
+        public static final String COLUMN_NAME_HAS_VERTICAL_ACCURACY = "has_vertical_accuracy";
+        public static final String COLUMN_NAME_HAS_SPEED = "has_speed";
+        public static final String COLUMN_NAME_HAS_BEARING = "has_bearing";
+        public static final String COLUMN_NAME_HAS_ALTITUDE = "has_altitude";
+        public static final String COLUMN_NAME_HAS_RADIUS = "has_radius";
+        public static final String COLUMN_NAME_PROVIDER = "provider";
+        public static final String COLUMN_NAME_LOCATION_PROVIDER = "service_provider";
+        public static final String COLUMN_NAME_STATUS = "valid";
+        public static final String COLUMN_NAME_BATCH_START_MILLIS = "batch_start";
+        public static final String COLUMN_NAME_MOCK_FLAGS = "mock_flags";
+
+        public static final String SQL_CREATE_SESSION_TABLE =
+                "CREATE TABLE " + SessionEntry.TABLE_NAME + " (" +
+                        SessionEntry._ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+                        SessionEntry.COLUMN_NAME_TIME + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_ACCURACY + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_VERTICAL_ACCURACY + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_SPEED + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_BEARING + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_ALTITUDE + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_LATITUDE + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_LONGITUDE + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_RADIUS + REAL_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_HAS_ACCURACY + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_HAS_VERTICAL_ACCURACY + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_HAS_SPEED + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_HAS_BEARING + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_HAS_ALTITUDE + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_HAS_RADIUS + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_PROVIDER + TEXT_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_LOCATION_PROVIDER + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_STATUS + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_BATCH_START_MILLIS + INTEGER_TYPE + COMMA_SEP +
+                        SessionEntry.COLUMN_NAME_MOCK_FLAGS + INTEGER_TYPE +
+                        " )";
+
+        public static final String SQL_DROP_SESSION_TABLE =
+                "DROP TABLE IF EXISTS " + SessionEntry.TABLE_NAME;
+
+        public static final String SQL_CREATE_SESSION_TABLE_TIME_IDX =
+                "CREATE INDEX session_time_idx ON " + SessionEntry.TABLE_NAME + " (" + SessionEntry.COLUMN_NAME_TIME + ")";
+    }
+}

package/android/common/src/main/java/com/marianhello/bgloc/data/sqlite/SQLiteSessionLocationDAO.java

@@ -0,0 +1,169 @@
+package com.marianhello.bgloc.data.sqlite;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.SessionLocationDAO;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class SQLiteSessionLocationDAO implements SessionLocationDAO {
+
+    private static final String PREFS_NAME = "bgloc_session";
+    private static final String KEY_SESSION_ACTIVE = "session_active";
+
+    private final SQLiteDatabase db;
+    private final Context context;
+
+    public SQLiteSessionLocationDAO(Context context) {
+        this.context = context.getApplicationContext();
+        SQLiteOpenHelper helper = SQLiteOpenHelper.getHelper(this.context);
+        this.db = helper.getWritableDatabase();
+    }
+
+    @Override
+    public void startSession() {
+        db.delete(SQLiteSessionContract.SessionEntry.TABLE_NAME, null, null);
+        setSessionActive(true);
+    }
+
+    @Override
+    public void clearSession() {
+        db.delete(SQLiteSessionContract.SessionEntry.TABLE_NAME, null, null);
+        setSessionActive(false);
+    }
+
+    @Override
+    public boolean isSessionActive() {
+        return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+                .getBoolean(KEY_SESSION_ACTIVE, false);
+    }
+
+    private void setSessionActive(boolean active) {
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+                .edit()
+                .putBoolean(KEY_SESSION_ACTIVE, active)
+                .apply();
+    }
+
+    @Override
+    public void persistSessionLocation(BackgroundLocation location) {
+        if (!isSessionActive() || location == null) return;
+        ContentValues values = getContentValues(location);
+        db.insertOrThrow(SQLiteSessionContract.SessionEntry.TABLE_NAME,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_NULLABLE, values);
+    }
+
+    @Override
+    public Collection<BackgroundLocation> getSessionLocations() {
+        Collection<BackgroundLocation> locations = new ArrayList<>();
+        String orderBy = SQLiteSessionContract.SessionEntry.COLUMN_NAME_TIME + " ASC";
+        Cursor cursor = null;
+        try {
+            cursor = db.query(
+                    SQLiteSessionContract.SessionEntry.TABLE_NAME,
+                    queryColumns(),
+                    null, null, null, null, orderBy);
+            while (cursor.moveToNext()) {
+                locations.add(hydrate(cursor));
+            }
+        } finally {
+            if (cursor != null) cursor.close();
+        }
+        return locations;
+    }
+
+    @Override
+    public int getSessionLocationsCount() {
+        Cursor cursor = null;
+        try {
+            cursor = db.rawQuery("SELECT COUNT(*) FROM " + SQLiteSessionContract.SessionEntry.TABLE_NAME, null);
+            return cursor.moveToFirst() ? cursor.getInt(0) : 0;
+        } finally {
+            if (cursor != null) cursor.close();
+        }
+    }
+
+    private BackgroundLocation hydrate(Cursor c) {
+        BackgroundLocation l = new BackgroundLocation(c.getString(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_PROVIDER)));
+        l.setTime(c.getLong(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_TIME)));
+        if (c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_ACCURACY)) == 1) {
+            l.setAccuracy(c.getFloat(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_ACCURACY)));
+        }
+        if (c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_VERTICAL_ACCURACY)) == 1) {
+            l.setVerticalAccuracy(c.getFloat(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_VERTICAL_ACCURACY)));
+        }
+        if (c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_SPEED)) == 1) {
+            l.setSpeed(c.getFloat(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_SPEED)));
+        }
+        if (c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_BEARING)) == 1) {
+            l.setBearing(c.getFloat(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_BEARING)));
+        }
+        if (c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_ALTITUDE)) == 1) {
+            l.setAltitude(c.getDouble(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_ALTITUDE)));
+        }
+        if (c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_RADIUS)) == 1) {
+            l.setRadius(c.getFloat(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_RADIUS)));
+        }
+        l.setLatitude(c.getDouble(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_LATITUDE)));
+        l.setLongitude(c.getDouble(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_LONGITUDE)));
+        l.setLocationProvider(c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_LOCATION_PROVIDER)));
+        l.setLocationId(c.getLong(c.getColumnIndex(SQLiteSessionContract.SessionEntry._ID)));
+        l.setMockFlags(c.getInt(c.getColumnIndex(SQLiteSessionContract.SessionEntry.COLUMN_NAME_MOCK_FLAGS)));
+        return l;
+    }
+
+    private ContentValues getContentValues(BackgroundLocation l) {
+        ContentValues values = new ContentValues();
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_PROVIDER, l.getProvider());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_TIME, l.getTime());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_ACCURACY, l.getAccuracy());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_VERTICAL_ACCURACY, l.getVerticalAccuracy());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_SPEED, l.getSpeed());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_BEARING, l.getBearing());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_ALTITUDE, l.getAltitude());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_RADIUS, l.getRadius());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_LATITUDE, l.getLatitude());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_LONGITUDE, l.getLongitude());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_ACCURACY, l.hasAccuracy() ? 1 : 0);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_VERTICAL_ACCURACY, l.hasVerticalAccuracy() ? 1 : 0);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_SPEED, l.hasSpeed() ? 1 : 0);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_BEARING, l.hasBearing() ? 1 : 0);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_ALTITUDE, l.hasAltitude() ? 1 : 0);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_RADIUS, l.hasRadius() ? 1 : 0);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_LOCATION_PROVIDER, l.getLocationProvider());
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_STATUS, 0);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_BATCH_START_MILLIS, 0L);
+        values.put(SQLiteSessionContract.SessionEntry.COLUMN_NAME_MOCK_FLAGS, l.getMockFlags());
+        return values;
+    }
+
+    private String[] queryColumns() {
+        return new String[]{
+                SQLiteSessionContract.SessionEntry._ID,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_PROVIDER,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_TIME,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_ACCURACY,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_VERTICAL_ACCURACY,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_SPEED,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_BEARING,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_ALTITUDE,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_RADIUS,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_LATITUDE,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_LONGITUDE,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_ACCURACY,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_VERTICAL_ACCURACY,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_SPEED,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_BEARING,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_ALTITUDE,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_HAS_RADIUS,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_LOCATION_PROVIDER,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_STATUS,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_BATCH_START_MILLIS,
+                SQLiteSessionContract.SessionEntry.COLUMN_NAME_MOCK_FLAGS
+        };
+    }
+}

package/android/common/src/main/java/com/marianhello/bgloc/service/LocationServiceImpl.java

@@ -22,6 +22,7 @@ import android.content.ComponentName;
 import android.content.pm.PackageManager;
 import android.content.pm.ServiceInfo;
 import android.Manifest;
+import android.location.Location;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.os.Binder;
@@ -48,7 +49,9 @@ import com.marianhello.bgloc.data.BackgroundLocation;
 import com.marianhello.bgloc.data.ConfigurationDAO;
 import com.marianhello.bgloc.data.DAOFactory;
 import com.marianhello.bgloc.data.LocationDAO;
+import com.marianhello.bgloc.data.SessionLocationDAO;
 import com.marianhello.bgloc.data.LocationTransform;
+import com.marianhello.bgloc.data.sqlite.SQLiteSessionLocationDAO;
 import com.marianhello.bgloc.headless.AbstractTaskRunner;
 import com.marianhello.bgloc.headless.ActivityTask;
 import com.marianhello.bgloc.headless.LocationTask;
@@ -67,6 +70,8 @@ import com.marianhello.logging.UncaughtExceptionLogger;
 import org.chromium.content.browser.ThreadUtils;
 import org.json.JSONException;
 
+import java.util.Locale;
+
 import static com.marianhello.bgloc.service.LocationServiceIntentBuilder.containsCommand;
 import static com.marianhello.bgloc.service.LocationServiceIntentBuilder.containsMessage;
 import static com.marianhello.bgloc.service.LocationServiceIntentBuilder.getCommand;
@@ -122,6 +127,7 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
     private HandlerThread mHandlerThread;
     private ServiceHandler mServiceHandler;
     private LocationDAO mLocationDAO;
+    private SessionLocationDAO mSessionDAO;
     private PostLocationTask mPostLocationTask;
     private String mHeadlessTaskRunnerClass;
     private TaskRunner mHeadlessTaskRunner;
@@ -156,6 +162,30 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         }
     };
 
+    /** Session start time for notification elapsed time (showTime). */
+    private volatile long mSessionStartTime = 0L;
+    /** Accumulated distance in meters for notification (showDistance). */
+    private volatile double mSessionDistanceMeters = 0.0;
+    private volatile double mLastLat = 0.0;
+    private volatile double mLastLon = 0.0;
+    private volatile boolean mHasLastLocation = false;
+    private static final long NOTIFICATION_UPDATE_INTERVAL_MS = 1000L;
+    private final Runnable mNotificationUpdateRunnable = new Runnable() {
+        @Override
+        public void run() {
+            if (!sIsRunning || !mIsInForeground || mConfig == null) {
+                return;
+            }
+            boolean showTime = Boolean.TRUE.equals(mConfig.getShowTime());
+            boolean showDistance = Boolean.TRUE.equals(mConfig.getShowDistance());
+            if (!showTime && !showDistance) {
+                return;
+            }
+            updateForegroundNotification();
+            mMainHandler.postDelayed(this, NOTIFICATION_UPDATE_INTERVAL_MS);
+        }
+    };
+
     private static LocationTransform sLocationTransform;
     private static LocationProviderFactory sLocationProviderFactory;
 
@@ -228,8 +258,9 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         ContentResolver.setSyncAutomatically(mSyncAccount, authority, true);
 
         mLocationDAO = DAOFactory.createLocationDAO(this);
+        mSessionDAO = new SQLiteSessionLocationDAO(this);
 
-        mPostLocationTask = new PostLocationTask(mLocationDAO,
+        mPostLocationTask = new PostLocationTask(mLocationDAO, mSessionDAO,
                 new PostLocationTask.PostLocationTaskListener() {
                     @Override
                     public void onRequestedAbortUpdates() {
@@ -418,6 +449,12 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
             mMainHandler.postDelayed(mWatchdogRunnable, WATCHDOG_INTERVAL_MS);
         }
 
+        mSessionStartTime = System.currentTimeMillis();
+        mSessionDistanceMeters = 0.0;
+        mLastLat = 0.0;
+        mLastLon = 0.0;
+        mHasLastLocation = false;
+
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
@@ -447,6 +484,7 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         }
 
         mMainHandler.removeCallbacks(mWatchdogRunnable);
+        mMainHandler.removeCallbacks(mNotificationUpdateRunnable);
 
         if (mWakeLock != null && mWakeLock.isHeld()) {
             try {
@@ -461,6 +499,7 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
             mProvider.onStop();
         }
 
+        mIsInForeground = false;
         stopForeground(true);
         stopSelf();
 
@@ -530,9 +569,10 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                 return;
             }
             Config config = getConfig();
+            String contentText = buildNotificationContentText(config);
             Notification notification = new NotificationHelper.NotificationFactory(this).getNotification(
                     config.getNotificationTitle(),
-                    config.getNotificationText(),
+                    contentText,
                     config.getLargeNotificationIcon(),
                     config.getSmallNotificationIcon(),
                     config.getNotificationIconColor());
@@ -548,12 +588,14 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                 super.startForeground(NOTIFICATION_ID, notification);
             }
             mIsInForeground = true;
+            scheduleNotificationUpdater();
         }
     }
 
     @Override
     public synchronized void stopForeground() {
         if (sIsRunning && mIsInForeground) {
+            mMainHandler.removeCallbacks(mNotificationUpdateRunnable);
             stopForeground(true);
             if (mProvider != null) {
                 mProvider.onCommand(LocationProvider.CMD_SWITCH_MODE,
@@ -563,6 +605,70 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
         }
     }
 
+    /** Resource names for optional app-localized notification labels (showTime / showDistance). */
+    private static final String RES_NOTIFICATION_TIME_LABEL = "plugin_bgloc_notification_time_label";
+    private static final String RES_NOTIFICATION_DISTANCE_LABEL = "plugin_bgloc_notification_distance_label";
+
+    private String getNotificationLabel(String resourceName, String defaultValue) {
+        Context app = getApplicationContext();
+        int id = app.getResources().getIdentifier(resourceName, "string", app.getPackageName());
+        return (id != 0) ? app.getString(id) : defaultValue;
+    }
+
+    private String buildNotificationContentText(Config config) {
+        String base = config.getNotificationText() != null ? config.getNotificationText() : "ENABLED";
+        if (Boolean.TRUE.equals(config.getShowTime())) {
+            String timeLabel = getNotificationLabel(RES_NOTIFICATION_TIME_LABEL, "Time");
+            base += "\n" + timeLabel + ": " + formatElapsed(mSessionStartTime);
+        }
+        if (Boolean.TRUE.equals(config.getShowDistance())) {
+            String distanceLabel = getNotificationLabel(RES_NOTIFICATION_DISTANCE_LABEL, "Distance");
+            base += "\n" + distanceLabel + ": " + formatDistance(mSessionDistanceMeters);
+        }
+        return base;
+    }
+
+    private static String formatElapsed(long startTimeMs) {
+        long elapsed = Math.max(0L, System.currentTimeMillis() - startTimeMs);
+        long s = (elapsed / 1000L) % 60L;
+        long m = (elapsed / 60000L) % 60L;
+        long h = elapsed / 3600000L;
+        return String.format(Locale.US, "%02d:%02d:%02d", h, m, s);
+    }
+
+    private static String formatDistance(double meters) {
+        return String.format(Locale.US, "%.2f km", meters / 1000.0);
+    }
+
+    private void updateForegroundNotification() {
+        if (!sIsRunning || !mIsInForeground || mConfig == null) {
+            return;
+        }
+        String contentText = buildNotificationContentText(mConfig);
+        Notification notification = new NotificationHelper.NotificationFactory(this).getNotification(
+                mConfig.getNotificationTitle(),
+                contentText,
+                mConfig.getLargeNotificationIcon(),
+                mConfig.getSmallNotificationIcon(),
+                mConfig.getNotificationIconColor());
+        NotificationManager nm = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+        if (nm != null) {
+            nm.notify(NOTIFICATION_ID, notification);
+        }
+    }
+
+    private void scheduleNotificationUpdater() {
+        mMainHandler.removeCallbacks(mNotificationUpdateRunnable);
+        if (mConfig == null) {
+            return;
+        }
+        boolean showTime = Boolean.TRUE.equals(mConfig.getShowTime());
+        boolean showDistance = Boolean.TRUE.equals(mConfig.getShowDistance());
+        if ((showTime || showDistance) && sIsRunning && mIsInForeground) {
+            mMainHandler.postDelayed(mNotificationUpdateRunnable, NOTIFICATION_UPDATE_INTERVAL_MS);
+        }
+    }
+
     @Override
     public synchronized void configure(Config config) {
         if (mConfig == null) {
@@ -580,7 +686,7 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
             public void run() {
                 if (sIsRunning) {
                     if (currentConfig.getStartForeground() == true && mConfig.getStartForeground() == false) {
-                        stopForeground(true);
+                        stopForeground();
                     }
 
                     if (mConfig.getStartForeground() == true) {
@@ -589,15 +695,17 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
                             startForeground();
                         } else {
                             // was running in foreground, so just update existing notification
+                            String contentText = buildNotificationContentText(mConfig);
                             Notification notification = new NotificationHelper.NotificationFactory(LocationServiceImpl.this).getNotification(
                                     mConfig.getNotificationTitle(),
-                                    mConfig.getNotificationText(),
+                                    contentText,
                                     mConfig.getLargeNotificationIcon(),
                                     mConfig.getSmallNotificationIcon(),
                                     mConfig.getNotificationIconColor());
 
                             NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
                             notificationManager.notify(NOTIFICATION_ID, notification);
+                            scheduleNotificationUpdater();
                         }
                     }
                 }
@@ -661,6 +769,26 @@ public class LocationServiceImpl extends Service implements ProviderDelegate, Lo
     @Override
     public void onLocation(BackgroundLocation location) {
         mLastLocationTime = System.currentTimeMillis();
+        if (Boolean.TRUE.equals(mConfig != null ? mConfig.getShowDistance() : null)) {
+            double lat = location.getLatitude();
+            double lon = location.getLongitude();
+            if (mHasLastLocation) {
+                float[] dist = new float[1];
+                Location.distanceBetween(mLastLat, mLastLon, lat, lon, dist);
+                mSessionDistanceMeters += (double) dist[0];
+            }
+            mLastLat = lat;
+            mLastLon = lon;
+            mHasLastLocation = true;
+            if (mIsInForeground && mConfig != null && (Boolean.TRUE.equals(mConfig.getShowTime()) || Boolean.TRUE.equals(mConfig.getShowDistance()))) {
+                mMainHandler.post(new Runnable() {
+                    @Override
+                    public void run() {
+                        updateForegroundNotification();
+                    }
+                });
+            }
+        }
         logger.debug("New location {}", location.toString());
 
         location = transformLocation(location);

package/angular/background-geolocation.service.ts

@@ -168,6 +168,34 @@ export class BackgroundGeolocationService {
     return this.ensurePlugin().getPendingSyncCount(success, fail);
   }
 
+  startSession(
+    success?: () => void,
+    fail?: (error: any) => void
+  ): Promise<void> {
+    return this.ensurePlugin().startSession(success, fail);
+  }
+
+  getSessionLocations(
+    success?: (locations: any[]) => void,
+    fail?: (error: any) => void
+  ): Promise<any[]> {
+    return this.ensurePlugin().getSessionLocations(success, fail);
+  }
+
+  clearSession(
+    success?: () => void,
+    fail?: (error: any) => void
+  ): Promise<void> {
+    return this.ensurePlugin().clearSession(success, fail);
+  }
+
+  getSessionLocationsCount(
+    success?: (count: number) => void,
+    fail?: (error: any) => void
+  ): Promise<number> {
+    return this.ensurePlugin().getSessionLocationsCount(success, fail);
+  }
+
   getConfig(
     success?: (config: any) => void,
     fail?: (error: any) => void

package/angular/dist/background-geolocation.service.d.ts

@@ -45,6 +45,10 @@ export declare class BackgroundGeolocationService {
     forceSync(success?: () => void, fail?: (error: any) => void): Promise<void>;
     clearSync(success?: () => void, fail?: (error: any) => void): Promise<void>;
     getPendingSyncCount(success?: (count: number) => void, fail?: (error: any) => void): Promise<number>;
+    startSession(success?: () => void, fail?: (error: any) => void): Promise<void>;
+    getSessionLocations(success?: (locations: any[]) => void, fail?: (error: any) => void): Promise<any[]>;
+    clearSession(success?: () => void, fail?: (error: any) => void): Promise<void>;
+    getSessionLocationsCount(success?: (count: number) => void, fail?: (error: any) => void): Promise<number>;
     getConfig(success?: (config: any) => void, fail?: (error: any) => void): Promise<any>;
     getLogEntries(limit: number, fromId: number, minLevel: string, success?: (entries: any[]) => void, fail?: (error: any) => void): Promise<any[]>;
     removeAllListeners(event?: string): void;

package/angular/dist/esm2022/background-geolocation.service.mjs

@@ -97,6 +97,18 @@ export class BackgroundGeolocationService {
     getPendingSyncCount(success, fail) {
         return this.ensurePlugin().getPendingSyncCount(success, fail);
     }
+    startSession(success, fail) {
+        return this.ensurePlugin().startSession(success, fail);
+    }
+    getSessionLocations(success, fail) {
+        return this.ensurePlugin().getSessionLocations(success, fail);
+    }
+    clearSession(success, fail) {
+        return this.ensurePlugin().clearSession(success, fail);
+    }
+    getSessionLocationsCount(success, fail) {
+        return this.ensurePlugin().getSessionLocationsCount(success, fail);
+    }
     getConfig(success, fail) {
         return this.ensurePlugin().getConfig(success, fail);
     }
@@ -151,4 +163,4 @@ export class BackgroundGeolocationService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BackgroundGeolocationService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"background-geolocation.service.js","sourceRoot":"","sources":["../../background-geolocation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, InjectionToken } from '@angular/core';\n\n/**\n * Token used to provide BackgroundGeolocationService without triggering JIT.\n * The module provides this token with useFactory; the class is aliased via useExisting\n * so you still inject constructor(private bg: BackgroundGeolocationService) {}.\n */\nexport const BACKGROUND_GEOLOCATION_SERVICE = new InjectionToken<BackgroundGeolocationService>(\n  'BackgroundGeolocationService'\n);\n\n/**\n * Angular service that wraps the Cordova/Capacitor BackgroundGeolocation plugin.\n * Use dependency injection instead of the global BackgroundGeolocation object.\n *\n * The native plugin must be installed and available (e.g. after deviceready).\n * Types (ConfigureOptions, Location, etc.) can be imported from\n * '@josuelmm/cordova-background-geolocation'.\n *\n * Provided via BackgroundGeolocationModule using an InjectionToken + useFactory\n * so AOT builds never need the JIT compiler for this class.\n */\n@Injectable()\nexport class BackgroundGeolocationService {\n\n  /** Returns the global plugin instance (Cordova/Capacitor). */\n  private get plugin(): any {\n    if (typeof window === 'undefined') return null;\n    return (window as any).BackgroundGeolocation || null;\n  }\n\n  private ensurePlugin(): any {\n    const p = this.plugin;\n    if (!p) {\n      throw new Error(\n        'BackgroundGeolocation is not available. Ensure the plugin is installed and the app is running in a native context (Cordova/Capacitor).'\n      );\n    }\n    return p;\n  }\n\n  configure(options: any, success?: () => void, fail?: (err: any) => void): Promise<void> {\n    return this.ensurePlugin().configure(options, success, fail);\n  }\n\n  start(): Promise<void> {\n    return this.ensurePlugin().start();\n  }\n\n  stop(): Promise<void> {\n    return this.ensurePlugin().stop();\n  }\n\n  /** Inform the native plugin that the background task may complete (iOS). Call after handling location/stationary in the callback. */\n  finish(): Promise<void> {\n    return this.ensurePlugin().finish();\n  }\n\n  /** Force the plugin to enter \"moving\" or \"stationary\" state (iOS). */\n  changePace(isMoving: boolean): Promise<void> {\n    return this.ensurePlugin().changePace(isMoving);\n  }\n\n  getCurrentLocation(\n    success?: (location: any) => void,\n    fail?: (error: any) => void,\n    options?: any\n  ): Promise<any> {\n    return this.ensurePlugin().getCurrentLocation(success, fail, options);\n  }\n\n  getStationaryLocation(\n    success?: (location: any) => void,\n    fail?: (error: any) => void\n  ): Promise<any> {\n    return this.ensurePlugin().getStationaryLocation(success, fail);\n  }\n\n  checkStatus(\n    success?: (status: any) => void,\n    fail?: (error: any) => void\n  ): Promise<any> {\n    return this.ensurePlugin().checkStatus(success, fail);\n  }\n\n  showAppSettings(): Promise<void> {\n    return this.ensurePlugin().showAppSettings();\n  }\n\n  /** Open app settings (alias for showAppSettings). */\n  openSettings(): Promise<void> {\n    return this.ensurePlugin().openSettings();\n  }\n\n  showLocationSettings(): Promise<void> {\n    return this.ensurePlugin().showLocationSettings();\n  }\n\n  getPluginVersion(\n    success?: (version: string) => void,\n    fail?: (error: any) => void\n  ): Promise<string> {\n    return this.ensurePlugin().getPluginVersion(success, fail);\n  }\n\n  getLocations(\n    success?: (locations: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getLocations(success, fail);\n  }\n\n  getValidLocations(\n    success?: (locations: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getValidLocations(success, fail);\n  }\n\n  getValidLocationsAndDelete(\n    success?: (locations: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getValidLocationsAndDelete(success, fail);\n  }\n\n  deleteLocation(\n    locationId: number,\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().deleteLocation(locationId, success, fail);\n  }\n\n  deleteAllLocations(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().deleteAllLocations(success, fail);\n  }\n\n  switchMode(\n    modeId: number,\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().switchMode(modeId, success, fail);\n  }\n\n  forceSync(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().forceSync(success, fail);\n  }\n\n  clearSync(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().clearSync(success, fail);\n  }\n\n  getPendingSyncCount(\n    success?: (count: number) => void,\n    fail?: (error: any) => void\n  ): Promise<number> {\n    return this.ensurePlugin().getPendingSyncCount(success, fail);\n  }\n\n  getConfig(\n    success?: (config: any) => void,\n    fail?: (error: any) => void\n  ): Promise<any> {\n    return this.ensurePlugin().getConfig(success, fail);\n  }\n\n  getLogEntries(\n    limit: number,\n    fromId: number,\n    minLevel: string,\n    success?: (entries: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getLogEntries(limit, fromId, minLevel, success, fail);\n  }\n\n  removeAllListeners(event?: string): void {\n    this.ensurePlugin().removeAllListeners(event);\n  }\n\n  startTask(\n    success?: (taskKey: number) => void,\n    fail?: (error: any) => void\n  ): Promise<number> {\n    return this.ensurePlugin().startTask(success, fail);\n  }\n\n  endTask(\n    taskKey: number,\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().endTask(taskKey, success, fail);\n  }\n\n  headlessTask(task: (event: any) => void): void {\n    this.ensurePlugin().headlessTask(task);\n  }\n\n  /**\n   * Register an event listener. Compatible with Awesome-style usage:\n   * .on(BackgroundGeolocationEvents.error).subscribe((err) => ...) — returns subscription with .unsubscribe().\n   * .on('location', (loc) => ...) — also supported; returned object has .unsubscribe().\n   */\n  on(eventName: string, callback?: (value: any) => void): { subscribe(cb: (value: any) => void): { unsubscribe(): void }; unsubscribe(): void } {\n    const plugin = this.ensurePlugin();\n    if (callback !== undefined) {\n      const sub = plugin.on(eventName, callback) as { remove?: () => void };\n      return {\n        subscribe(cb: (value: any) => void) {\n          const s = cb ? (plugin.on(eventName, cb) as { remove?: () => void }) : null;\n          return { unsubscribe() { s?.remove?.(); } };\n        },\n        unsubscribe() { sub.remove?.(); }\n      };\n    }\n    const channel = plugin.on(eventName) as { subscribe: (cb: (v: any) => void) => void; unsubscribe: (cb: (v: any) => void) => void };\n    return {\n      subscribe(cb: (value: any) => void) {\n        channel.subscribe(cb);\n        return { unsubscribe() { channel.unsubscribe(cb); } };\n      },\n      unsubscribe() { /* no-op when no callback */ }\n    };\n  }\n\n  /** Convenience: access plugin constants (e.g. ACTIVITY_PROVIDER, HIGH_ACCURACY). */\n  get native(): any {\n    return this.plugin;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"background-geolocation.service.js","sourceRoot":"","sources":["../../background-geolocation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, InjectionToken } from '@angular/core';\n\n/**\n * Token used to provide BackgroundGeolocationService without triggering JIT.\n * The module provides this token with useFactory; the class is aliased via useExisting\n * so you still inject constructor(private bg: BackgroundGeolocationService) {}.\n */\nexport const BACKGROUND_GEOLOCATION_SERVICE = new InjectionToken<BackgroundGeolocationService>(\n  'BackgroundGeolocationService'\n);\n\n/**\n * Angular service that wraps the Cordova/Capacitor BackgroundGeolocation plugin.\n * Use dependency injection instead of the global BackgroundGeolocation object.\n *\n * The native plugin must be installed and available (e.g. after deviceready).\n * Types (ConfigureOptions, Location, etc.) can be imported from\n * '@josuelmm/cordova-background-geolocation'.\n *\n * Provided via BackgroundGeolocationModule using an InjectionToken + useFactory\n * so AOT builds never need the JIT compiler for this class.\n */\n@Injectable()\nexport class BackgroundGeolocationService {\n\n  /** Returns the global plugin instance (Cordova/Capacitor). */\n  private get plugin(): any {\n    if (typeof window === 'undefined') return null;\n    return (window as any).BackgroundGeolocation || null;\n  }\n\n  private ensurePlugin(): any {\n    const p = this.plugin;\n    if (!p) {\n      throw new Error(\n        'BackgroundGeolocation is not available. Ensure the plugin is installed and the app is running in a native context (Cordova/Capacitor).'\n      );\n    }\n    return p;\n  }\n\n  configure(options: any, success?: () => void, fail?: (err: any) => void): Promise<void> {\n    return this.ensurePlugin().configure(options, success, fail);\n  }\n\n  start(): Promise<void> {\n    return this.ensurePlugin().start();\n  }\n\n  stop(): Promise<void> {\n    return this.ensurePlugin().stop();\n  }\n\n  /** Inform the native plugin that the background task may complete (iOS). Call after handling location/stationary in the callback. */\n  finish(): Promise<void> {\n    return this.ensurePlugin().finish();\n  }\n\n  /** Force the plugin to enter \"moving\" or \"stationary\" state (iOS). */\n  changePace(isMoving: boolean): Promise<void> {\n    return this.ensurePlugin().changePace(isMoving);\n  }\n\n  getCurrentLocation(\n    success?: (location: any) => void,\n    fail?: (error: any) => void,\n    options?: any\n  ): Promise<any> {\n    return this.ensurePlugin().getCurrentLocation(success, fail, options);\n  }\n\n  getStationaryLocation(\n    success?: (location: any) => void,\n    fail?: (error: any) => void\n  ): Promise<any> {\n    return this.ensurePlugin().getStationaryLocation(success, fail);\n  }\n\n  checkStatus(\n    success?: (status: any) => void,\n    fail?: (error: any) => void\n  ): Promise<any> {\n    return this.ensurePlugin().checkStatus(success, fail);\n  }\n\n  showAppSettings(): Promise<void> {\n    return this.ensurePlugin().showAppSettings();\n  }\n\n  /** Open app settings (alias for showAppSettings). */\n  openSettings(): Promise<void> {\n    return this.ensurePlugin().openSettings();\n  }\n\n  showLocationSettings(): Promise<void> {\n    return this.ensurePlugin().showLocationSettings();\n  }\n\n  getPluginVersion(\n    success?: (version: string) => void,\n    fail?: (error: any) => void\n  ): Promise<string> {\n    return this.ensurePlugin().getPluginVersion(success, fail);\n  }\n\n  getLocations(\n    success?: (locations: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getLocations(success, fail);\n  }\n\n  getValidLocations(\n    success?: (locations: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getValidLocations(success, fail);\n  }\n\n  getValidLocationsAndDelete(\n    success?: (locations: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getValidLocationsAndDelete(success, fail);\n  }\n\n  deleteLocation(\n    locationId: number,\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().deleteLocation(locationId, success, fail);\n  }\n\n  deleteAllLocations(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().deleteAllLocations(success, fail);\n  }\n\n  switchMode(\n    modeId: number,\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().switchMode(modeId, success, fail);\n  }\n\n  forceSync(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().forceSync(success, fail);\n  }\n\n  clearSync(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().clearSync(success, fail);\n  }\n\n  getPendingSyncCount(\n    success?: (count: number) => void,\n    fail?: (error: any) => void\n  ): Promise<number> {\n    return this.ensurePlugin().getPendingSyncCount(success, fail);\n  }\n\n  startSession(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().startSession(success, fail);\n  }\n\n  getSessionLocations(\n    success?: (locations: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getSessionLocations(success, fail);\n  }\n\n  clearSession(\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().clearSession(success, fail);\n  }\n\n  getSessionLocationsCount(\n    success?: (count: number) => void,\n    fail?: (error: any) => void\n  ): Promise<number> {\n    return this.ensurePlugin().getSessionLocationsCount(success, fail);\n  }\n\n  getConfig(\n    success?: (config: any) => void,\n    fail?: (error: any) => void\n  ): Promise<any> {\n    return this.ensurePlugin().getConfig(success, fail);\n  }\n\n  getLogEntries(\n    limit: number,\n    fromId: number,\n    minLevel: string,\n    success?: (entries: any[]) => void,\n    fail?: (error: any) => void\n  ): Promise<any[]> {\n    return this.ensurePlugin().getLogEntries(limit, fromId, minLevel, success, fail);\n  }\n\n  removeAllListeners(event?: string): void {\n    this.ensurePlugin().removeAllListeners(event);\n  }\n\n  startTask(\n    success?: (taskKey: number) => void,\n    fail?: (error: any) => void\n  ): Promise<number> {\n    return this.ensurePlugin().startTask(success, fail);\n  }\n\n  endTask(\n    taskKey: number,\n    success?: () => void,\n    fail?: (error: any) => void\n  ): Promise<void> {\n    return this.ensurePlugin().endTask(taskKey, success, fail);\n  }\n\n  headlessTask(task: (event: any) => void): void {\n    this.ensurePlugin().headlessTask(task);\n  }\n\n  /**\n   * Register an event listener. Compatible with Awesome-style usage:\n   * .on(BackgroundGeolocationEvents.error).subscribe((err) => ...) — returns subscription with .unsubscribe().\n   * .on('location', (loc) => ...) — also supported; returned object has .unsubscribe().\n   */\n  on(eventName: string, callback?: (value: any) => void): { subscribe(cb: (value: any) => void): { unsubscribe(): void }; unsubscribe(): void } {\n    const plugin = this.ensurePlugin();\n    if (callback !== undefined) {\n      const sub = plugin.on(eventName, callback) as { remove?: () => void };\n      return {\n        subscribe(cb: (value: any) => void) {\n          const s = cb ? (plugin.on(eventName, cb) as { remove?: () => void }) : null;\n          return { unsubscribe() { s?.remove?.(); } };\n        },\n        unsubscribe() { sub.remove?.(); }\n      };\n    }\n    const channel = plugin.on(eventName) as { subscribe: (cb: (v: any) => void) => void; unsubscribe: (cb: (v: any) => void) => void };\n    return {\n      subscribe(cb: (value: any) => void) {\n        channel.subscribe(cb);\n        return { unsubscribe() { channel.unsubscribe(cb); } };\n      },\n      unsubscribe() { /* no-op when no callback */ }\n    };\n  }\n\n  /** Convenience: access plugin constants (e.g. ACTIVITY_PROVIDER, HIGH_ACCURACY). */\n  get native(): any {\n    return this.plugin;\n  }\n}\n"]}