@rejourneyco/react-native 1.0.0

package/android/src/main/java/com/rejourney/lifecycle/SessionLifecycleService.kt

@@ -0,0 +1,162 @@
+/**
+ * Service to detect when the app is swiped away from recent apps or killed.
+ * 
+ * This service uses onTaskRemoved() callback which is called when the user
+ * swipes the app away from the recent apps screen. By setting stopWithTask="false"
+ * in the manifest, this callback will fire even when the app is killed.
+ * 
+ * IMPORTANT: This is not 100% reliable across all Android versions and OEMs,
+ * but it's the best available mechanism for detecting app termination.
+ */
+package com.rejourney.lifecycle
+
+import android.app.Service
+import android.content.Intent
+import android.os.IBinder
+import android.os.SystemClock
+import com.rejourney.core.Logger
+import com.rejourney.utils.OEMDetector
+import kotlinx.coroutines.*
+
+/**
+ * Callback interface for notifying when app is being killed.
+ * Defined outside the class for better accessibility.
+ * 
+ * CRITICAL: This callback is invoked SYNCHRONOUSLY on the main thread.
+ * The implementation should complete session end as fast as possible
+ * since the process may be killed immediately after this returns.
+ */
+interface TaskRemovedListener {
+    /**
+     * Called when the app is being killed/swiped away.
+     * Implementation should be as fast as possible and use runBlocking
+     * to ensure critical operations complete before process death.
+     */
+    fun onTaskRemoved()
+}
+
+/**
+ * Service that detects app termination via onTaskRemoved() callback.
+ * 
+ * This service must be registered in AndroidManifest.xml with:
+ * - android:stopWithTask="false" (critical - allows onTaskRemoved to fire)
+ * - android:exported="false" (security - don't allow external apps to start it)
+ */
+class SessionLifecycleService : Service() {
+    
+    companion object {
+        private const val TAG = "SessionLifecycleService"
+        
+        // Static listener reference - set by RejourneyModuleImpl
+        @Volatile
+        var taskRemovedListener: TaskRemovedListener? = null
+        
+        // Track if service is running
+        @Volatile
+        var isRunning = false
+            private set
+        
+        // Minimum time between service start and onTaskRemoved to be considered valid
+        // Samsung devices sometimes fire onTaskRemoved immediately on app launch
+        private const val MIN_TIME_BEFORE_TASK_REMOVED_MS = 2000L // 2 seconds
+    }
+    
+    private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    
+    // Track service start time to detect false positives (Samsung bug)
+    // Instance variable, not static, since each service instance has its own start time
+    private var serviceStartTime: Long = 0
+    
+    override fun onCreate() {
+        super.onCreate()
+        isRunning = true
+        serviceStartTime = SystemClock.elapsedRealtime()
+        Logger.debug("[$TAG] Service created (OEM: ${OEMDetector.getOEM()})")
+        Logger.debug("[$TAG] ${OEMDetector.getRecommendations()}")
+    }
+    
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        serviceStartTime = SystemClock.elapsedRealtime()
+        Logger.debug("[$TAG] Service started (startId=$startId, OEM: ${OEMDetector.getOEM()})")
+        // Return START_STICKY to allow system to restart service if killed
+        // This helps ensure the service stays alive to catch termination events
+        return START_STICKY
+    }
+    
+    /**
+     * Called when the user removes a task from the recent apps list.
+     * 
+     * This is the key callback for detecting app swipe-away/kill events.
+     * It fires when:
+     * - User swipes the app away from recent apps
+     * - User taps "Clear all" in recent apps (on some devices)
+     * 
+     * NOTE: This may NOT fire in all cases:
+     * - Some OEMs suppress this callback
+     * - "Clear all" on some devices may not trigger it
+     * - System-initiated kills (low memory) may not trigger it
+     * - Samsung devices have a bug where this fires on app launch (we filter this)
+     * 
+     * That's why we also use ApplicationExitInfo (Android 11+) and
+     * persistent state checking on next app launch as fallbacks.
+     */
+    override fun onTaskRemoved(rootIntent: Intent?) {
+        val timeSinceStart = SystemClock.elapsedRealtime() - serviceStartTime
+        val oem = OEMDetector.getOEM()
+        
+        Logger.debug("[$TAG] ⚠️ onTaskRemoved() called (OEM: $oem, timeSinceStart: ${timeSinceStart}ms)")
+        
+        // SAMSUNG BUG FIX: Samsung devices sometimes fire onTaskRemoved() immediately
+        // after app launch (within 1-2 seconds). This is a known bug on Samsung devices.
+        // We filter out these false positives by checking the time since service start.
+        if (OEMDetector.isSamsung() && timeSinceStart < Companion.MIN_TIME_BEFORE_TASK_REMOVED_MS) {
+            Logger.warning("[$TAG] ⚠️ Ignoring onTaskRemoved() - likely Samsung false positive (fired ${timeSinceStart}ms after start, expected > ${MIN_TIME_BEFORE_TASK_REMOVED_MS}ms)")
+            Logger.warning("[$TAG] This is a known Samsung bug where onTaskRemoved fires on app launch")
+            super.onTaskRemoved(rootIntent)
+            return
+        }
+        
+        // For other OEMs with aggressive task killing, log but still process
+        if (OEMDetector.hasAggressiveTaskKilling()) {
+            Logger.debug("[$TAG] OEM has aggressive task killing - onTaskRemoved may be unreliable")
+        }
+        
+        Logger.debug("[$TAG] ✅ Valid onTaskRemoved() - app is being killed/swiped away")
+        
+        // CRITICAL: Notify the listener IMMEDIATELY and SYNCHRONOUSLY
+        // The previous implementation used a coroutine with 100ms delay which caused
+        // the process to be killed before session end could complete.
+        // 
+        // We now call the listener directly on the main thread. The listener
+        // (RejourneyModuleImpl) is responsible for doing synchronous work as fast
+        // as possible since the process may be killed immediately after this returns.
+        try {
+            Logger.debug("[$TAG] Calling listener synchronously...")
+            taskRemovedListener?.onTaskRemoved()
+            Logger.debug("[$TAG] Task removed listener completed")
+        } catch (e: Exception) {
+            Logger.error("[$TAG] Error notifying task removed listener", e)
+        }
+        
+        // Stop the service - no need for async since listener is already done
+        try {
+            stopSelf()
+        } catch (e: Exception) {
+            Logger.warning("[$TAG] Error stopping service: ${e.message}")
+        }
+        
+        super.onTaskRemoved(rootIntent)
+    }
+    
+    override fun onBind(intent: Intent?): IBinder? {
+        // This is a started service, not a bound service
+        return null
+    }
+    
+    override fun onDestroy() {
+        isRunning = false
+        serviceScope.cancel()
+        Logger.debug("[$TAG] Service destroyed")
+        super.onDestroy()
+    }
+}