@josuelmm/capacitor-background-geolocation 1.0.0

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

@@ -0,0 +1,321 @@
+package com.marianhello.bgloc.data.provider;
+
+import android.content.ContentProvider;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.text.TextUtils;
+
+import com.marianhello.bgloc.ResourceResolver;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry;
+import com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper;
+
+/**
+ * Content provider implementation based on
+ * https://shellmonger.com/2017/06/28/android-notes-app-content-providers/
+ */
+public class LocationContentProvider extends ContentProvider {
+
+    /**
+     * Creates a UriMatcher for matching the path elements for this content provider
+     */
+    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+
+    /**
+     * The code for the UriMatch matching all notes
+     */
+    private static final int ALL_ITEMS = 10;
+
+    /**
+     * The code for the UriMatch matching a single note
+     */
+    private static final int ONE_ITEM = 20;
+
+    /**
+     * The database helper for this content provider
+     */
+    private SQLiteOpenHelper mDatabaseHelper;
+
+    /*
+     * Initialize the UriMatcher with the URIs that this content provider handles
+     *
+     * All paths added to the UriMatcher have a corresponding code to return when a match is
+     * found. The code passed into the constructor of UriMatcher here represents the code to
+     * return for the root URI. It's common to use NO_MATCH as the code for this case.
+     */
+    private static void initialize(String authority) {
+
+        /* This URI is content://com.example.location/location/ */
+        sUriMatcher.addURI(
+                authority,
+                LocationEntry.TABLE_NAME,
+                ALL_ITEMS);
+
+
+        /*
+         * This URI would look something like content://com.example.location/location/1
+         * The "/#" signifies to the UriMatcher that if TABLE_NAME is followed by ANY number,
+         * that it should return the ONE_ITEM code
+         */
+        sUriMatcher.addURI(
+                authority,
+                LocationEntry.TABLE_NAME + "/#",
+                ONE_ITEM);
+    }
+
+    /**
+     * Part of the Content Provider interface.  The system calls onCreate() when it starts up
+     * the provider.  You should only perform fast-running initialization tasks in this method.
+     * Defer database creation and data loading until the provider actually receives a request
+     * for the data.  This runs on the UI thread.
+     *
+     * @return true if the provider was successfully loaded; false otherwise
+     */
+    @Override
+    public boolean onCreate() {
+        Context context = getContext();
+        ResourceResolver resourceResolver = ResourceResolver.newInstance(getContext());
+        initialize(resourceResolver.getAuthority());
+        mDatabaseHelper = new SQLiteOpenHelper(context);
+        return true;
+    }
+
+    /**
+     * The content provider must return the content type for its supported URIs.  The supported
+     * URIs are defined in the UriMatcher
+     *
+     * As we don't export this content provider, we return null here.
+     *
+     * @param uri the URI for typing
+     * @return the type of the URI
+     */
+    @Override
+    public String getType(Uri uri) {
+        return null;
+    }
+
+    /**
+     * Handles query requests from clients. We will use this method to query for all
+     * of our location data as well as to query for the specific location record.
+     *
+     * @param uri           The URI to query
+     * @param projection    The list of columns to put into the cursor. If null, all columns are
+     *                      included.
+     * @param selection     A selection criteria to apply when filtering rows. If null, then all
+     *                      rows are included.
+     * @param selectionArgs You may include ?s in selection, which will be replaced by
+     *                      the values from selectionArgs, in order that they appear in the
+     *                      selection.
+     * @param sortOrder     How the rows in the cursor should be sorted.
+     * @return A Cursor containing the results of the query. In our implementation,
+     */
+    @Override
+    public Cursor query(
+            Uri uri,
+            String[] projection,
+            String selection,
+            String[] selectionArgs,
+            String sortOrder) {
+
+        int uriType = sUriMatcher.match(uri);
+        SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
+        SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
+
+        switch (uriType) {
+            /*
+             * When sUriMatcher's match method is called with a URI that looks EXACTLY like this
+             *
+             *      content://com.example.location/location
+             *
+             * sUriMatcher's match method will return the code that indicates to us that we need
+             * to return all of the records in our location table.
+             *
+             * In this case, we want to return a cursor that contains every record
+             * in our location table.
+             */
+            case ALL_ITEMS:
+                queryBuilder.setTables(LocationEntry.TABLE_NAME);
+                if (TextUtils.isEmpty(sortOrder)) {
+                    sortOrder = LocationEntry.COLUMN_NAME_TIME + " ASC";
+                }
+                break;
+
+
+            /*
+             * When sUriMatcher's match method is called with a URI that looks something like this
+             *
+             *      content://com.example.location/location/2
+             *
+             * sUriMatcher's match method will return the code that indicates to us that we need
+             * to return the location for a particular id. The id in this code is encoded in
+             * int and is at the very end of the URI (2) and can be accessed
+             * programmatically using Uri's getLastPathSegment method.
+             *
+             * In this case, we want to return a cursor that contains one row of location data for
+             * a particular date.
+             */
+            case ONE_ITEM:
+                queryBuilder.setTables(LocationEntry.TABLE_NAME);
+                queryBuilder.appendWhere(LocationEntry._ID + " = " + uri.getLastPathSegment());
+                break;
+
+            default:
+                throw new IllegalArgumentException("Unsupported URI: " + uri);
+        }
+
+        Cursor cursor = queryBuilder.query(db, projection, selection, selectionArgs, null, null, sortOrder);
+        cursor.setNotificationUri(getContext().getContentResolver(), uri);
+        return cursor;
+    }
+
+    /**
+     * Insert a new record into the database.
+     *
+     * @param uri the base URI to insert at (must be a directory-based URI)
+     * @param values the values to be inserted
+     * @return the URI of the inserted item
+     */
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        int uriType = sUriMatcher.match(uri);
+        switch (uriType) {
+            case ALL_ITEMS:
+                SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
+                long id = db.insert(
+                        LocationEntry.TABLE_NAME,
+                        null,
+                        values);
+                if (id > 0) {
+                    Uri item = ContentUris.withAppendedId(uri, id);
+                    notifyAllListeners(item);
+                    return item;
+                }
+
+                throw new SQLException("Error inserting for URI " + uri + " result:" + id);
+            default:
+                throw new IllegalArgumentException("Unsupported URI: " + uri);
+        }
+    }
+
+    /**
+     * Delete one or more records from the SQLite database.
+     *
+     * @param uri the URI of the record(s) to delete
+     * @param selection A WHERE clause to use for the deletion
+     * @param selectionArgs Any arguments to replace the ? in the selection
+     * @return the number of rows deleted.
+     */
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        int uriType = sUriMatcher.match(uri);
+        int rows;
+        SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
+        switch (uriType) {
+            case ALL_ITEMS:
+                rows = db.delete(
+                        LocationEntry.TABLE_NAME,  // The table name
+                        selection, selectionArgs); // The WHERE clause
+                break;
+            case ONE_ITEM:
+                String where = LocationEntry._ID + " = " + uri.getLastPathSegment();
+                if (!TextUtils.isEmpty(selection)) {
+                    where += " AND " + selection;
+                }
+                rows = db.delete(
+                        LocationEntry.TABLE_NAME,  // The table name
+                        where, selectionArgs);     // The WHERE clause
+                break;
+            default:
+                throw new IllegalArgumentException("Unsupported URI: " + uri);
+        }
+        if (rows > 0) {
+            notifyAllListeners(uri);
+        }
+        return rows;
+    }
+
+    @Override
+    public int update(
+            Uri uri,
+            ContentValues values,
+            String selection,
+            String[] selectionArgs) {
+        int uriType = sUriMatcher.match(uri);
+        int rows;
+        SQLiteDatabase db = mDatabaseHelper.getWritableDatabase();
+        switch (uriType) {
+            case ALL_ITEMS:
+                rows = db.update(
+                        LocationEntry.TABLE_NAME,  // The table name
+                        values,                    // The values to replace
+                        selection, selectionArgs); // The WHERE clause
+                break;
+            case ONE_ITEM:
+                String where = LocationEntry._ID + " = " + uri.getLastPathSegment();
+                if (!TextUtils.isEmpty(selection)) {
+                    where += " AND " + selection;
+                }
+                rows = db.update(
+                        LocationEntry.TABLE_NAME,  // The table name
+                        values,                    // The values to replace
+                        where, selectionArgs);     // The WHERE clause
+                break;
+            default:
+                throw new IllegalArgumentException("Unsupported URI: " + uri);
+        }
+        if (rows > 0) {
+            notifyAllListeners(uri);
+        }
+        return rows;
+    }
+
+    /**
+     * Notify all listeners that the specified URI has changed
+     * @param uri the URI that changed
+     */
+    private void notifyAllListeners(Uri uri) {
+        ContentResolver resolver = getContext().getContentResolver();
+        if (resolver != null) {
+            resolver.notifyChange(uri, null);
+        }
+    }
+
+    /**
+     * The base CONTENT_URI used to query the Location table from the content provider
+     */
+    public static Uri getBaseContentUri(String authority) {
+        return Uri.parse("content://" + authority);
+    }
+
+    /**
+     * The content URI for this table
+     */
+    public static Uri getContentUri(String authority) {
+        return getBaseContentUri(authority).buildUpon()
+                .appendPath(LocationEntry.TABLE_NAME)
+                .build();
+    }
+
+    /**
+     * Builds a URI that adds the task _ID to the end of the location content URI path.
+     * This is used to query details about a single location entry by _ID. This is what we
+     * use for the detail view query.
+     *
+     * @param authority The authority of the locations content provider
+     * @param id Unique id pointing to that row
+     * @return Uri to query details about a single location entry
+     */
+    public static Uri buildUriWithId(String authority, long id) {
+        return getContentUri(authority).buildUpon()
+                .appendPath(Long.toString(id))
+                .build();
+    }
+}
+

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

