@josuelmm/capacitor-background-geolocation 1.0.0

package/ios/common/BackgroundGeolocation/MAURSQLiteOpenHelper.m

@@ -0,0 +1,276 @@
+//
+//  MAURSQLiteOpenHelper.m
+//
+//  Created by Marian Hello on 22/06/16.
+//
+
+#import <Foundation/Foundation.h>
+#import <sqlite3.h>
+#import "MAURSQLiteHelper.h"
+#import "MAURSQLiteOpenHelper.h"
+
+@implementation MAURSQLiteOpenHelper {
+    FMDatabaseQueue *mQueue;
+    BOOL mIsInitializing;
+    BOOL mIsReadOnly;
+    NSInteger mNewVersion; //  REMARK: never use mNewVersion < 1 in your subclasses
+    NSString* mName;
+}
+
+static NSString *const metaTableName = @"__META";
+static int const OPEN_READONLY = SQLITE_OPEN_READONLY|SQLITE_OPEN_FULLMUTEX;
+static int const OPEN_READWRITE = SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_FULLMUTEX;
+
+- (instancetype)init:(NSString*)name version:(NSInteger)version
+{
+    self = [super init];
+    if (self) {
+        self->mName = name;
+        self->mNewVersion = version;
+    }
+    return self;
+}
+
+- (FMDatabaseQueue*) getReadableDatabase
+{
+    
+    @synchronized(self) {
+        return [self getDatabaseLocked: NO];
+    }
+}
+
+- (FMDatabaseQueue*) getWritableDatabase
+{
+    @synchronized(self) {
+        return [self getDatabaseLocked: YES];
+    }
+}
+
+- (FMDatabaseQueue*) getDatabaseLocked:(BOOL)writable
+{
+    if (mQueue != nil) {
+        // TODO: add check if db was closed by user
+        return mQueue;
+    }
+    
+    if (mIsInitializing) {
+        @throw [NSException exceptionWithName:NSInternalInconsistencyException
+                                       reason:[NSString stringWithFormat:@"getDatabaseLocked called recursively"]
+                                     userInfo:nil];
+    }
+    
+    FMDatabaseQueue* queue = mQueue;
+    mIsInitializing = true;
+    
+    if (queue != nil) {
+        if (writable && mIsReadOnly) {
+            // TODO reopen as writable
+        }
+    } else if (mName == nil) {
+        @throw [NSException exceptionWithName:NSInternalInconsistencyException
+                                       reason:[NSString stringWithFormat:@"in memory database is not supported"]
+                                     userInfo:nil];
+    } else {
+        if (writable) {
+            queue = [self openOrCreateDatabase:mName];
+        } else {
+            queue = [self openDatabase:[self getDatabasePath] flags: OPEN_READONLY];
+        }
+    }
+    
+    [self onConfigure:queue];
+    
+    NSInteger version = [self getVersion:queue];
+    NSLog(@"Current db version: %ld", (long)version);
+    
+    if (version != mNewVersion) {
+        if (version == 0) {
+            [self onCreate:queue];
+        } else {
+            if (version < mNewVersion) {
+                [self onUpgrade:queue fromVersion:version toVersion:mNewVersion];
+            } else if (version > mNewVersion) {
+                [self onDowngrade:queue fromVersion:version toVersion:mNewVersion];
+            }
+        }
+        [self setVersion:queue version:mNewVersion];
+    }
+    
+    [self onOpen:queue];
+    
+    mQueue = queue;
+    mIsInitializing = false;
+    mIsReadOnly = !writable;
+    return queue;
+}
+
+- (FMDatabaseQueue*) openDatabase:(NSString*)path flags:(int)flags
+{
+    return [FMDatabaseQueue databaseQueueWithPath:path flags:flags];
+}
+
+- (FMDatabaseQueue*) openOrCreateDatabase:(NSString*)name
+{
+    __block BOOL isOpen;
+    FMDatabaseQueue *queue = [FMDatabaseQueue databaseQueueWithPath:[self getDatabasePath:name]];
+    
+    [queue inDatabase:^(FMDatabase *database) {
+        isOpen = [database open];
+    }];
+    
+    if (!isOpen) {
+        return nil;
+    }
+    
+    if ([self getVersion:queue] == -1) {
+        NSArray *columns = @[
+            @{ @"name": @"id", @"type": [SQLPrimaryKeyColumnType sqlColumnWithType: kInteger]},
+            @{ @"name": @"db_version", @"type": [SQLColumnType sqlColumnWithType: kInteger]},
+            @{ @"name": @"created", @"type": [SQLColumnType sqlColumnWithType: kInteger]},
+            @{ @"name": @"last_updated", @"type": [SQLColumnType sqlColumnWithType: kInteger]}
+         ];
+        
+        [queue inDatabase:^(FMDatabase *database) {
+            if ([database executeStatements:[MAURSQLiteHelper createTableSqlStatement:metaTableName columns:columns]]) {
+                NSString *sql = [NSString stringWithFormat: @"INSERT INTO %@ (id,db_version,created,last_updated) VALUES (1,%d,datetime(),null)", metaTableName, 0];
+                if (![database executeUpdate:sql]) {
+                    NSLog(@"%@ failed code: %d: message: %@", sql, [database lastErrorCode], [database lastErrorMessage]);
+                }
+            } else {
+                NSLog(@"Creating meta table %@ failed code: %d: message: %@", metaTableName, [database lastErrorCode], [database lastErrorMessage]);
+            }
+        }];
+    }
+    
+    return queue;
+}
+
+- (void) close
+{
+    @synchronized(self) {
+        if (mQueue != nil) {
+            [mQueue close];
+            mQueue = nil;
+        }
+    }
+}
+
+- (NSDictionary*) getDatabaseMetadata
+{
+    FMDatabaseQueue *queue = [self getReadableDatabase];
+    NSMutableDictionary *metadata = [[NSMutableDictionary alloc] init];
+    [metadata setObject:[NSNumber numberWithInt:-1] forKey:@"dbVersion"];
+    
+    NSString *sql =[NSString stringWithFormat: @"SELECT db_version, created, last_updated FROM %@ LIMIT 1", metaTableName];
+    [queue inDatabase:^(FMDatabase *database) {
+        FMResultSet *rs = [database executeQuery:sql];
+        while ([rs next]) {
+            NSNumber *dbVersion = [NSNumber numberWithInt:[rs intForColumnIndex:0]];
+            NSString *created = [rs stringForColumnIndex:1] ?: @"";
+            NSString *lastUpdated = [rs stringForColumnIndex:2] ?: @"";
+            
+            [metadata setObject:dbVersion forKey:@"dbVersion"];
+            [metadata setObject:created forKey:@"created"];
+            [metadata setObject:lastUpdated forKey:@"last_updated"];
+        }
+        
+        // TODO error handling
+        // NSLog(@"Retrieving meta data failed code: %d: message: %s", sqlite3_errcode(database), sqlite3_errmsg(database));
+        [rs close];
+        
+    }];
+    
+    [queue close];
+    
+    return metadata;
+}
+
+- (NSString*) getDatabaseName
+{
+    return mName;
+}
+
+- (NSString*) getDatabasePath:(NSString*)name
+{
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES);
+    NSString *libraryDirectory = [paths objectAtIndex:0];
+    NSString *databasePath = [[NSString alloc]initWithString:[libraryDirectory stringByAppendingPathComponent:name]];
+    
+    return databasePath;
+}
+
+- (NSString*) getDatabasePath
+{
+    return [self getDatabasePath:mName];
+}
+
+- (FMDatabaseQueue*) getDatabaseQueue
+{
+    @synchronized(self) {
+        if (mQueue == nil) {
+            mQueue = [FMDatabaseQueue databaseQueueWithPath:[self getDatabasePath]];
+        }
+        
+        return mQueue;
+    }
+}
+
+- (NSInteger) getVersion:(FMDatabaseQueue*)queue
+{
+    __block NSInteger dbVersion = -1;
+    NSString *sql =[NSString stringWithFormat: @"SELECT db_version FROM %@", metaTableName];
+    [queue inDatabase:^(FMDatabase *database) {
+        database.logsErrors = NO;
+        NSError *lastError;
+        FMResultSet *rs = [database executeQuery:sql values:nil error:&lastError];
+        if (rs != nil) {
+            while ([rs next]) {
+                dbVersion = [rs intForColumnIndex:0];
+            }
+            [rs close];
+        } else {
+            NSLog(@"Determining db version returned error (ok for first run): %@", [lastError localizedDescription]);
+        }
+        database.logsErrors = YES;
+    }];
+    
+    return dbVersion;
+}
+
+- (void) setVersion:(FMDatabaseQueue*)queue version:(NSInteger)version
+{
+    NSString *sql = [NSString stringWithFormat: @"UPDATE %@ SET db_version = %ld, last_updated = datetime()", metaTableName, (long)version];
+    [queue inDatabase:^(FMDatabase *database) {
+        if (![database executeUpdate:sql]) {
+            NSLog(@"%@ failed code: %d: message: %@", sql, [database lastErrorCode], [database lastErrorMessage]);
+        }
+    }];
+}
+
+- (void) onOpen:(FMDatabaseQueue*)database
+{
+    // ment to be implemented in subclass
+}
+
+- (void) onConfigure:(FMDatabaseQueue*)database;
+{
+    // ment to be implemented in subclass
+}
+
+- (void) onCreate:(FMDatabaseQueue*)database
+{
+    // has to be implemented in subclass
+}
+
+- (void) onUpgrade:(FMDatabaseQueue*)database fromVersion:(NSInteger)oldVersion toVersion:(NSInteger)newVersion
+{
+    // upgrade policy has to be implemented in subclass
+}
+
+- (void) onDowngrade:(FMDatabaseQueue*)database fromVersion:(NSInteger)oldVersion toVersion:(NSInteger)newVersion
+{
+    // upgrade policy has to be implemented in subclass
+}
+
+
+@end

