Revert "feat: switch to androidx.navigation (ReVanced#2362)"

This reverts commit 5d3a81f.

app/build.gradle.kts

@@ -126,7 +126,6 @@ dependencies {
     implementation(libs.compose.livedata)
     implementation(libs.compose.material.icons.extended)
     implementation(libs.compose.material3)
-    implementation(libs.navigation.compose)
 
     // Accompanist
     implementation(libs.accompanist.drawablepainter)
@@ -174,9 +173,11 @@ dependencies {
     // Koin
     implementation(libs.koin.android)
     implementation(libs.koin.compose)
-    implementation(libs.koin.compose.navigation)
     implementation(libs.koin.workmanager)
 
+    // Compose Navigation
+    implementation(libs.reimagined.navigation)
+
     // Licenses
     implementation(libs.about.libraries)
 

app/src/main/java/app/revanced/manager/MainActivity.kt

@@ -1,38 +1,36 @@
 package app.revanced.manager
 
 import android.os.Bundle
-import android.os.Parcelable
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.animation.ExperimentalAnimationApi
 import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
-import androidx.navigation.NavBackStackEntry
-import androidx.navigation.NavController
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.navigation
-import androidx.navigation.compose.rememberNavController
-import androidx.navigation.toRoute
-import app.revanced.manager.ui.model.navigation.*
-import app.revanced.manager.ui.screen.*
-import app.revanced.manager.ui.screen.settings.*
-import app.revanced.manager.ui.screen.settings.update.ChangelogsScreen
-import app.revanced.manager.ui.screen.settings.update.UpdatesSettingsScreen
+import app.revanced.manager.ui.destination.Destination
+import app.revanced.manager.ui.destination.SettingsDestination
+import app.revanced.manager.ui.screen.AppSelectorScreen
+import app.revanced.manager.ui.screen.DashboardScreen
+import app.revanced.manager.ui.screen.InstalledAppInfoScreen
+import app.revanced.manager.ui.screen.PatcherScreen
+import app.revanced.manager.ui.screen.SelectedAppInfoScreen
+import app.revanced.manager.ui.screen.SettingsScreen
 import app.revanced.manager.ui.theme.ReVancedManagerTheme
 import app.revanced.manager.ui.theme.Theme
 import app.revanced.manager.ui.viewmodel.MainViewModel
 import app.revanced.manager.ui.viewmodel.SelectedAppInfoViewModel
 import app.revanced.manager.util.EventEffect
-import org.koin.androidx.compose.koinViewModel
-import org.koin.androidx.compose.navigation.koinNavViewModel
+import dev.olshevski.navigation.reimagined.AnimatedNavHost
+import dev.olshevski.navigation.reimagined.NavBackHandler
+import dev.olshevski.navigation.reimagined.navigate
+import dev.olshevski.navigation.reimagined.pop
+import dev.olshevski.navigation.reimagined.popUpTo
+import dev.olshevski.navigation.reimagined.rememberNavController
 import org.koin.core.parameter.parametersOf
-import org.koin.androidx.viewmodel.ext.android.getViewModel as getActivityViewModel
+import org.koin.androidx.compose.koinViewModel as getComposeViewModel
+import org.koin.androidx.viewmodel.ext.android.getViewModel as getAndroidViewModel
 
 class MainActivity : ComponentActivity() {
     @ExperimentalAnimationApi
@@ -43,7 +41,7 @@ class MainActivity : ComponentActivity() {
         enableEdgeToEdge()
         installSplashScreen()
 
-        val vm: MainViewModel = getActivityViewModel()
+        val vm: MainViewModel = getAndroidViewModel()
         vm.importLegacySettings(this)
 
         setContent {
@@ -54,203 +52,79 @@ class MainActivity : ComponentActivity() {
                 darkTheme = theme == Theme.SYSTEM && isSystemInDarkTheme() || theme == Theme.DARK,
                 dynamicColor = dynamicColor
             ) {
-                ReVancedManager(vm)
-            }
-        }
-    }
-}
-
-@Composable
-private fun ReVancedManager(vm: MainViewModel) {
-    val navController = rememberNavController()
-
-    EventEffect(vm.appSelectFlow) { app ->
-        navController.navigateComplex(
-            SelectedApplicationInfo,
-            SelectedApplicationInfo.ViewModelParams(app)
-        )
-    }
+                val navController =
+                    rememberNavController<Destination>(startDestination = Destination.Dashboard)
+                NavBackHandler(navController)
 
-    NavHost(
-        navController = navController,
-        startDestination = Dashboard,
-    ) {
-        composable<Dashboard> {
-            DashboardScreen(
-                onSettingsClick = { navController.navigate(Settings) },
-                onAppSelectorClick = {
-                    navController.navigate(AppSelector)
-                },
-                onUpdateClick = {
-                    navController.navigate(Update())
-                },
-                onDownloaderPluginClick = {
-                    navController.navigate(Settings.Downloads)
-                },
-                onAppClick = { packageName ->
-                    navController.navigate(InstalledApplicationInfo(packageName))
+                EventEffect(vm.appSelectFlow) { app ->
+                    navController.navigate(Destination.SelectedApplicationInfo(app))
                 }
-            )
-        }
-
-        composable<InstalledApplicationInfo> {
-            val data = it.toRoute<InstalledApplicationInfo>()
-
-            InstalledAppInfoScreen(
-                onPatchClick = vm::selectApp,
-                onBackClick = navController::popBackStack,
-                viewModel = koinViewModel { parametersOf(data.packageName) }
-            )
-        }
-
-        composable<AppSelector> {
-            AppSelectorScreen(
-                onSelect = vm::selectApp,
-                onStorageSelect = vm::selectApp,
-                onBackClick = navController::popBackStack
-            )
-        }
 
-        composable<Patcher> {
-            PatcherScreen(
-                onBackClick = {
-                    navController.navigate(route = Dashboard) {
-                        launchSingleTop = true
-                        popUpTo<Dashboard> {
-                            inclusive = false
-                        }
-                    }
-                },
-                vm = koinViewModel { parametersOf(it.getComplexArg<Patcher.ViewModelParams>()) }
-            )
-        }
+                AnimatedNavHost(
+                    controller = navController
+                ) { destination ->
+                    when (destination) {
+                        is Destination.Dashboard -> DashboardScreen(
+                            onSettingsClick = { navController.navigate(Destination.Settings()) },
+                            onAppSelectorClick = { navController.navigate(Destination.AppSelector) },
+                            onUpdateClick = {
+                                navController.navigate(Destination.Settings(SettingsDestination.Update()))
+                            },
+                            onDownloaderPluginClick = {
+                                navController.navigate(Destination.Settings(SettingsDestination.Downloads))
+                            },
+                            onAppClick = { installedApp ->
+                                navController.navigate(
+                                    Destination.InstalledApplicationInfo(
+                                        installedApp
+                                    )
+                                )
+                            }
+                        )
 
-        composable<Update> {
-            val data = it.toRoute<Update>()
+                        is Destination.InstalledApplicationInfo -> InstalledAppInfoScreen(
+                            onPatchClick = vm::selectApp,
+                            onBackClick = { navController.pop() },
+                            viewModel = getComposeViewModel { parametersOf(destination.installedApp) }
+                        )
 
-            UpdateScreen(
-                onBackClick = navController::popBackStack,
-                vm = koinViewModel { parametersOf(data.downloadOnScreenEntry) }
-            )
-        }
+                        is Destination.Settings -> SettingsScreen(
+                            onBackClick = { navController.pop() },
+                            startDestination = destination.startDestination
+                        )
 
-        navigation<SelectedApplicationInfo>(startDestination = SelectedApplicationInfo.Main) {
-            composable<SelectedApplicationInfo.Main> {
-                val parentBackStackEntry = navController.navGraphEntry(it)
-                val data =
-                    parentBackStackEntry.getComplexArg<SelectedApplicationInfo.ViewModelParams>()
+                        is Destination.AppSelector -> AppSelectorScreen(
+                            onSelect = vm::selectApp,
+                            onStorageSelect = vm::selectApp,
+                            onBackClick = { navController.pop() }
+                        )
 
-                SelectedAppInfoScreen(
-                    onBackClick = navController::popBackStack,
-                    onPatchClick = { app, patches, options ->
-                        navController.navigateComplex(
-                            Patcher,
-                            Patcher.ViewModelParams(app, patches, options)
+                        is Destination.SelectedApplicationInfo -> SelectedAppInfoScreen(
+                            onPatchClick = { app, patches, options ->
+                                navController.navigate(
+                                    Destination.Patcher(
+                                        app, patches, options
+                                    )
+                                )
+                            },
+                            onBackClick = navController::pop,
+                            vm = getComposeViewModel {
+                                parametersOf(
+                                    SelectedAppInfoViewModel.Params(
+                                        destination.selectedApp,
+                                        destination.patchSelection
+                                    )
+                                )
+                            }
                         )
-                    },
-                    onPatchSelectorClick = { app, patches, options ->
-                        navController.navigateComplex(
-                            SelectedApplicationInfo.PatchesSelector,
-                            SelectedApplicationInfo.PatchesSelector.ViewModelParams(
-                                app,
-                                patches,
-                                options
-                            )
+
+                        is Destination.Patcher -> PatcherScreen(
+                            onBackClick = { navController.popUpTo { it is Destination.Dashboard } },
+                            vm = getComposeViewModel { parametersOf(destination) }
                         )
-                    },
-                    vm = koinNavViewModel<SelectedAppInfoViewModel>(viewModelStoreOwner = parentBackStackEntry) {
-                        parametersOf(data)
                     }
-                )
-            }
-
-            composable<SelectedApplicationInfo.PatchesSelector> {
-                val data =
-                    it.getComplexArg<SelectedApplicationInfo.PatchesSelector.ViewModelParams>()
-                val selectedAppInfoVm = koinNavViewModel<SelectedAppInfoViewModel>(
-                    viewModelStoreOwner = navController.navGraphEntry(it)
-                )
-
-                PatchesSelectorScreen(
-                    onBackClick = navController::popBackStack,
-                    onSave = { patches, options ->
-                        selectedAppInfoVm.updateConfiguration(patches, options)
-                        navController.popBackStack()
-                    },
-                    vm = koinViewModel { parametersOf(data) }
-                )
-            }
-        }
-
-        navigation<Settings>(startDestination = Settings.Main) {
-            composable<Settings.Main> {
-                SettingsScreen(
-                    onBackClick = navController::popBackStack,
-                    navigate = navController::navigate
-                )
-            }
-
-            composable<Settings.General> {
-                GeneralSettingsScreen(onBackClick = navController::popBackStack)
-            }
-
-            composable<Settings.Advanced> {
-                AdvancedSettingsScreen(onBackClick = navController::popBackStack)
-            }
-
-            composable<Settings.Updates> {
-                UpdatesSettingsScreen(
-                    onBackClick = navController::popBackStack,
-                    onChangelogClick = { navController.navigate(Settings.Changelogs) },
-                    onUpdateClick = { navController.navigate(Update()) }
-                )
-            }
-
-            composable<Settings.Downloads> {
-                DownloadsSettingsScreen(onBackClick = navController::popBackStack)
-            }
-
-            composable<Settings.ImportExport> {
-                ImportExportSettingsScreen(onBackClick = navController::popBackStack)
-            }
-
-            composable<Settings.About> {
-                AboutSettingsScreen(
-                    onBackClick = navController::popBackStack,
-                    navigate = navController::navigate
-                )
-            }
-
-            composable<Settings.Changelogs> {
-                ChangelogsScreen(onBackClick = navController::popBackStack)
-            }
-
-            composable<Settings.Contributors> {
-                ContributorScreen(onBackClick = navController::popBackStack)
-            }
-
-            composable<Settings.Licenses> {
-                LicensesScreen(onBackClick = navController::popBackStack)
-            }
-
-            composable<Settings.DeveloperOptions> {
-                DeveloperOptionsScreen(onBackClick = navController::popBackStack)
+                }
             }
         }
     }
 }
-
-@Composable
-private fun NavController.navGraphEntry(entry: NavBackStackEntry) =
-    remember(entry) { getBackStackEntry(entry.destination.parent!!.id) }
-
-// Androidx Navigation does not support storing complex types in route objects, so we have to store them inside the saved state handle of the back stack entry instead.
-private fun <T : Parcelable, R : ComplexParameter<T>> NavController.navigateComplex(
-    route: R,
-    data: T
-) {
-    navigate(route)
-    getBackStackEntry(route).savedStateHandle["args"] = data
-}
-
-private fun <T : Parcelable> NavBackStackEntry.getComplexArg() = savedStateHandle.get<T>("args")!!

app/src/main/java/app/revanced/manager/data/room/apps/installed/InstalledApp.kt

@@ -1,20 +1,23 @@
 package app.revanced.manager.data.room.apps.installed
 
+import android.os.Parcelable
 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
 import app.revanced.manager.R
+import kotlinx.parcelize.Parcelize
 
 enum class InstallType(val stringResource: Int) {
     DEFAULT(R.string.default_install),
     MOUNT(R.string.mount_install)
 }
 
+@Parcelize
 @Entity(tableName = "installed_app")
 data class InstalledApp(
     @PrimaryKey
     @ColumnInfo(name = "current_package_name") val currentPackageName: String,
     @ColumnInfo(name = "original_package_name") val originalPackageName: String,
     @ColumnInfo(name = "version") val version: String,
     @ColumnInfo(name = "install_type") val installType: InstallType
-)
+) : Parcelable

app/src/main/java/app/revanced/manager/di/ViewModelModule.kt

@@ -9,7 +9,7 @@ val viewModelModule = module {
     viewModelOf(::DashboardViewModel)
     viewModelOf(::SelectedAppInfoViewModel)
     viewModelOf(::PatchesSelectorViewModel)
-    viewModelOf(::GeneralSettingsViewModel)
+    viewModelOf(::SettingsViewModel)
     viewModelOf(::AdvancedSettingsViewModel)
     viewModelOf(::AppSelectorViewModel)
     viewModelOf(::PatcherViewModel)