@josuelmm/capacitor-background-geolocation 1.0.0

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

@@ -0,0 +1,189 @@
+package com.marianhello.bgloc.data.sqlite;
+
+
+import android.content.Context;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.util.Log;
+
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry;
+import com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract.ConfigurationEntry;
+import com.marianhello.bgloc.data.sqlite.SQLiteSessionContract.SessionEntry;
+
+import java.util.ArrayList;
+
+import static com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract.ConfigurationEntry.SQL_CREATE_CONFIG_TABLE;
+import static com.marianhello.bgloc.data.sqlite.SQLiteConfigurationContract.ConfigurationEntry.SQL_DROP_CONFIG_TABLE;
+import static com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry.SQL_CREATE_LOCATION_TABLE;
+import static com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry.SQL_CREATE_LOCATION_TABLE_BATCH_ID_IDX;
+import static com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry.SQL_CREATE_LOCATION_TABLE_TIME_IDX;
+import static com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry.SQL_DROP_LOCATION_TABLE;
+
+public class SQLiteOpenHelper extends android.database.sqlite.SQLiteOpenHelper {
+    private static final String TAG = SQLiteOpenHelper.class.getName();
+    public static final String SQLITE_DATABASE_NAME = "cordova_bg_geolocation.db";
+    public static final int DATABASE_VERSION = 22;
+
+    public static final String TEXT_TYPE = " TEXT";
+    public static final String INTEGER_TYPE = " INTEGER";
+    public static final String REAL_TYPE = " REAL";
+    public static final String COMMA_SEP = ",";
+
+    private static SQLiteOpenHelper instance;
+
+    /**
+     * Get SqliteOpenHelper instance (singleton)
+     *
+     * Use the application context, which will ensure that you
+     * don't accidentally leak an Activity's context.
+     * See this article for more information: http://bit.ly/6LRzfx
+     *
+     * @param context
+     * @return
+     */
+    public static synchronized SQLiteOpenHelper getHelper(Context context) {
+        if (instance == null)
+            instance = new SQLiteOpenHelper(context.getApplicationContext());
+
+        return instance;
+    }
+
+    /**
+     * Constructor
+     *
+     * NOTE: Intended to use only for testing purposes.
+     * Use factory method getHelper instead.
+     *
+     * @param context
+     */
+    public SQLiteOpenHelper(Context context) {
+        super(context, SQLITE_DATABASE_NAME, null, DATABASE_VERSION);
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        Log.d(TAG, "Creating db: " + this.getDatabaseName());
+        execAndLogSql(db, SQL_CREATE_LOCATION_TABLE);
+        execAndLogSql(db, SQL_CREATE_CONFIG_TABLE);
+        execAndLogSql(db, SQL_CREATE_LOCATION_TABLE_TIME_IDX);
+        execAndLogSql(db, SQL_CREATE_LOCATION_TABLE_BATCH_ID_IDX);
+        execAndLogSql(db, SessionEntry.SQL_CREATE_SESSION_TABLE);
+        execAndLogSql(db, SessionEntry.SQL_CREATE_SESSION_TABLE_TIME_IDX);
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        Log.d(this.getClass().getName(), "Upgrading database oldVersion: " + oldVersion + " newVersion: " + newVersion);
+
+        ArrayList<String> alterSql = new ArrayList<String>();
+        switch (oldVersion) {
+            case 10:
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_STATUS + INTEGER_TYPE);
+                alterSql.add(SQL_CREATE_LOCATION_TABLE_TIME_IDX);
+                alterSql.add(SQL_DROP_CONFIG_TABLE);
+                alterSql.add(SQL_CREATE_CONFIG_TABLE);
+            case 11:
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_RADIUS + REAL_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_HAS_ACCURACY + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_HAS_SPEED + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_HAS_BEARING + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_HAS_ALTITUDE + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_HAS_RADIUS + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + INTEGER_TYPE);
+                alterSql.add(SQL_CREATE_LOCATION_TABLE_BATCH_ID_IDX);
+                alterSql.add("UPDATE " + LocationEntry.TABLE_NAME +
+                        " SET " + LocationEntry.COLUMN_NAME_HAS_ACCURACY + "= 1," +
+                        LocationEntry.COLUMN_NAME_HAS_SPEED + "= 1," +
+                        LocationEntry.COLUMN_NAME_HAS_BEARING + "= 1," +
+                        LocationEntry.COLUMN_NAME_HAS_ALTITUDE + "= 1," +
+                        LocationEntry.COLUMN_NAME_HAS_RADIUS + "= 1"
+                );
+            case 12:
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_TEMPLATE + TEXT_TYPE);
+            case 13:
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_MOCK_FLAGS + INTEGER_TYPE);
+            case 14:
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_NOTIFICATIONS_ENABLED + INTEGER_TYPE);
+            case 15:
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_VERTICAL_ACCURACY + REAL_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_HAS_VERTICAL_ACCURACY + INTEGER_TYPE);
+                alterSql.add("UPDATE " + LocationEntry.TABLE_NAME +
+                                        " SET " + LocationEntry.COLUMN_NAME_VERTICAL_ACCURACY + "= -1," +
+                                        LocationEntry.COLUMN_NAME_HAS_VERTICAL_ACCURACY + "= 0");
+            case 16:
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TITLE + TEXT_TYPE);
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_TEXT + TEXT_TYPE);
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_COMPLETED + TEXT_TYPE);
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_NOTIF_SYNC_FAILED + TEXT_TYPE);
+            case 17:
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_SYNC_ENABLED + INTEGER_TYPE);
+            case 18:
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_SHOW_TIME + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_SHOW_DISTANCE + INTEGER_TYPE);
+            case 19:
+                alterSql.add(SessionEntry.SQL_CREATE_SESSION_TABLE);
+                alterSql.add(SessionEntry.SQL_CREATE_SESSION_TABLE_TIME_IDX);
+            case 20:
+                // v4.4.1: store the full Config as a single JSON blob so future-added fields
+                // do not require a per-field schema bump.
+                alterSql.add("ALTER TABLE " + ConfigurationEntry.TABLE_NAME +
+                        " ADD COLUMN " + ConfigurationEntry.COLUMN_NAME_CONFIG_JSON + TEXT_TYPE);
+            case 21:
+                // v4.5.0: persist driving events / battery / isCharging on each location so
+                // they survive the sync queue (POST failure → SQLite → background sync).
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_EVENTS_JSON + TEXT_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_BATTERY_LEVEL + INTEGER_TYPE);
+                alterSql.add("ALTER TABLE " + LocationEntry.TABLE_NAME +
+                        " ADD COLUMN " + LocationEntry.COLUMN_NAME_IS_CHARGING + INTEGER_TYPE);
+
+                break; // DO NOT FORGET TO MOVE DOWN BREAK ON DB UPGRADE!!!
+            default:
+                onDowngrade(db, 0, 0);
+                return;
+        }
+
+        for (String sql : alterSql) {
+            execAndLogSql(db, sql);
+        }
+    }
+
+    @Override
+    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        // we don't support db downgrade yet, instead we drop table and start over
+        execAndLogSql(db, SQL_DROP_LOCATION_TABLE);
+        execAndLogSql(db, SQL_DROP_CONFIG_TABLE);
+        execAndLogSql(db, SessionEntry.SQL_DROP_SESSION_TABLE);
+        onCreate(db);
+    }
+
+    public void execAndLogSql(SQLiteDatabase db, String sql) {
+        Log.d(TAG, sql);
+        try {
+            db.execSQL(sql);
+        } catch (SQLException e) {
+            Log.e(TAG, "Error executing sql: " + e.getMessage());
+        }
+    }
+}

package/android/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/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
+        };
+    }
+}