package/ios/common/BackgroundGeolocation/MAURSensorFusionDetector.h

@@ -0,0 +1,41 @@
+//
+//  MAURSensorFusionDetector.h
+//  BackgroundGeolocation
+//
+//  v4.2 Phase 8 — Real sensor fusion detector for iOS.
+//  Uses CMMotionManager to sample userAcceleration (gravity removed) and rotationRate.
+//  Refines possibleCrash via accelerometer impact and detects phoneUsageWhileDriving.
+//
+
+#ifndef MAURSensorFusionDetector_h
+#define MAURSensorFusionDetector_h
+
+#import <Foundation/Foundation.h>
+
+@class MAURLocation;
+
+@protocol MAURSensorFusionListener <NSObject>
+- (void)onSensorCrashWithImpactG:(double)impactG location:(MAURLocation *)location;
+- (void)onPhoneUsageWhileDriving:(MAURLocation *)location;
+@end
+
+@interface MAURSensorFusionDetector : NSObject
+
+@property (nonatomic, weak)   id<MAURSensorFusionListener> listener;
+@property (nonatomic, assign) BOOL enabled;
+@property (nonatomic, assign) double crashImpactG;       // default 3.0
+@property (nonatomic, assign) NSTimeInterval crashCooldownMs;        // default 10000
+@property (nonatomic, assign) NSTimeInterval phoneUsageWindowMs;     // default 4000
+@property (nonatomic, assign) NSTimeInterval phoneUsageCooldownMs;   // default 60000
+
+@property (nonatomic, assign) BOOL tripActive;
+@property (nonatomic, strong) MAURLocation *lastLocation;
+
+- (instancetype)init;
+- (BOOL)isAvailable;
+- (void)start;
+- (void)stop;
+
+@end
+
+#endif /* MAURSensorFusionDetector_h */

