chore(fc): move deep link handler to top level to support cross-room deeplinks

Signed-off-by: Brandon McAnsh <git@bmcreations.dev>

Author: bmc08gt

flipchatApp/src/main/kotlin/xyz/flipchat/app/App.kt

@@ -12,11 +12,15 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.lifecycle.Lifecycle
+import cafe.adriel.voyager.core.registry.ScreenRegistry
 import cafe.adriel.voyager.core.stack.StackEvent
+import cafe.adriel.voyager.hilt.getViewModel
 import cafe.adriel.voyager.navigator.CurrentScreen
 import cafe.adriel.voyager.navigator.Navigator
 import cafe.adriel.voyager.transitions.SlideTransition
+import com.getcode.navigation.NavScreenProvider
 import xyz.flipchat.app.features.payments.PaymentScaffold
 import com.getcode.navigation.core.BottomSheetNavigator
 import com.getcode.navigation.core.CombinedNavigator
@@ -33,17 +37,22 @@ import com.getcode.ui.components.bars.TopBarContainer
 import com.getcode.ui.components.bars.rememberBarManager
 import com.getcode.ui.decor.ScrimSupport
 import com.getcode.ui.theme.CodeScaffold
+import com.getcode.ui.utils.getActivity
 import dev.bmcreations.tipkit.TipScaffold
 import dev.bmcreations.tipkit.engines.TipsEngine
 import dev.theolm.rinku.DeepLink
 import dev.theolm.rinku.compose.ext.DeepLinkListener
 import xyz.flipchat.app.features.home.HomeViewModel
+import xyz.flipchat.app.util.DeeplinkType
 
 @Composable
 fun App(
     tipsEngine: TipsEngine,
 ) {
     val homeViewModel = getActivityScopedViewModel<HomeViewModel>()
+    val router = homeViewModel.router
+    val context = LocalContext.current
+
     OnLifecycleEvent { _, event ->
         when (event) {
             Lifecycle.Event.ON_RESUME -> {
@@ -59,6 +68,20 @@ fun App(
         }
     }
 
+    //We are obtaining deep link here, in case we want to allow for some amount of deep linking when not
+    //authenticated. Currently we will require authentication to see anything, but can be changed in future.
+    var deepLink by remember { mutableStateOf<DeepLink?>(null) }
+    var loginRequest by remember { mutableStateOf<String?>(null) }
+
+    DeepLinkListener {
+        val type = router.processType(it)
+        if (type is DeeplinkType.Login) {
+            loginRequest = type.entropy
+            return@DeepLinkListener
+        }
+        deepLink = it
+    }
+
     FlipchatTheme {
         val barManager = rememberBarManager()
         AppScreenContent {
@@ -83,6 +106,33 @@ fun App(
                                     ) {
                                         SlideTransition(navigator)
                                     }
+
+                                    LaunchedEffect(deepLink) {
+                                        if (deepLink != null) {
+                                            val screenSet = router.processDestination(deepLink)
+                                            codeNavigator.replaceAll(screenSet)
+                                        }
+                                    }
+
+                                    LaunchedEffect(loginRequest) {
+                                        loginRequest?.let { entropy ->
+                                            homeViewModel.handleLoginEntropy(
+                                                entropy,
+                                                onSwitchAccounts = {
+                                                    loginRequest = null
+                                                    context.getActivity()?.let {
+                                                        homeViewModel.logout(it) {
+                                                            codeNavigator.replaceAll(ScreenRegistry.get(NavScreenProvider.Login.Home(entropy)))
+                                                        }
+                                                    }
+                                                },
+                                                onCancel = {
+                                                    loginRequest = null
+                                                }
+                                            )
+                                        }
+                                    }
+
                                 }
                             }
                         }

flipchatApp/src/main/kotlin/xyz/flipchat/app/features/home/HomeViewModel.kt

@@ -1,5 +1,6 @@
 package xyz.flipchat.app.features.home
 
+import android.app.Activity
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.getcode.manager.BottomBarManager
@@ -17,6 +18,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import xyz.flipchat.app.R
+import xyz.flipchat.app.auth.AuthManager
 import xyz.flipchat.app.util.Router
 import xyz.flipchat.controllers.ChatsController
 import xyz.flipchat.controllers.CodeController
@@ -27,6 +29,7 @@ import javax.inject.Inject
 
 @HiltViewModel
 class HomeViewModel @Inject constructor(
+    private val authManager: AuthManager,
     private val codeController: CodeController,
     private val chatsController: ChatsController,
     private val profileController: ProfileController,
@@ -104,6 +107,22 @@ class HomeViewModel @Inject constructor(
         }
     }
 
+    fun logout(activity: Activity, onComplete: () -> Unit) = viewModelScope.launch {
+        authManager.logout(activity)
+            .onSuccess {
+                chatsController.closeEventStream()
+                onComplete()
+            }
+    }
+
+    fun deleteAccount(activity: Activity, onComplete: () -> Unit) = viewModelScope.launch {
+        authManager.deleteAndLogout(activity)
+            .onSuccess {
+                chatsController.closeEventStream()
+                onComplete()
+            }
+    }
+
     override fun onCleared() {
         super.onCleared()
         closeStream()

flipchatApp/src/main/kotlin/xyz/flipchat/app/features/home/TabbedHomeScreen.kt

@@ -59,54 +59,19 @@ import xyz.flipchat.app.util.DeeplinkType
 import kotlin.math.log
 
 @Parcelize
-class TabbedHomeScreen(private val deeplink: @RawValue DeepLink?) : Screen, Parcelable {
+class TabbedHomeScreen(private val deepLink: @RawValue DeepLink?) : Screen, Parcelable {
     @IgnoredOnParcel
     override val key: ScreenKey = uniqueScreenKey
 
     @Composable
     override fun Content() {
-        val context = LocalContext.current
         val viewModel = getActivityScopedViewModel<HomeViewModel>()
-        val settingsViewModel = getViewModel<SettingsViewModel>()
         val router = viewModel.router
 
         val codeNavigator = LocalCodeNavigator.current
 
         val isLoggedIn by viewModel.isLoggedIn.collectAsState()
 
-        //We are obtaining deep link here, in case we want to allow for some amount of deep linking when not
-        //authenticated. Currently we will require authentication to see anything, but can be changed in future.
-        var deepLink by remember(deeplink) { mutableStateOf(deeplink) }
-        var loginRequest by remember { mutableStateOf<String?>(null) }
-
-        DeepLinkListener {
-            val type = router.processType(it)
-            if (type is DeeplinkType.Login) {
-                loginRequest = type.entropy
-                return@DeepLinkListener
-            }
-            deepLink = it
-        }
-
-        LaunchedEffect(loginRequest) {
-            loginRequest?.let { entropy ->
-                viewModel.handleLoginEntropy(
-                    entropy,
-                    onSwitchAccounts = {
-                        loginRequest = null
-                        context.getActivity()?.let {
-                            settingsViewModel.logout(it) {
-                                codeNavigator.replaceAll(ScreenRegistry.get(NavScreenProvider.Login.Home(entropy)))
-                            }
-                        }
-                    },
-                    onCancel = {
-                        loginRequest = null
-                    }
-                )
-            }
-        }
-
         val initialTab = remember(deepLink) { router.getInitialTabIndex(deepLink) }
 
         OnLifecycleEvent { _, event ->