added lifesycle support

Author: Namitjain07

PIN_REAUTH_IMPLEMENTATION.md

@@ -0,0 +1,50 @@
+# PIN Re-Authentication Feature
+
+## Overview
+This implementation ensures that users must re-enter their PIN every time they return to the app after switching to another app or going to the home screen.
+
+## How It Works
+
+### 1. **AuthStateManager** (`auth/AuthStateManager.kt`)
+A singleton that manages the authentication state across the app:
+- Tracks whether the user is currently authenticated
+- Tracks whether re-authentication is required
+- Provides methods to update authentication state when app goes to background/foreground
+
+### 2. **MainActivity Lifecycle Observer**
+The MainActivity now observes the app's lifecycle using `ProcessLifecycleOwner`:
+- **onStop()**: Called when the app goes to background → marks that re-authentication is required
+- **onStart()**: Called when the app returns to foreground → the app checks if authentication is needed
+
+### 3. **AppNavigation Updates**
+The navigation component monitors the `requiresAuth` state:
+- When `requiresAuth` becomes true and the user is not authenticated, it automatically navigates to the Auth screen
+- This happens regardless of which screen the user was on
+
+### 4. **AuthScreen Updates**
+The AuthScreen now updates the AuthStateManager when authentication succeeds:
+- After successful PIN entry, it marks the user as authenticated
+- After successful biometric authentication, it marks the user as authenticated
+
+## User Experience
+
+1. User opens the app and enters their PIN → authenticated
+2. User presses home button or switches to another app → app goes to background
+3. App detects background state and marks that re-authentication is required
+4. User returns to the app → Auth screen is automatically shown
+5. User must enter PIN again to continue
+
+## Testing
+
+To test this feature:
+1. Open the app and log in with your PIN
+2. Press the home button or switch to another app
+3. Return to the app
+4. You should see the PIN entry screen again
+
+## Technical Notes
+
+- Uses `ProcessLifecycleOwner` to observe app-wide lifecycle events (not just single Activity)
+- State is managed using Kotlin StateFlow for reactive updates
+- Navigation is handled automatically without requiring back stack manipulation
+- Works seamlessly with both PIN and biometric authentication

app/build.gradle

@@ -89,6 +89,7 @@ dependencies {
     // Lifecycle
     implementation libs.androidx.lifecycle.viewmodel.compose
     implementation libs.androidx.lifecycle.runtime.compose
+    implementation libs.androidx.lifecycle.process
 
     // DataStore for saving onboarding state
     implementation libs.androidx.datastore.preferences

app/src/main/java/com/secure/privacyfirst/MainActivity.kt

@@ -13,10 +13,29 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
 import androidx.core.view.WindowCompat
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import com.secure.privacyfirst.auth.AuthStateManager
 import com.secure.privacyfirst.navigation.AppNavigation
 import com.secure.privacyfirst.ui.theme.PrivacyFirstTheme
 
 class MainActivity : AppCompatActivity() {
+    
+    private val appLifecycleObserver = object : DefaultLifecycleObserver {
+        override fun onStop(owner: LifecycleOwner) {
+            super.onStop(owner)
+            // App went to background - require re-authentication
+            AuthStateManager.onAppBackgrounded()
+        }
+        
+        override fun onStart(owner: LifecycleOwner) {
+            super.onStart(owner)
+            // App came to foreground
+            AuthStateManager.onAppForegrounded()
+        }
+    }
+    
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
@@ -28,6 +47,9 @@ class MainActivity : AppCompatActivity() {
         // Edge-to-edge automatically handles system bar colors
         WindowCompat.setDecorFitsSystemWindows(window, false)
 
+        // Register lifecycle observer to track app foreground/background state
+        ProcessLifecycleOwner.get().lifecycle.addObserver(appLifecycleObserver)
+        
         // Handle back button press using OnBackPressedDispatcher (modern approach)
         onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
@@ -51,4 +73,10 @@ class MainActivity : AppCompatActivity() {
             }
         }
     }
+    
+    override fun onDestroy() {
+        super.onDestroy()
+        // Cleanup lifecycle observer
+        ProcessLifecycleOwner.get().lifecycle.removeObserver(appLifecycleObserver)
+    }
 }

app/src/main/java/com/secure/privacyfirst/auth/AuthStateManager.kt