package/ios/common/BackgroundGeolocation/MAURSensorFusionDetector.m

@@ -0,0 +1,137 @@
+//
+//  MAURSensorFusionDetector.m
+//  BackgroundGeolocation
+//
+//  v4.2 Phase 8 — sensor fusion detector implementation.
+//
+
+#import "MAURSensorFusionDetector.h"
+#import <CoreMotion/CoreMotion.h>
+#import <UIKit/UIKit.h>
+
+static const double kJitterGyroRadS  = 0.7;   // ~40 deg/s
+static const double kJitterAccelMps2 = 0.5;
+
+@interface MAURSensorFusionDetector ()
+@property (nonatomic, strong) CMMotionManager *motion;
+@property (nonatomic, strong) NSOperationQueue *queue;
+@property (nonatomic, assign) BOOL started;
+@property (nonatomic, assign) NSTimeInterval lastCrashAt;
+@property (nonatomic, assign) NSTimeInterval lastPhoneUsageAt;
+@property (nonatomic, assign) NSTimeInterval jitterAboveSince;
+@end
+
+@implementation MAURSensorFusionDetector
+
+- (instancetype)init {
+    if ((self = [super init])) {
+        _motion = [[CMMotionManager alloc] init];
+        _motion.deviceMotionUpdateInterval = 1.0 / 50.0; // 50 Hz
+        _queue = [[NSOperationQueue alloc] init];
+        _queue.name = @"MAURSensorFusionQueue";
+        _queue.maxConcurrentOperationCount = 1;
+        _enabled = NO;
+        _crashImpactG = 3.0;
+        _crashCooldownMs = 10000;
+        _phoneUsageWindowMs = 4000;
+        _phoneUsageCooldownMs = 60000;
+        _started = NO;
+        _lastCrashAt = 0;
+        _lastPhoneUsageAt = 0;
+        _jitterAboveSince = 0;
+    }
+    return self;
+}
+
+- (BOOL)isAvailable {
+    return self.motion.isDeviceMotionAvailable;
+}
+
+- (void)start {
+    @synchronized (self) {
+        if (self.started || !self.enabled) return;
+        if (![self.motion isDeviceMotionAvailable]) return;
+        __weak typeof(self) weakSelf = self;
+        [self.motion startDeviceMotionUpdatesToQueue:self.queue
+                                          withHandler:^(CMDeviceMotion * _Nullable motion, NSError * _Nullable error) {
+            if (!motion || error) return;
+            [weakSelf processMotion:motion];
+        }];
+        self.started = YES;
+    }
+}
+
+- (void)stop {
+    @synchronized (self) {
+        if (!self.started) return;
+        [self.motion stopDeviceMotionUpdates];
+        self.started = NO;
+        self.jitterAboveSince = 0;
+    }
+}
+
+- (void)processMotion:(CMDeviceMotion *)motion {
+    if (!self.enabled) return;
+    NSTimeInterval nowMs = [[NSDate date] timeIntervalSince1970] * 1000.0;
+
+    // userAcceleration is in g (gravity removed); convert magnitude to g and to m/s².
+    double ax = motion.userAcceleration.x;
+    double ay = motion.userAcceleration.y;
+    double az = motion.userAcceleration.z;
+    double accelMagG  = sqrt(ax*ax + ay*ay + az*az);            // g
+    double accelMagMs = accelMagG * 9.80665;                    // m/s²
+
+    double gx = motion.rotationRate.x;
+    double gy = motion.rotationRate.y;
+    double gz = motion.rotationRate.z;
+    double gyroMag = sqrt(gx*gx + gy*gy + gz*gz);               // rad/s
+
+    BOOL tripActiveNow = self.tripActive;
+    MAURLocation *loc = self.lastLocation;
+    id<MAURSensorFusionListener> l = self.listener;
+
+    // Crash detection
+    if (tripActiveNow && self.crashImpactG > 0 && accelMagG >= self.crashImpactG
+            && (nowMs - self.lastCrashAt) >= self.crashCooldownMs) {
+        self.lastCrashAt = nowMs;
+        if ([l respondsToSelector:@selector(onSensorCrashWithImpactG:location:)]) {
+            [l onSensorCrashWithImpactG:accelMagG location:loc];
+        }
+    }
+
+    // phoneUsageWhileDriving
+    if (!tripActiveNow) { self.jitterAboveSince = 0; return; }
+    BOOL screenOn = [self isScreenOnApprox];
+    if (!screenOn) { self.jitterAboveSince = 0; return; }
+
+    BOOL above = (accelMagMs >= kJitterAccelMps2) || (gyroMag >= kJitterGyroRadS);
+    if (above) {
+        if (self.jitterAboveSince == 0) self.jitterAboveSince = nowMs;
+        if ((nowMs - self.jitterAboveSince) >= self.phoneUsageWindowMs
+                && (nowMs - self.lastPhoneUsageAt) >= self.phoneUsageCooldownMs) {
+            self.lastPhoneUsageAt = nowMs;
+            self.jitterAboveSince = 0;
+            if ([l respondsToSelector:@selector(onPhoneUsageWhileDriving:)]) {
+                [l onPhoneUsageWhileDriving:loc];
+            }
+        }
+    } else {
+        self.jitterAboveSince = 0;
+    }
+}
+
+- (BOOL)isScreenOnApprox {
+    // Heuristic: app is foreground active => screen is on. Background sampling does
+    // not constitute phone usage while driving (passenger may have screen off too).
+    __block UIApplicationState state = UIApplicationStateBackground;
+    if ([NSThread isMainThread]) {
+        state = [UIApplication sharedApplication].applicationState;
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            state = [UIApplication sharedApplication].applicationState;
+        });
+    }
+    return state == UIApplicationStateActive;
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURSessionLocationContract.h

