@tsachit/react-native-geo-service 1.0.0 → 1.0.2

package/android/src/main/java/com/geoservice/LocationService.kt

@@ -7,6 +7,7 @@ import android.content.Intent
 import android.os.Build
 import android.os.IBinder
 import android.util.Log
+import androidx.core.content.ContextCompat
 import androidx.localbroadcastmanager.content.LocalBroadcastManager
 import com.google.android.gms.location.*
 import org.json.JSONObject
@@ -24,6 +25,21 @@ class LocationService : Service() {
 
         var isRunning = false
             private set
+
+        // Session tracking metrics (readable by GeoServiceModule)
+        var updateCount: Long = 0
+            private set
+        var trackingStartTimeMs: Long = 0
+            private set
+        // Accumulated GPS-on milliseconds (excludes current open window)
+        private var gpsAccumulatedMs: Long = 0
+        // When the current GPS-on window started (0 = GPS currently idle)
+        private var gpsActiveWindowStartMs: Long = 0
+
+        /** Total GPS-active ms including any currently open window */
+        val currentGpsActiveMs: Long
+            get() = gpsAccumulatedMs +
+                if (gpsActiveWindowStartMs > 0) System.currentTimeMillis() - gpsActiveWindowStartMs else 0L
     }
 
     private lateinit var fusedLocationClient: FusedLocationProviderClient