@@ -0,0 +1,94 @@
+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;
+
+public final class SQLiteConfigurationContract {
+    // To prevent someone from accidentally instantiating the contract class,
+    // give it an empty constructor.
+    public SQLiteConfigurationContract() {}
+
+    /* Inner class that defines the table contents */
+    public static abstract class ConfigurationEntry implements BaseColumns {
+        public static final String TABLE_NAME = "configuration";
+        public static final String COLUMN_NAME_NULLABLE = "NULLHACK";
+        public static final String COLUMN_NAME_RADIUS = "stationary_radius";
+        public static final String COLUMN_NAME_DISTANCE_FILTER = "distance_filter";
+        public static final String COLUMN_NAME_DESIRED_ACCURACY = "desired_accuracy";
+        public static final String COLUMN_NAME_DEBUG = "debugging";
+        public static final String COLUMN_NAME_NOTIF_TITLE = "notification_title";
+        public static final String COLUMN_NAME_NOTIF_TEXT = "notification_text";
+        public static final String COLUMN_NAME_NOTIF_SYNC_TITLE = "notification_sync_title";
+        public static final String COLUMN_NAME_NOTIF_SYNC_TEXT = "notification_sync_text";
+        public static final String COLUMN_NAME_NOTIF_SYNC_COMPLETED = "notification_sync_completed_text";
+        public static final String COLUMN_NAME_NOTIF_SYNC_FAILED = "notification_sync_failed_text";
+        public static final String COLUMN_NAME_NOTIF_ICON_LARGE = "notification_icon_large";
+        public static final String COLUMN_NAME_NOTIF_ICON_SMALL = "notification_icon_small";
+        public static final String COLUMN_NAME_NOTIF_COLOR = "notification_icon_color";
+        public static final String COLUMN_NAME_STOP_TERMINATE = "stop_terminate";
+        public static final String COLUMN_NAME_START_BOOT = "start_boot";
+        public static final String COLUMN_NAME_START_FOREGROUND = "start_foreground";
+        public static final String COLUMN_NAME_NOTIFICATIONS_ENABLED = "notifications_enabled";
+        public static final String COLUMN_NAME_STOP_ON_STILL = "stop_still";
+        public static final String COLUMN_NAME_LOCATION_PROVIDER = "service_provider";
+        public static final String COLUMN_NAME_INTERVAL = "interval";
+        public static final String COLUMN_NAME_FASTEST_INTERVAL = "fastest_interval";
+        public static final String COLUMN_NAME_ACTIVITIES_INTERVAL = "activities_interval";
+        public static final String COLUMN_NAME_URL = "url";
+        public static final String COLUMN_NAME_SYNC_URL = "sync_url";
+        public static final String COLUMN_NAME_SYNC_THRESHOLD = "sync_threshold";
+        public static final String COLUMN_NAME_SYNC_ENABLED = "sync_enabled";
+        public static final String COLUMN_NAME_HEADERS = "http_headers";
+        public static final String COLUMN_NAME_MAX_LOCATIONS = "max_locations";
+        public static final String COLUMN_NAME_TEMPLATE = "template";
+        public static final String COLUMN_NAME_SHOW_TIME = "show_time";
+        public static final String COLUMN_NAME_SHOW_DISTANCE = "show_distance";
+        // v4.4.1 — single JSON blob holding the full config (replaces per-field columns
+        // for new keys). Old columns are kept for backward compat with v20 databases.
+        public static final String COLUMN_NAME_CONFIG_JSON = "config_json";
+
+        public 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_SYNC_TITLE + TEXT_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TEXT + TEXT_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_COMPLETED + TEXT_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_FAILED + 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_STOP_ON_STILL + 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_NOTIFICATIONS_ENABLED + 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_SYNC_URL + TEXT_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_SYNC_THRESHOLD + INTEGER_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_SYNC_ENABLED + INTEGER_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_HEADERS + TEXT_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_MAX_LOCATIONS + INTEGER_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_TEMPLATE + TEXT_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_SHOW_TIME + INTEGER_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE + INTEGER_TYPE + COMMA_SEP +
+                        ConfigurationEntry.COLUMN_NAME_CONFIG_JSON + TEXT_TYPE +
+                        " )";
+
+        public static final String SQL_DROP_CONFIG_TABLE =
+                "DROP TABLE IF EXISTS " + ConfigurationEntry.TABLE_NAME;
+    }
+}

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