@@ -0,0 +1,29 @@
+//
+//  MAURSessionLocationContract.h
+//  BackgroundGeolocation
+//
+//  Session table for current recording route. Independent of sync; cleared on startSession/clearSession.
+//
+
+#ifndef MAURSessionLocationContract_h
+#define MAURSessionLocationContract_h
+
+#define LSC_TABLE_NAME "location_session"
+#define LSC_COLUMN_NAME_ID "id"
+#define LSC_COLUMN_NAME_TIME "time"
+#define LSC_COLUMN_NAME_ACCURACY "accuracy"
+#define LSC_COLUMN_NAME_SPEED "speed"
+#define LSC_COLUMN_NAME_BEARING "bearing"
+#define LSC_COLUMN_NAME_ALTITUDE "altitude"
+#define LSC_COLUMN_NAME_LATITUDE "latitude"
+#define LSC_COLUMN_NAME_LONGITUDE "longitude"
+#define LSC_COLUMN_NAME_PROVIDER "provider"
+#define LSC_COLUMN_NAME_LOCATION_PROVIDER "service_provider"
+#define LSC_COLUMN_NAME_STATUS "valid"
+#define LSC_COLUMN_NAME_RECORDED_AT "recorded_at"
+
+@interface MAURSessionLocationContract : NSObject
++ (NSString*) createTableSQL;
+@end
+
+#endif /* MAURSessionLocationContract_h */