@@ -0,0 +1,60 @@
+package com.secure.privacyfirst.auth
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Singleton to manage authentication state across the app
+ * Tracks whether user needs to re-authenticate when returning from background
+ */
+object AuthStateManager {
+    private val _isAuthenticated = MutableStateFlow(false)
+    val isAuthenticated: StateFlow<Boolean> = _isAuthenticated.asStateFlow()
+    
+    private val _requiresAuth = MutableStateFlow(false)
+    val requiresAuth: StateFlow<Boolean> = _requiresAuth.asStateFlow()
+    
+    /**
+     * Mark user as authenticated (after successful PIN entry)
+     */
+    fun setAuthenticated(authenticated: Boolean) {
+        _isAuthenticated.value = authenticated
+        if (authenticated) {
+            _requiresAuth.value = false
+        }
+    }
+    
+    /**
+     * Mark that re-authentication is required (app went to background)
+     */
+    fun setRequiresAuth(required: Boolean) {
+        _requiresAuth.value = required
+    }
+    
+    /**
+     * Called when app goes to background
+     */
+    fun onAppBackgrounded() {
+        if (_isAuthenticated.value) {
+            _requiresAuth.value = true
+            _isAuthenticated.value = false
+        }
+    }
+    
+    /**
+     * Called when app comes to foreground
+     */
+    fun onAppForegrounded() {
+        // requiresAuth will be true if user was authenticated before
+        // This will trigger the auth screen to show
+    }
+    
+    /**
+     * Reset all auth state (for logout or similar)
+     */
+    fun reset() {
+        _isAuthenticated.value = false
+        _requiresAuth.value = false
+    }
+}

app/src/main/java/com/secure/privacyfirst/navigation/AppNavigation.kt

@@ -1,10 +1,14 @@
 package com.secure.privacyfirst.navigation
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
 import androidx.compose.ui.platform.LocalContext
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
+import com.secure.privacyfirst.auth.AuthStateManager
 import com.secure.privacyfirst.data.AppDatabase
 import com.secure.privacyfirst.ui.screens.OnboardingScreen
 import com.secure.privacyfirst.ui.screens.SetupScreen
@@ -20,6 +24,27 @@ fun AppNavigation() {
     val context = LocalContext.current
     val database = AppDatabase.getDatabase(context)
 
+    // Observe authentication state
+    val requiresAuth by AuthStateManager.requiresAuth.collectAsState()
+    val isAuthenticated by AuthStateManager.isAuthenticated.collectAsState()
+    
+    // When app comes back from background and requires auth, navigate to Auth screen
+    LaunchedEffect(requiresAuth) {
+        if (requiresAuth && !isAuthenticated) {
+            val currentRoute = navController.currentBackStackEntry?.destination?.route
+            // Only navigate if we're not already on auth/splash/setup/onboarding screens
+            if (currentRoute != Screen.Auth.route && 
+                currentRoute != Screen.Splash.route && 
+                currentRoute != Screen.Setup.route && 
+                currentRoute != Screen.Onboarding.route) {
+                navController.navigate(Screen.Auth.route) {
+                    // Don't pop the back stack - just overlay auth screen
+                    launchSingleTop = true
+                }
+            }
+        }
+    }
+    
     NavHost(
         navController = navController,
         startDestination = Screen.Splash.route

app/src/main/java/com/secure/privacyfirst/ui/screens/AuthScreen.kt

@@ -27,6 +27,7 @@ import androidx.fragment.app.FragmentActivity
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.viewmodel.compose.viewModel
 import androidx.navigation.NavHostController
+import com.secure.privacyfirst.auth.AuthStateManager
 import com.secure.privacyfirst.navigation.Screen
 import com.secure.privacyfirst.viewmodel.PasswordViewModel
 import kotlinx.coroutines.launch
@@ -75,6 +76,8 @@ fun AuthScreen(
             object : BiometricPrompt.AuthenticationCallback() {
                 override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
                     Toast.makeText(context, "Authenticated", Toast.LENGTH_SHORT).show()
+                    // Mark user as authenticated
+                    AuthStateManager.setAuthenticated(true)
                     if (navController != null) {
                         navController.navigate(Screen.WebView.route) {
                             popUpTo(Screen.Auth.route) { inclusive = true }
@@ -205,6 +208,8 @@ fun AuthScreen(
 
                     if (valid) {
                         Toast.makeText(context, "PIN Accepted", Toast.LENGTH_SHORT).show()
+                        // Mark user as authenticated
+                        AuthStateManager.setAuthenticated(true)
                         if (navController != null) {
                             navController.navigate(Screen.WebView.route) {
                                 popUpTo(Screen.Auth.route) { inclusive = true }

gradle/libs.versions.toml

@@ -5,6 +5,7 @@ datastorePreferences = "1.2.0"
 espressoCoreVersion = "3.7.0"
 kotlin = "2.2.21"
 ksp = "2.3.2"
+lifecycleProcess = "2.10.0"
 room = "2.8.4"
 coreKtx = "1.17.0"
 junit = "4.13.2"
@@ -36,6 +37,7 @@ androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref =
 androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastorePreferences" }
 androidx-espresso-core-v351 = { module = "androidx.test.espresso:espresso-core", version.ref = "espressoCoreVersion" }
 androidx-junit-v115 = { module = "androidx.test.ext:junit", version.ref = "androidxJunit" }
+androidx-lifecycle-process = { module = "androidx.lifecycle:lifecycle-process", version.ref = "lifecycleProcess" }
 androidx-lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "lifecycleRuntimeCompose" }
 androidx-lifecycle-runtime-ktx = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "lifecycleRuntimeKtx" }
 androidx-lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "lifecycleViewmodelCompose" }