@@ -0,0 +1,227 @@
+package com.marianhello.bgloc.data.sqlite;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.util.Log;
+
+import org.json.JSONObject;
+import org.json.JSONException;
+
+import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.data.ConfigJsonMapper;
+import com.marianhello.bgloc.data.ConfigurationDAO;
+import com.marianhello.bgloc.data.LocationTemplateFactory;
+import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract.ConfigurationEntry;
+
+public class SQLiteConfigurationDAO implements ConfigurationDAO {
+  private static final String TAG = SQLiteConfigurationDAO.class.getName();
+
+    private SQLiteDatabase db;
+
+  public SQLiteConfigurationDAO(Context context) {
+    SQLiteOpenHelper helper = SQLiteOpenHelper.getHelper(context);
+    this.db = helper.getWritableDatabase();
+  }
+
+  public SQLiteConfigurationDAO(SQLiteDatabase db) {
+    this.db = db;
+  }
+
+  public Config retrieveConfiguration() throws JSONException {
+    Cursor cursor = null;
+
+    String[] columns = {
+      ConfigurationEntry._ID,
+      ConfigurationEntry.COLUMN_NAME_RADIUS,
+      ConfigurationEntry.COLUMN_NAME_DISTANCE_FILTER,
+      ConfigurationEntry.COLUMN_NAME_DESIRED_ACCURACY,
+      ConfigurationEntry.COLUMN_NAME_DEBUG,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_TITLE,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_TEXT,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TITLE,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TEXT,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_COMPLETED,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_FAILED,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_LARGE,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_SMALL,
+      ConfigurationEntry.COLUMN_NAME_NOTIF_COLOR,
+      ConfigurationEntry.COLUMN_NAME_STOP_TERMINATE,
+      ConfigurationEntry.COLUMN_NAME_STOP_ON_STILL,
+      ConfigurationEntry.COLUMN_NAME_START_BOOT,
+      ConfigurationEntry.COLUMN_NAME_START_FOREGROUND,
+      ConfigurationEntry.COLUMN_NAME_NOTIFICATIONS_ENABLED,
+      ConfigurationEntry.COLUMN_NAME_LOCATION_PROVIDER,
+      ConfigurationEntry.COLUMN_NAME_INTERVAL,
+      ConfigurationEntry.COLUMN_NAME_FASTEST_INTERVAL,
+      ConfigurationEntry.COLUMN_NAME_ACTIVITIES_INTERVAL,
+      ConfigurationEntry.COLUMN_NAME_URL,
+      ConfigurationEntry.COLUMN_NAME_SYNC_URL,
+      ConfigurationEntry.COLUMN_NAME_SYNC_THRESHOLD,
+      ConfigurationEntry.COLUMN_NAME_SYNC_ENABLED,
+      ConfigurationEntry.COLUMN_NAME_HEADERS,
+      ConfigurationEntry.COLUMN_NAME_MAX_LOCATIONS,
+      ConfigurationEntry.COLUMN_NAME_TEMPLATE,
+      ConfigurationEntry.COLUMN_NAME_SHOW_TIME,
+      ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE,
+      ConfigurationEntry.COLUMN_NAME_CONFIG_JSON
+    };
+
+    String whereClause = null;
+    String[] whereArgs = null;
+    String groupBy = null;
+    String having = null;
+    String orderBy = null;
+
+    Config config = null;
+    try {
+      cursor = db.query(
+          ConfigurationEntry.TABLE_NAME,  // The table to query
+          columns,                   // The columns to return
+          whereClause,               // The columns for the WHERE clause
+          whereArgs,                 // The values for the WHERE clause
+          groupBy,                   // don't group the rows
+          having,                    // don't filter by row groups
+          orderBy                    // The sort order
+      );
+      if (cursor.moveToFirst()) {
+        config = hydrate(cursor);
+      }
+    } finally {
+      if (cursor != null) {
+        cursor.close();
+      }
+    }
+    return config;
+  }
+
+  public boolean persistConfiguration(Config config) throws NullPointerException {
+    long rowId = db.replace(ConfigurationEntry.TABLE_NAME, ConfigurationEntry.COLUMN_NAME_NULLABLE, getContentValues(config));
+    Log.d(TAG, "Configuration persisted with rowId = " + rowId);
+    if (rowId > -1) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  private Config hydrate(Cursor c) throws JSONException {
+    // v4.4.1: prefer the full JSON blob if present (covers all keys, including post-3.2 ones).
+    // Note: `template` (postTemplate) lives in its dedicated column — restore it after the
+    // JSON deserialization so it's not lost when the config arrived via config_json only.
+    int idxJson = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_CONFIG_JSON);
+    if (idxJson >= 0 && !c.isNull(idxJson)) {
+      String json = c.getString(idxJson);
+      if (json != null && !json.isEmpty()) {
+        try {
+          Config restored = ConfigJsonMapper.fromJSONObject(new JSONObject(json));
+          int idxTpl = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_TEMPLATE);
+          if (idxTpl >= 0 && !c.isNull(idxTpl)) {
+            restored.setTemplate(LocationTemplateFactory.fromJSONString(c.getString(idxTpl)));
+          }
+          return restored;
+        } catch (JSONException ex) {
+          Log.w(TAG, "config_json parse failed; falling back to legacy columns: " + ex.getMessage());
+        }
+      }
+    }
+    // Legacy hydration (DBs upgraded from v20 or earlier where config_json is still NULL).
+    Config config = Config.getDefault();
+    config.setStationaryRadius(c.getFloat(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_RADIUS)));
+    config.setDistanceFilter(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_DISTANCE_FILTER)));
+    config.setDesiredAccuracy(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_DESIRED_ACCURACY)));
+    config.setDebugging( (c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_DEBUG)) == 1) ? true : false );
+    config.setNotificationTitle(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_TITLE)));
+    config.setNotificationText(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_TEXT)));
+    int idxSyncTitle = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TITLE);
+    if (idxSyncTitle >= 0) {
+      if (!c.isNull(idxSyncTitle)) config.setNotificationSyncTitle(c.getString(idxSyncTitle));
+      int idxSyncText = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TEXT);
+      if (idxSyncText >= 0 && !c.isNull(idxSyncText)) config.setNotificationSyncText(c.getString(idxSyncText));
+      int idxSyncCompleted = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_COMPLETED);
+      if (idxSyncCompleted >= 0 && !c.isNull(idxSyncCompleted)) config.setNotificationSyncCompletedText(c.getString(idxSyncCompleted));
+      int idxSyncFailed = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_FAILED);
+      if (idxSyncFailed >= 0 && !c.isNull(idxSyncFailed)) config.setNotificationSyncFailedText(c.getString(idxSyncFailed));
+    }
+    config.setSmallNotificationIcon(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_SMALL)));
+    config.setLargeNotificationIcon(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_LARGE)));
+    config.setNotificationIconColor(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIF_COLOR)));
+    config.setStopOnTerminate( (c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_STOP_TERMINATE)) == 1) ? true : false );
+    config.setStopOnStillActivity( (c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_STOP_ON_STILL)) == 1) ? true : false );
+    config.setStartOnBoot( (c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_START_BOOT)) == 1) ? true : false );
+    config.setStartForeground( (c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_START_FOREGROUND)) == 1) ? true : false );
+    config.setNotificationsEnabled( (c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_NOTIFICATIONS_ENABLED)) == 1) ? true : false );
+    config.setLocationProvider(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_LOCATION_PROVIDER)));
+    config.setInterval(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_INTERVAL)));
+    config.setFastestInterval(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_FASTEST_INTERVAL)));
+    config.setActivitiesInterval(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_ACTIVITIES_INTERVAL)));
+    config.setUrl(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_URL)));
+    config.setSyncUrl(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_SYNC_URL)));
+    config.setSyncThreshold(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_SYNC_THRESHOLD)));
+    int idxSyncEnabled = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_SYNC_ENABLED);
+    if (idxSyncEnabled >= 0 && !c.isNull(idxSyncEnabled)) {
+      config.setSyncEnabled(c.getInt(idxSyncEnabled) == 1);
+    }
+    config.setHttpHeaders(new JSONObject(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_HEADERS))));
+    config.setMaxLocations(c.getInt(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_MAX_LOCATIONS)));
+    config.setTemplate(LocationTemplateFactory.fromJSONString(c.getString(c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_TEMPLATE))));
+    int idxShowTime = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_SHOW_TIME);
+    if (idxShowTime >= 0 && !c.isNull(idxShowTime)) {
+      config.setShowTime(c.getInt(idxShowTime) == 1);
+    }
+    int idxShowDistance = c.getColumnIndex(ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE);
+    if (idxShowDistance >= 0 && !c.isNull(idxShowDistance)) {
+      config.setShowDistance(c.getInt(idxShowDistance) == 1);
+    }
+
+    return config;
+  }
+
+  private ContentValues getContentValues(Config config) throws NullPointerException {
+    ContentValues values = new ContentValues();
+    values.put(ConfigurationEntry._ID, 1);
+    values.put(ConfigurationEntry.COLUMN_NAME_RADIUS, config.getStationaryRadius());
+    values.put(ConfigurationEntry.COLUMN_NAME_DISTANCE_FILTER, config.getDistanceFilter());
+    values.put(ConfigurationEntry.COLUMN_NAME_DESIRED_ACCURACY, config.getDesiredAccuracy());
+    values.put(ConfigurationEntry.COLUMN_NAME_DEBUG, (config.isDebugging() == true) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_TITLE, config.getNotificationTitle());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_TEXT, config.getNotificationText());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TITLE, config.getNotificationSyncTitle());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TEXT, config.getNotificationSyncText());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_COMPLETED, config.getNotificationSyncCompletedText());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_FAILED, config.getNotificationSyncFailedText());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_SMALL, config.getSmallNotificationIcon());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_ICON_LARGE, config.getLargeNotificationIcon());
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIF_COLOR, config.getNotificationIconColor());
+    values.put(ConfigurationEntry.COLUMN_NAME_STOP_TERMINATE, (config.getStopOnTerminate() == true) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_STOP_ON_STILL, (config.getStopOnStillActivity() == true) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_START_BOOT, (config.getStartOnBoot() == true) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_START_FOREGROUND, (config.getStartForeground() == true) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_NOTIFICATIONS_ENABLED, (config.getNotificationsEnabled() == true) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_LOCATION_PROVIDER, config.getLocationProvider());
+    values.put(ConfigurationEntry.COLUMN_NAME_INTERVAL, config.getInterval());
+    values.put(ConfigurationEntry.COLUMN_NAME_FASTEST_INTERVAL, config.getFastestInterval());
+    values.put(ConfigurationEntry.COLUMN_NAME_ACTIVITIES_INTERVAL, config.getActivitiesInterval());
+    values.put(ConfigurationEntry.COLUMN_NAME_URL, config.getUrl());
+    values.put(ConfigurationEntry.COLUMN_NAME_SYNC_URL, config.getSyncUrl());
+    values.put(ConfigurationEntry.COLUMN_NAME_SYNC_THRESHOLD, config.getSyncThreshold());
+    values.put(ConfigurationEntry.COLUMN_NAME_SYNC_ENABLED, Boolean.TRUE.equals(config.getSyncEnabled()) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_HEADERS, new JSONObject(config.getHttpHeaders()).toString());
+    values.put(ConfigurationEntry.COLUMN_NAME_MAX_LOCATIONS, config.getMaxLocations());
+    values.put(ConfigurationEntry.COLUMN_NAME_TEMPLATE, config.hasTemplate() ? config.getTemplate().toString() : null);
+    values.put(ConfigurationEntry.COLUMN_NAME_SHOW_TIME, Boolean.TRUE.equals(config.getShowTime()) ? 1 : 0);
+    values.put(ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE, Boolean.TRUE.equals(config.getShowDistance()) ? 1 : 0);
+    // v4.4.1: persist the full Config as JSON so post-3.2 fields (httpMethod, queryParams,
+    // drivingEvents, includeBattery, mockLocationPolicy, heartbeatInterval, ...) survive
+    // a reboot / startOnBoot. Legacy columns are kept populated above for backward compat.
+    try {
+      values.put(ConfigurationEntry.COLUMN_NAME_CONFIG_JSON,
+              ConfigJsonMapper.toJSONObject(config).toString());
+    } catch (JSONException e) {
+      Log.w(TAG, "config_json serialize failed: " + e.getMessage());
+    }
+
+    return values;
+  }
+}