package/ios/common/BackgroundGeolocation/MAURSessionLocationContract.m

@@ -0,0 +1,31 @@
+//
+//  MAURSessionLocationContract.m
+//  BackgroundGeolocation
+//
+
+#import <Foundation/Foundation.h>
+#import "MAURSQLiteHelper.h"
+#import "MAURSessionLocationContract.h"
+
+@implementation MAURSessionLocationContract
+
++ (NSString*) createTableSQL
+{
+    NSArray *columns = @[
+        @{ @"name": @LSC_COLUMN_NAME_ID, @"type": [SQLPrimaryKeyAutoIncColumnType sqlColumnWithType: kInteger]},
+        @{ @"name": @LSC_COLUMN_NAME_TIME, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_ACCURACY, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_SPEED, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_BEARING, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_ALTITUDE, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_LATITUDE, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_LONGITUDE, @"type": [SQLColumnType sqlColumnWithType: kReal]},
+        @{ @"name": @LSC_COLUMN_NAME_PROVIDER, @"type": [SQLColumnType sqlColumnWithType: kText]},
+        @{ @"name": @LSC_COLUMN_NAME_LOCATION_PROVIDER, @"type": [SQLColumnType sqlColumnWithType: kText]},
+        @{ @"name": @LSC_COLUMN_NAME_STATUS, @"type": [SQLColumnType sqlColumnWithType: kInteger]},
+        @{ @"name": @LSC_COLUMN_NAME_RECORDED_AT, @"type": [SQLColumnType sqlColumnWithType: kInteger]}
+    ];
+    return [MAURSQLiteHelper createTableSqlStatement:@LSC_TABLE_NAME columns:columns];
+}
+
+@end