@@ -44,12 +60,30 @@ class LocationService : Service() {
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        val bundle = intent?.getBundleExtra("config")
-        config = GeoServiceConfig.fromBundle(bundle)
+        config = if (intent != null) {
+            GeoServiceConfig.fromBundle(intent.getBundleExtra("config"))
+        } else {
+            // START_STICKY restart after force-kill: intent is null, restore from SharedPreferences
+            Log.d(TAG, "START_STICKY restart detected — restoring config from SharedPreferences")
+            configFromSharedPreferences()
+        }
+
+        // Stop immediately if location permission was revoked while we were away
+        if (!hasLocationPermission()) {
+            Log.e(TAG, "Location permission not granted — stopping service")
+            stopSelf()
+            return START_NOT_STICKY
+        }
 
         slowReadingCount = 0
         isIdle = false
 
+        // Reset session metrics
+        updateCount = 0
+        trackingStartTimeMs = System.currentTimeMillis()
+        gpsAccumulatedMs = 0
+        gpsActiveWindowStartMs = System.currentTimeMillis() // GPS starts active
+
         log("Starting — adaptiveAccuracy=${config.adaptiveAccuracy}, accuracy=${config.accuracy}")
         startForeground(NOTIFICATION_ID, buildNotification())
         startLocationUpdates(idleOverride = false)
@@ -58,6 +92,63 @@ class LocationService : Service() {
         return START_STICKY
     }
 
+    // Called when the user swipes the app away from the recents screen.
+    // By default the foreground service keeps running — which is correct for
+    // always-on tracking. If stopOnAppClose=true we honour the user's intent.
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        super.onTaskRemoved(rootIntent)
+        val prefs = getSharedPreferences(BootReceiver.PREFS_NAME, Context.MODE_PRIVATE)
+        val shouldStop = try {
+            val json = prefs.getString("configBundle", null)
+            json?.let { org.json.JSONObject(it).optBoolean("stopOnAppClose", false) } ?: false
+        } catch (e: Exception) { false }
+
+        if (shouldStop) {
+            log("App removed from recents — stopOnAppClose=true, stopping service")
+            prefs.edit().putBoolean(BootReceiver.KEY_IS_TRACKING, false).apply()
+            stopSelf()
+        } else {
+            log("App removed from recents — continuing background tracking")
+        }
+    }
+
+    private fun hasLocationPermission(): Boolean {
+        val fine = ContextCompat.checkSelfPermission(
+            this, android.Manifest.permission.ACCESS_FINE_LOCATION
+        ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+        val coarse = ContextCompat.checkSelfPermission(
+            this, android.Manifest.permission.ACCESS_COARSE_LOCATION
+        ) == android.content.pm.PackageManager.PERMISSION_GRANTED
+        return fine || coarse
+    }
+
+    private fun configFromSharedPreferences(): GeoServiceConfig {
+        val prefs = getSharedPreferences(BootReceiver.PREFS_NAME, Context.MODE_PRIVATE)
+        val configJson = prefs.getString("configBundle", null) ?: return GeoServiceConfig()
+        return try {
+            val json = org.json.JSONObject(configJson)
+            val bundle = android.os.Bundle().apply {
+                putFloat("minDistanceMeters", json.optDouble("minDistanceMeters", 10.0).toFloat())
+                putString("accuracy", json.optString("accuracy", "balanced"))
+                putBoolean("stopOnAppClose", json.optBoolean("stopOnAppClose", false))
+                putBoolean("restartOnBoot", json.optBoolean("restartOnBoot", false))
+                putLong("updateIntervalMs", json.optLong("updateIntervalMs", 5000L))
+                putLong("minUpdateIntervalMs", json.optLong("minUpdateIntervalMs", 2000L))
+                putString("serviceTitle", json.optString("serviceTitle", "Location Tracking"))
+                putString("serviceBody", json.optString("serviceBody", "Your location is being tracked in the background."))
+                putString("backgroundTaskName", json.optString("backgroundTaskName", "GeoServiceHeadlessTask"))
+                putBoolean("adaptiveAccuracy", json.optBoolean("adaptiveAccuracy", true))
+                putFloat("idleSpeedThreshold", json.optDouble("idleSpeedThreshold", 0.5).toFloat())
+                putInt("idleSampleCount", json.optInt("idleSampleCount", 3))
+                putBoolean("debug", json.optBoolean("debug", false))
+            }
+            GeoServiceConfig.fromBundle(bundle)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to restore config from SharedPreferences: ${e.message}")
+            GeoServiceConfig()
+        }
+    }
+
     // ---------------------------------------------------------------------------
     // Location updates
     // ---------------------------------------------------------------------------
@@ -109,6 +200,7 @@ class LocationService : Service() {
     // ---------------------------------------------------------------------------
 
     private fun handleLocation(location: android.location.Location) {
+        updateCount++
         if (config.adaptiveAccuracy) {
             evaluateMotionState(location)
         }
@@ -123,6 +215,11 @@ class LocationService : Service() {
             if (!isIdle && slowReadingCount >= config.idleSampleCount) {
                 isIdle = true
                 slowReadingCount = 0
+                // Accumulate GPS-on time before going idle
+                if (gpsActiveWindowStartMs > 0) {
+                    gpsAccumulatedMs += System.currentTimeMillis() - gpsActiveWindowStartMs
+                    gpsActiveWindowStartMs = 0
+                }
                 log("Device idle — switching to LOW_POWER (GPS off)")
                 startLocationUpdates(idleOverride = true)
             }
@@ -130,6 +227,7 @@ class LocationService : Service() {
             if (isIdle) {
                 isIdle = false
                 slowReadingCount = 0
+                gpsActiveWindowStartMs = System.currentTimeMillis() // GPS back on
                 log("Movement detected — restoring ${config.accuracy} accuracy")
                 startLocationUpdates(idleOverride = false)
             } else {
@@ -195,11 +293,12 @@ class LocationService : Service() {
             putExtra("location", locationJson)
             putExtra("taskName", config.backgroundTaskName)
         }
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            startForegroundService(intent)
-        } else {
-            startService(intent)
-        }
+        // Always use startService — HeadlessJsTaskService does NOT call startForeground().
+        // Using startForegroundService() here would crash with
+        // ForegroundServiceDidNotStartInTimeException after 5 seconds on Android O+.
+        // This is safe because LocationService itself is a foreground service, which
+        // allows it to start background services regardless of app state.
+        startService(intent)
     }
 
     // ---------------------------------------------------------------------------
@@ -237,9 +336,12 @@ class LocationService : Service() {
             PendingIntent.FLAG_UPDATE_CURRENT
         val pendingIntent = PendingIntent.getActivity(this, 0, launchIntent, pendingFlags)
 
+        val title = if (config.debug) "[DEBUG] ${config.serviceTitle}" else config.serviceTitle
+        val body = if (config.debug) "Tracking active — debug mode on" else config.serviceBody
+
         return builder
-            .setContentTitle(config.serviceTitle)
-            .setContentText(config.serviceBody)
+            .setContentTitle(title)
+            .setContentText(body)
             .setSmallIcon(android.R.drawable.ic_menu_mylocation)
             .setOngoing(true)
             .setContentIntent(pendingIntent)

package/android/src/main/java/com/geoservice/WatchdogWorker.kt

@@ -0,0 +1,87 @@
+package com.geoservice
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+
+/**
+ * Periodic watchdog that detects when the LocationService was killed by the OS
+ * (common on Xiaomi, Samsung, Huawei with aggressive battery optimization) and
+ * restarts it using the config persisted in SharedPreferences.
+ *
+ * Scheduled every 15 minutes (WorkManager minimum). If the service is already
+ * running nothing happens. If tracking was expected but the service is dead,
+ * it is restarted with the user's original config.
+ */
+class WatchdogWorker(
+    private val appContext: Context,
+    workerParams: WorkerParameters
+) : CoroutineWorker(appContext, workerParams) {
+
+    companion object {
+        const val TAG = "GeoService:Watchdog"
+        const val WORK_NAME = "GeoServiceWatchdog"
+    }
+
+    override suspend fun doWork(): Result {
+        val prefs = appContext.getSharedPreferences(
+            BootReceiver.PREFS_NAME, Context.MODE_PRIVATE
+        )
+        val isTrackingExpected = prefs.getBoolean(BootReceiver.KEY_IS_TRACKING, false)
+
+        if (!isTrackingExpected) {
+            Log.d(TAG, "Tracking not expected — nothing to do")
+            return Result.success()
+        }
+
+        if (LocationService.isRunning) {
+            Log.d(TAG, "Service is running — no action needed")
+            return Result.success()
+        }
+
+        Log.w(TAG, "Service not running but tracking was expected — restarting")
+
+        val configJson = prefs.getString("configBundle", null)
+        val serviceIntent = Intent(appContext, LocationService::class.java)
+
+        if (configJson != null) {
+            try {
+                val json = org.json.JSONObject(configJson)
+                val bundle = android.os.Bundle().apply {
+                    putFloat("minDistanceMeters", json.optDouble("minDistanceMeters", 10.0).toFloat())
+                    putString("accuracy", json.optString("accuracy", "balanced"))
+                    putBoolean("stopOnAppClose", json.optBoolean("stopOnAppClose", false))
+                    putBoolean("restartOnBoot", json.optBoolean("restartOnBoot", false))
+                    putLong("updateIntervalMs", json.optLong("updateIntervalMs", 5000L))
+                    putLong("minUpdateIntervalMs", json.optLong("minUpdateIntervalMs", 2000L))
+                    putString("serviceTitle", json.optString("serviceTitle", "Location Tracking"))
+                    putString("serviceBody", json.optString("serviceBody", "Your location is being tracked in the background."))
+                    putString("backgroundTaskName", json.optString("backgroundTaskName", "GeoServiceHeadlessTask"))
+                    putBoolean("adaptiveAccuracy", json.optBoolean("adaptiveAccuracy", true))
+                    putFloat("idleSpeedThreshold", json.optDouble("idleSpeedThreshold", 0.5).toFloat())
+                    putInt("idleSampleCount", json.optInt("idleSampleCount", 3))
+                    putBoolean("debug", json.optBoolean("debug", false))
+                }
+                serviceIntent.putExtra("config", bundle)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to parse config — starting with defaults: ${e.message}")
+            }
+        }
+
+        return try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                appContext.startForegroundService(serviceIntent)
+            } else {
+                appContext.startService(serviceIntent)
+            }
+            Log.d(TAG, "Service restarted successfully")
+            Result.success()
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to restart service: ${e.message}")
+            Result.retry()
+        }
+    }
+}

package/debug-panel.d.ts

@@ -0,0 +1 @@
+export {};

package/debug-panel.js

@@ -0,0 +1 @@
+require('./lib/setup');