Merge pull request #18 from gabriel-sisjr/feature/sql-lite-storage

Feature - Adding Room Support for Persistent Data

Author: gabriel-sisjr

CHANGELOG.md

@@ -24,11 +24,13 @@ A React Native library for tracking location in the background using TurboModule
 
 - ✅ **Background location tracking** - Continues tracking when app is in background
 - ✅ **Real-time location updates** - Automatic event-driven location watching
+- ✅ **Crash recovery** - Automatic recovery of tracking sessions after app crash or restart
+- ✅ **Battery optimization** - Configurable accuracy levels and update intervals for efficient battery usage
 - ✅ **TurboModule** - Built with React Native's New Architecture for better performance
 - ✅ **Session-based tracking** - Organize location data by trip/session IDs
 - ✅ **TypeScript support** - Fully typed API
 - ✅ **Android support** - Native Kotlin implementation (iOS coming soon)
-- ✅ **Persistent storage** - Locations are stored and survive app restarts
+- ✅ **Persistent storage** - Locations are stored in Room Database and survive app restarts
 - ✅ **Foreground service** - Uses Android foreground service for reliable tracking
 
 ## Installation
@@ -65,29 +67,6 @@ yarn add @gabriel-sisjr/react-native-background-location
 </manifest>
 ```
 
-2. **Request permissions at runtime:** _(not recommended, should use hook instead)_
-
-```typescript
-import { PermissionsAndroid, Platform } from 'react-native';
-
-const requestLocationPermissions = async () => {
-  if (Platform.OS === 'android') {
-    const granted = await PermissionsAndroid.requestMultiple([
-      PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
-      PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
-      PermissionsAndroid.PERMISSIONS.ACCESS_BACKGROUND_LOCATION,
-    ]);
-
-    return (
-      granted['android.permission.ACCESS_FINE_LOCATION'] === 'granted' &&
-      granted['android.permission.ACCESS_COARSE_LOCATION'] === 'granted' &&
-      granted['android.permission.ACCESS_BACKGROUND_LOCATION'] === 'granted'
-    );
-  }
-  return true;
-};
-```
-
 ### iOS
 
 iOS support is coming in a future release.
@@ -556,14 +535,24 @@ See the [example app](example/src/App.tsx) for complete implementation examples.
 
 ## Battery Optimization
 
-⚠️ **Important:** Background location tracking can significantly impact battery life. Consider:
+The library includes built-in battery optimization features:
+
+- **Configurable accuracy levels** - Use `LocationAccuracy.LOW_POWER` or `BALANCED_POWER_ACCURACY` for better battery efficiency
+- **Adjustable update intervals** - Increase intervals to reduce battery consumption
+- **Smart location updates** - Only requests location when necessary
+- **Foreground service optimization** - Efficient service implementation
+
+### Best Practices
+
+- Use `LocationAccuracy.LOW_POWER` for long-term tracking
+- Increase `updateInterval` when high-frequency updates aren't needed
+- Stop tracking when not in use
+- Inform users about battery usage
+- Test on real devices (emulator GPS simulation is unreliable)
 
-- Only tracking when necessary
-- Stopping tracking when done
-- Informing users about battery usage
-- Testing on real devices (not emulators)
+### Android Battery Optimization
 
-On Android, some manufacturers (Xiaomi, Huawei, etc.) have aggressive battery optimization that may kill background services. Users may need to whitelist your app in battery settings.
+Some Android manufacturers (Xiaomi, Huawei, etc.) have aggressive battery optimization that may kill background services. Users may need to whitelist your app in battery settings for optimal performance.
 
 ## Simulator/Emulator Support
 
@@ -714,12 +703,9 @@ Make sure your `tsconfig.json` includes:
 ## Roadmap
 
 - [ ] iOS implementation with Swift
-- [ ] Customizable location update intervals
 - [ ] Geofencing support
 - [ ] Distance filtering for GPS coordinates
-- [ ] SQLite storage option for large datasets
 - [ ] Configurable notification appearance
-- [ ] Battery optimization modes
 - [ ] Web support (Geolocation API)
 
 ## Contributing

README.md

@@ -12,13 +12,15 @@ buildscript {
     classpath "com.android.tools.build:gradle:8.7.2"
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+    classpath "com.google.devtools.ksp:com.google.devtools.ksp.gradle.plugin:2.1.20-1.0.32"
   }
 }
 
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 apply plugin: "kotlin-parcelize"
+apply plugin: "com.google.devtools.ksp"
 
 apply plugin: "com.facebook.react"
 
@@ -78,4 +80,10 @@ dependencies {
 
   // Google Play Services for Location
   implementation "com.google.android.gms:play-services-location:21.3.0"
+  
+  // Room
+  def room = "2.6.1"
+  implementation("androidx.room:room-runtime:$room")
+  implementation("androidx.room:room-ktx:$room")
+  ksp("androidx.room:room-compiler:$room")
 }

android/build.gradle

@@ -1,4 +1,4 @@
-BackgroundLocation_kotlinVersion=2.0.21
+BackgroundLocation_kotlinVersion=2.1.20
 BackgroundLocation_minSdkVersion=24
 BackgroundLocation_targetSdkVersion=34
 BackgroundLocation_compileSdkVersion=35

android/gradle.properties

@@ -21,6 +21,15 @@ class BackgroundLocationModule(reactContext: ReactApplicationContext) :
   init {
     // Set the React Context in LocationService for event emission
     LocationService.setReactContext(reactContext)
+    
+    // Attempt to recover tracking session if app crashed/restarted
+    recoverTrackingSession()
+  }
+  
+  override fun initialize() {
+    super.initialize()
+    // Re-set the React Context when module is initialized
+    LocationService.setReactContext(reactApplicationContext)
   }
 
   override fun getName(): String = NAME
@@ -59,9 +68,12 @@ class BackgroundLocationModule(reactContext: ReactApplicationContext) :
       // Parse options if provided
       val trackingOptions = parseTrackingOptions(options)
 
-      // Save tracking state
-      storage.saveTrackingState(effectiveTripId, true)
+      // Save tracking state with options for recovery
+      storage.saveTrackingState(effectiveTripId, true, trackingOptions)
 
+      // Ensure React Context is set before starting service
+      LocationService.setReactContext(reactApplicationContext)
+      
       // Start the foreground service with options
       val context = reactApplicationContext
       LocationService.startService(context, effectiveTripId, trackingOptions)
@@ -164,6 +176,44 @@ class BackgroundLocationModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  /**
+   * Recovers tracking session after app restart/crash
+   * Restarts the LocationService if tracking was active
+   */
+  private fun recoverTrackingSession() {
+    try {
+      val trackingState = storage.getTrackingState()
+      
+      // If tracking was active and we have both tripId and options
+      if (trackingState.isActive && trackingState.tripId != null) {
+        // Check if we still have location permissions
+        if (!hasLocationPermissions()) {
+          // Clear tracking state if permissions were revoked
+          storage.saveTrackingState(null, false)
+          return
+        }
+        
+        // Ensure React Context is set before restarting service
+        LocationService.setReactContext(reactApplicationContext)
+        
+        // Restart the service with saved options
+        val options = trackingState.options ?: TrackingOptions()
+        val context = reactApplicationContext
+        LocationService.startService(context, trackingState.tripId, options)
+      }
+    } catch (e: Exception) {
+      // Log error but don't crash - recovery is best-effort
+      e.printStackTrace()
+      
+      // Clear tracking state if recovery fails
+      try {
+        storage.saveTrackingState(null, false)
+      } catch (clearError: Exception) {
+        clearError.printStackTrace()
+      }
+    }
+  }
+
   /**
    * Checks if the app has the necessary location permissions
    */

android/src/main/java/com/backgroundlocation/BackgroundLocationModule.kt

@@ -38,20 +38,34 @@ class LocationService : Service() {
   }
 
   override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-    currentTripId = intent?.getStringExtra(EXTRA_TRIP_ID)
+    android.util.Log.d("LocationService", "onStartCommand called")
+    // Try to get tripId from intent
+    var tripId = intent?.getStringExtra(EXTRA_TRIP_ID)
 
     // Parse tracking options from Bundle
     val optionsBundle = intent?.getBundleExtra(EXTRA_TRACKING_OPTIONS)
     trackingOptions = if (optionsBundle != null) {
       parseTrackingOptionsFromBundle(optionsBundle)
     } else {
-      TrackingOptions()
+      // If intent is null (service restarted by system), try to recover from storage
+      if (intent == null) {
+        val trackingState = storage.getTrackingState()
+        if (trackingState.isActive && trackingState.tripId != null) {
+          tripId = trackingState.tripId
+          trackingState.options?.let { trackingOptions = it }
+        }
+      }
+      trackingOptions
     }
 
-    if (currentTripId == null) {
+    if (tripId == null) {
+      // No valid tripId - stop the service
       stopSelf()
       return START_NOT_STICKY
     }
+    
+    currentTripId = tripId
+    android.util.Log.d("LocationService", "Starting location tracking for tripId: $tripId")
 
     // Create notification channel with options
     createNotificationChannel()
@@ -60,9 +74,13 @@ class LocationService : Service() {
     val notification = createNotification()
     startForeground(NOTIFICATION_ID, notification)
 
+    // Check last known location to verify GPS is working
+    checkLastKnownLocation()
+    
     // Start location updates
     startLocationUpdates()
 
+    // Return START_STICKY so the service is restarted if killed by system
     return START_STICKY
   }
 
@@ -84,6 +102,24 @@ class LocationService : Service() {
     )
   }
 
+  @SuppressLint("MissingPermission")
+  private fun checkLastKnownLocation() {
+    try {
+      android.util.Log.d("LocationService", "Checking last known location...")
+      fusedLocationClient.lastLocation.addOnSuccessListener { location ->
+        if (location != null) {
+          android.util.Log.d("LocationService", "Last known location: lat=${location.latitude}, lng=${location.longitude}")
+        } else {
+          android.util.Log.w("LocationService", "Last known location is NULL - GPS may not have a fix yet")
+        }
+      }.addOnFailureListener { e ->
+        android.util.Log.e("LocationService", "Failed to get last known location", e)
+      }
+    } catch (e: Exception) {
+      android.util.Log.e("LocationService", "Exception checking last known location", e)
+    }
+  }
+  
   @SuppressLint("MissingPermission")
   private fun startLocationUpdates() {
     val priority = when (trackingOptions.getAccuracyOrDefault()) {
@@ -94,30 +130,51 @@ class LocationService : Service() {
       LocationAccuracy.PASSIVE -> Priority.PRIORITY_PASSIVE
     }
 
+    val updateInterval = trackingOptions.getUpdateIntervalOrDefault()
+    val fastestInterval = trackingOptions.getFastestIntervalOrDefault()
+    val maxWaitTime = trackingOptions.getMaxWaitTimeOrDefault()
+    
+    android.util.Log.d("LocationService", "Starting location updates with:")
+    android.util.Log.d("LocationService", "  Priority: $priority")
+    android.util.Log.d("LocationService", "  Update Interval: ${updateInterval}ms")
+    android.util.Log.d("LocationService", "  Fastest Interval: ${fastestInterval}ms")
+    android.util.Log.d("LocationService", "  Max Wait Time: ${maxWaitTime}ms")
+
     val locationRequest = LocationRequest.Builder(
       priority,
-      trackingOptions.getUpdateIntervalOrDefault()
+      updateInterval
     ).apply {
-      setMinUpdateIntervalMillis(trackingOptions.getFastestIntervalOrDefault())
-      setMaxUpdateDelayMillis(trackingOptions.getMaxWaitTimeOrDefault())
+      setMinUpdateIntervalMillis(fastestInterval)
+      setMaxUpdateDelayMillis(maxWaitTime)
       setWaitForAccurateLocation(trackingOptions.getWaitForAccurateLocationOrDefault())
     }.build()
 
     try {
+      android.util.Log.d("LocationService", "Requesting location updates...")
       fusedLocationClient.requestLocationUpdates(
         locationRequest,
         locationCallback,
         Looper.getMainLooper()
-      )
+      ).addOnSuccessListener {
+        android.util.Log.d("LocationService", "Location updates request SUCCESS")
+      }.addOnFailureListener { e ->
+        android.util.Log.e("LocationService", "Location updates request FAILED", e)
+        stopSelf()
+      }
     } catch (e: SecurityException) {
+      android.util.Log.e("LocationService", "SecurityException when requesting location updates", e)
       e.printStackTrace()
       stopSelf()
+    } catch (e: Exception) {
+      android.util.Log.e("LocationService", "Exception when requesting location updates", e)
+      e.printStackTrace()
     }
   }
 
   private fun setupLocationCallback() {
     locationCallback = object : LocationCallback() {
       override fun onLocationResult(locationResult: LocationResult) {
+        android.util.Log.d("LocationService", "Received ${locationResult.locations.size} location(s)")
         locationResult.locations.forEach { location ->
           handleLocation(location)
         }
@@ -126,6 +183,7 @@ class LocationService : Service() {
   }
 
   private fun handleLocation(location: Location) {
+    android.util.Log.d("LocationService", "Handling location: lat=${location.latitude}, lng=${location.longitude}, tripId=$currentTripId")
     currentTripId?.let { tripId ->
       // Extract all available location data
       val accuracy = if (location.hasAccuracy()) location.accuracy else null
@@ -183,17 +241,29 @@ class LocationService : Service() {
    * Sends a location update event to React Native with extended location data
    */
   private fun sendLocationUpdateEvent(tripId: String, location: Location) {
-    reactContext?.let { context ->
-      try {
-        val eventData = createLocationMap(tripId, location)
-        
-        context
-          .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-          .emit("onLocationUpdate", eventData)
-      } catch (e: Exception) {
-        // React Native context may not be available yet
-        e.printStackTrace()
+    val context = reactContext
+    if (context == null) {
+      android.util.Log.w("LocationService", "React context not available - cannot emit location update event")
+      return
+    }
+    
+    try {
+      // Check if the catalyst instance is active
+      if (!context.hasActiveReactInstance()) {
+        android.util.Log.w("LocationService", "React instance not active - skipping location update event")
+        return
       }
+      
+      val eventData = createLocationMap(tripId, location)
+      
+      context
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit("onLocationUpdate", eventData)
+        
+      android.util.Log.d("LocationService", "Location update event emitted for tripId: $tripId")
+    } catch (e: Exception) {
+      // React Native context may not be available yet or JS thread might be busy
+      android.util.Log.e("LocationService", "Failed to emit location update event", e)
     }
   }
 
@@ -325,6 +395,7 @@ class LocationService : Service() {
      * Sets the React Context for event emission
      */
     fun setReactContext(context: ReactContext?) {
+      android.util.Log.d("LocationService", "Setting React context: ${context != null}")
       serviceInstance?.reactContext = context
     }