package/ios/common/BackgroundGeolocation/MAURSessionLocationDAO.h

@@ -0,0 +1,25 @@
+//
+//  MAURSessionLocationDAO.h
+//  BackgroundGeolocation
+//
+//  Session storage for current route. Cleared on startSession/clearSession; not cleared by sync.
+//
+
+#ifndef MAURSessionLocationDAO_h
+#define MAURSessionLocationDAO_h
+
+#import <Foundation/Foundation.h>
+#import "MAURLocation.h"
+
+@interface MAURSessionLocationDAO : NSObject
++ (instancetype) sharedInstance;
+- (id) init NS_UNAVAILABLE;
+- (void) startSession;
+- (void) clearSession;
+- (BOOL) isSessionActive;
+- (void) persistSessionLocation:(MAURLocation*)location;
+- (NSArray<MAURLocation*>*) getSessionLocations;
+- (NSInteger) getSessionLocationsCount;
+@end
+
+#endif /* MAURSessionLocationDAO_h */

package/ios/common/BackgroundGeolocation/MAURSessionLocationDAO.m

@@ -0,0 +1,153 @@
+//
+//  MAURSessionLocationDAO.m
+//  BackgroundGeolocation
+//
+
+#import <Foundation/Foundation.h>
+#import "MAURGeolocationOpenHelper.h"
+#import "MAURSessionLocationContract.h"
+#import "MAURSessionLocationDAO.h"
+#import "MAURLocation.h"
+#import "FMDB.h"
+
+static NSString *const kSessionActiveKey = @"bgloc_session_active";
+
+@interface MAURSessionLocationDAO ()
+- (instancetype)initPrivate;
+@end
+
+@implementation MAURSessionLocationDAO {
+    FMDatabaseQueue* queue;
+    MAURGeolocationOpenHelper *helper;
+}
+
++ (instancetype) sharedInstance
+{
+    static MAURSessionLocationDAO *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[self alloc] initPrivate];
+    });
+    return instance;
+}
+
+- (instancetype) initPrivate
+{
+    if (self = [super init]) {
+        helper = [[MAURGeolocationOpenHelper alloc] init];
+        queue = [helper getWritableDatabase];
+    }
+    return self;
+}
+
+- (void) startSession
+{
+    [queue inDatabase:^(FMDatabase *database) {
+        NSString *sql = [NSString stringWithFormat:@"DELETE FROM %@", @LSC_TABLE_NAME];
+        [database executeUpdate:sql];
+    }];
+    [[NSUserDefaults standardUserDefaults] setBool:YES forKey:kSessionActiveKey];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+- (void) clearSession
+{
+    [queue inDatabase:^(FMDatabase *database) {
+        NSString *sql = [NSString stringWithFormat:@"DELETE FROM %@", @LSC_TABLE_NAME];
+        [database executeUpdate:sql];
+    }];
+    [[NSUserDefaults standardUserDefaults] setBool:NO forKey:kSessionActiveKey];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+}
+
+- (BOOL) isSessionActive
+{
+    return [[NSUserDefaults standardUserDefaults] boolForKey:kSessionActiveKey];
+}
+
+- (void) persistSessionLocation:(MAURLocation*)location
+{
+    if (![self isSessionActive]) return;
+    if (!location || !location.time) return;
+    NSTimeInterval timestamp = [[NSDate date] timeIntervalSince1970];
+    NSNumber *recordedAt = [NSNumber numberWithDouble:timestamp];
+
+    NSString *sql = @"INSERT INTO " @LSC_TABLE_NAME @" ("
+        @LSC_COLUMN_NAME_TIME @"," @LSC_COLUMN_NAME_ACCURACY @"," @LSC_COLUMN_NAME_SPEED @","
+        @LSC_COLUMN_NAME_BEARING @"," @LSC_COLUMN_NAME_ALTITUDE @"," @LSC_COLUMN_NAME_LATITUDE @","
+        @LSC_COLUMN_NAME_LONGITUDE @"," @LSC_COLUMN_NAME_PROVIDER @"," @LSC_COLUMN_NAME_LOCATION_PROVIDER @","
+        @LSC_COLUMN_NAME_STATUS @"," @LSC_COLUMN_NAME_RECORDED_AT
+        @") VALUES (?,?,?,?,?,?,?,?,?,?,?)";
+
+    [queue inDatabase:^(FMDatabase *database) {
+        [database executeUpdate:sql,
+            [NSNumber numberWithDouble:[location.time timeIntervalSince1970]],
+            location.accuracy ?: @0,
+            location.speed ?: @0,
+            location.heading ?: @0,
+            location.altitude ?: @0,
+            location.latitude ?: @0,
+            location.longitude ?: @0,
+            location.provider ?: [NSNull null],
+            location.locationProvider ? [NSString stringWithFormat:@"%@", location.locationProvider] : [NSNull null],
+            @(1),
+            recordedAt
+        ];
+    }];
+}
+
+- (NSArray<MAURLocation*>*) getSessionLocations
+{
+    __block NSMutableArray* locations = [[NSMutableArray alloc] init];
+    NSString *sql = @"SELECT " @LSC_COLUMN_NAME_ID @"," @LSC_COLUMN_NAME_TIME @"," @LSC_COLUMN_NAME_ACCURACY @","
+        @LSC_COLUMN_NAME_SPEED @"," @LSC_COLUMN_NAME_BEARING @"," @LSC_COLUMN_NAME_ALTITUDE @","
+        @LSC_COLUMN_NAME_LATITUDE @"," @LSC_COLUMN_NAME_LONGITUDE @"," @LSC_COLUMN_NAME_PROVIDER @","
+        @LSC_COLUMN_NAME_LOCATION_PROVIDER @"," @LSC_COLUMN_NAME_STATUS @"," @LSC_COLUMN_NAME_RECORDED_AT
+        @" FROM " @LSC_TABLE_NAME @" ORDER BY " @LSC_COLUMN_NAME_RECORDED_AT;
+
+    [queue inDatabase:^(FMDatabase *database) {
+        FMResultSet *rs = [database executeQuery:sql];
+        while ([rs next]) {
+            MAURLocation *loc = [self convertToLocation:rs];
+            [locations addObject:loc];
+        }
+        [rs close];
+    }];
+    return locations;
+}
+
+- (NSInteger) getSessionLocationsCount
+{
+    __block NSInteger count = 0;
+    NSString *sql = [NSString stringWithFormat:@"SELECT COUNT(*) FROM %@", @LSC_TABLE_NAME];
+    [queue inDatabase:^(FMDatabase *database) {
+        FMResultSet *rs = [database executeQuery:sql];
+        if ([rs next]) {
+            count = [rs intForColumnIndex:0];
+        }
+        [rs close];
+    }];
+    return count;
+}
+
+- (MAURLocation*) convertToLocation:(FMResultSet*)rs
+{
+    MAURLocation *location = [[MAURLocation alloc] init];
+    location.locationId = [NSNumber numberWithLongLong:[rs longLongIntForColumnIndex:0]];
+    NSTimeInterval timestamp = [rs doubleForColumnIndex:1];
+    location.time = [NSDate dateWithTimeIntervalSince1970:timestamp];
+    location.accuracy = [NSNumber numberWithDouble:[rs doubleForColumnIndex:2]];
+    location.speed = [NSNumber numberWithDouble:[rs doubleForColumnIndex:3]];
+    location.heading = [NSNumber numberWithDouble:[rs doubleForColumnIndex:4]];
+    location.altitude = [NSNumber numberWithDouble:[rs doubleForColumnIndex:5]];
+    location.latitude = [NSNumber numberWithDouble:[rs doubleForColumnIndex:6]];
+    location.longitude = [NSNumber numberWithDouble:[rs doubleForColumnIndex:7]];
+    location.provider = [rs stringForColumnIndex:8];
+    location.locationProvider = [NSNumber numberWithInt:[rs intForColumnIndex:9]];
+    location.isValid = [rs intForColumnIndex:10] == 1 ? YES : NO;
+    NSTimeInterval recordedAt = [rs longForColumnIndex:11];
+    location.recordedAt = [NSDate dateWithTimeIntervalSince1970:recordedAt];
+    return location;
+}
+
+@end