chore(deps): bump androidx.compose:compose-bom

Bumps androidx.compose:compose-bom from 2025.08.00 to 2025.08.01.

---
updated-dependencies:
- dependency-name: androidx.compose:compose-bom
  dependency-version: 2025.08.01
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

app/build.gradle.kts

@@ -9,7 +9,6 @@ plugins {
     alias(libs.plugins.compose.compiler)
     alias(libs.plugins.grgit)
     alias(libs.plugins.licensee)
-    id("kotlin-parcelize")
 }
 
 android {
@@ -230,11 +229,6 @@ dependencies {
     implementation(libs.roomdatabasebackup) {
         exclude(group = "org.reactivestreams", module = "reactive-streams")
     }
-
-    // state management
-    implementation(libs.orbit.compose)
-    implementation(libs.orbit.viewmodel)
-    implementation(libs.orbit.core)
 }
 
 tasks.register<Copy>("copyLicenseeJsonToAssets") {

app/proguard-rules.pro

@@ -1,3 +0,0 @@
--keep class com.zaneschepke.wireguardautotunnel.ui.navigation.Route { *; }
--keep class com.zaneschepke.wireguardautotunnel.ui.navigation.Route$** { *; }
--keepclassmembers class com.zaneschepke.wireguardautotunnel.ui.navigation.Route$** { *; }

app/schemas/com.zaneschepke.wireguardautotunnel.data.AppDatabase/22.json

@@ -1,364 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 22,
-    "identityHash": "db93d0490401ccbef25ca39f27bafa29",
-    "entities": [
-      {
-        "tableName": "Settings",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL DEFAULT 0, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL DEFAULT 0, `trusted_network_ssids` TEXT NOT NULL DEFAULT '', `is_always_on_vpn_enabled` INTEGER NOT NULL DEFAULT 0, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL DEFAULT 0, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT 0, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT 0, `is_restore_on_boot_enabled` INTEGER NOT NULL DEFAULT 0, `is_multi_tunnel_enabled` INTEGER NOT NULL DEFAULT 0, `is_ping_enabled` INTEGER NOT NULL DEFAULT 0, `is_wildcards_enabled` INTEGER NOT NULL DEFAULT 0, `is_stop_on_no_internet_enabled` INTEGER NOT NULL DEFAULT 0, `is_lan_on_kill_switch_enabled` INTEGER NOT NULL DEFAULT 0, `debounce_delay_seconds` INTEGER NOT NULL DEFAULT 3, `is_disable_kill_switch_on_trusted_enabled` INTEGER NOT NULL DEFAULT 0, `is_tunnel_on_unsecure_enabled` INTEGER NOT NULL DEFAULT 0, `wifi_detection_method` INTEGER NOT NULL DEFAULT 0, `is_ping_monitoring_enabled` INTEGER NOT NULL DEFAULT 1, `tunnel_ping_interval_sec` INTEGER NOT NULL DEFAULT 30, `tunnel_ping_attempts` INTEGER NOT NULL DEFAULT 3, `tunnel_ping_timeout_sec` INTEGER, `app_mode` INTEGER NOT NULL DEFAULT 0, `dns_protocol` INTEGER NOT NULL DEFAULT 0, `dns_endpoint` TEXT)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "isAutoTunnelEnabled",
-            "columnName": "is_tunnel_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isTunnelOnMobileDataEnabled",
-            "columnName": "is_tunnel_on_mobile_data_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "trustedNetworkSSIDs",
-            "columnName": "trusted_network_ssids",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "isAlwaysOnVpnEnabled",
-            "columnName": "is_always_on_vpn_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isTunnelOnEthernetEnabled",
-            "columnName": "is_tunnel_on_ethernet_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isShortcutsEnabled",
-            "columnName": "is_shortcuts_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isTunnelOnWifiEnabled",
-            "columnName": "is_tunnel_on_wifi_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isRestoreOnBootEnabled",
-            "columnName": "is_restore_on_boot_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isMultiTunnelEnabled",
-            "columnName": "is_multi_tunnel_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isPingEnabled",
-            "columnName": "is_ping_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isWildcardsEnabled",
-            "columnName": "is_wildcards_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isStopOnNoInternetEnabled",
-            "columnName": "is_stop_on_no_internet_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isLanOnKillSwitchEnabled",
-            "columnName": "is_lan_on_kill_switch_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "debounceDelaySeconds",
-            "columnName": "debounce_delay_seconds",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "3"
-          },
-          {
-            "fieldPath": "isDisableKillSwitchOnTrustedEnabled",
-            "columnName": "is_disable_kill_switch_on_trusted_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isTunnelOnUnsecureEnabled",
-            "columnName": "is_tunnel_on_unsecure_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "wifiDetectionMethod",
-            "columnName": "wifi_detection_method",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "isPingMonitoringEnabled",
-            "columnName": "is_ping_monitoring_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "1"
-          },
-          {
-            "fieldPath": "tunnelPingIntervalSeconds",
-            "columnName": "tunnel_ping_interval_sec",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "30"
-          },
-          {
-            "fieldPath": "tunnelPingAttempts",
-            "columnName": "tunnel_ping_attempts",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "3"
-          },
-          {
-            "fieldPath": "tunnelPingTimeoutSeconds",
-            "columnName": "tunnel_ping_timeout_sec",
-            "affinity": "INTEGER"
-          },
-          {
-            "fieldPath": "appMode",
-            "columnName": "app_mode",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "dnsProtocol",
-            "columnName": "dns_protocol",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "dnsEndpoint",
-            "columnName": "dns_endpoint",
-            "affinity": "TEXT"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        }
-      },
-      {
-        "tableName": "TunnelConfig",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false, `restart_on_ping_failure` INTEGER NOT NULL DEFAULT false, `ping_target` TEXT DEFAULT null, `is_ethernet_tunnel` INTEGER NOT NULL DEFAULT false, `is_ipv4_preferred` INTEGER NOT NULL DEFAULT true, `position` INTEGER NOT NULL DEFAULT 0, `auto_tunnel_apps` TEXT NOT NULL DEFAULT '[]')",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "name",
-            "columnName": "name",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "wgQuick",
-            "columnName": "wg_quick",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tunnelNetworks",
-            "columnName": "tunnel_networks",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "isMobileDataTunnel",
-            "columnName": "is_mobile_data_tunnel",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isPrimaryTunnel",
-            "columnName": "is_primary_tunnel",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "amQuick",
-            "columnName": "am_quick",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "isActive",
-            "columnName": "is_Active",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "restartOnPingFailure",
-            "columnName": "restart_on_ping_failure",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "pingTarget",
-            "columnName": "ping_target",
-            "affinity": "TEXT",
-            "defaultValue": "null"
-          },
-          {
-            "fieldPath": "isEthernetTunnel",
-            "columnName": "is_ethernet_tunnel",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isIpv4Preferred",
-            "columnName": "is_ipv4_preferred",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "true"
-          },
-          {
-            "fieldPath": "position",
-            "columnName": "position",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "autoTunnelApps",
-            "columnName": "auto_tunnel_apps",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "'[]'"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_TunnelConfig_name",
-            "unique": true,
-            "columnNames": [
-              "name"
-            ],
-            "orders": [],
-            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
-          }
-        ]
-      },
-      {
-        "tableName": "proxy_settings",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `socks5_proxy_enabled` INTEGER NOT NULL DEFAULT 0, `socks5_proxy_bind_address` TEXT, `http_proxy_enable` INTEGER NOT NULL DEFAULT 0, `http_proxy_bind_address` TEXT, `proxy_username` TEXT, `proxy_password` TEXT)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "socks5ProxyEnabled",
-            "columnName": "socks5_proxy_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "socks5ProxyBindAddress",
-            "columnName": "socks5_proxy_bind_address",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "httpProxyEnabled",
-            "columnName": "http_proxy_enable",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "0"
-          },
-          {
-            "fieldPath": "httpProxyBindAddress",
-            "columnName": "http_proxy_bind_address",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "proxyUsername",
-            "columnName": "proxy_username",
-            "affinity": "TEXT"
-          },
-          {
-            "fieldPath": "proxyPassword",
-            "columnName": "proxy_password",
-            "affinity": "TEXT"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        }
-      }
-    ],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'db93d0490401ccbef25ca39f27bafa29')"
-    ]
-  }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/MainActivity.kt

@@ -1,6 +1,5 @@
 package com.zaneschepke.wireguardautotunnel
 
-import ProxySettingsScreen
 import android.annotation.SuppressLint
 import android.content.Intent
 import android.graphics.Color
@@ -16,12 +15,16 @@ import androidx.activity.result.ActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
 import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.layout.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.zIndex
@@ -31,29 +34,35 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
+import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
-import androidx.navigation.navigation
 import androidx.navigation.toRoute
 import com.zaneschepke.networkmonitor.NetworkMonitor
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.data.AppDatabase
 import com.zaneschepke.wireguardautotunnel.data.model.AppMode
-import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.di.MainDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.domain.sideeffect.GlobalSideEffect
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
-import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
+import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.banner.AppAlertBanner
 import com.zaneschepke.wireguardautotunnel.ui.common.dialog.VpnDeniedDialog
 import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.CustomSnackBar
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.navigation.components.BottomNavbar
 import com.zaneschepke.wireguardautotunnel.ui.navigation.components.DynamicTopAppBar
+import com.zaneschepke.wireguardautotunnel.ui.navigation.components.currentNavBackStackEntryAsNavBarState
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.AutoTunnelScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.advanced.AutoTunnelAdvancedScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.detection.WifiDetectionMethodScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.LocationDisclosureScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.TunnelAutoTunnelScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.ConfigScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.sort.SortScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.SplitTunnelScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.tunneloptions.TunnelOptionsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.pin.PinLockScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.AppearanceScreen
@@ -62,38 +71,47 @@ import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.langua
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.dns.DnsSettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.logs.LogsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.monitoring.TunnelMonitoringScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.proxy.ProxySettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.system.SystemFeaturesScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.license.LicenseScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.TunnelsScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.TunnelAutoTunnelScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.ConfigScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.sort.SortScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.SplitTunnelScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.tunneloptions.TunnelOptionsScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.AlertRed
 import com.zaneschepke.wireguardautotunnel.ui.theme.OffWhite
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
-import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
-import com.zaneschepke.wireguardautotunnel.util.extensions.*
-import com.zaneschepke.wireguardautotunnel.viewmodel.*
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
+import com.zaneschepke.wireguardautotunnel.util.extensions.restartApp
+import com.zaneschepke.wireguardautotunnel.util.extensions.showToast
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 import dagger.hilt.android.AndroidEntryPoint
 import de.raphaelebner.roomdatabasebackup.core.RoomBackup
-import java.util.*
+import java.util.Locale
 import javax.inject.Inject
+import kotlin.system.exitProcess
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.launch
-import xyz.teamgravity.pin_lock_compose.PinManager
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
 
     @Inject lateinit var appStateRepository: AppStateRepository
+
     @Inject lateinit var tunnelManager: TunnelManager
+
     @Inject lateinit var networkMonitor: NetworkMonitor
+
+    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
+
+    @Inject @MainDispatcher lateinit var mainDispatcher: CoroutineDispatcher
+
     @Inject lateinit var appDatabase: AppDatabase
 
+    private var lastLocationPermissionState: Boolean? = null
+
     private lateinit var roomBackup: RoomBackup
 
+    val REQUEST_CODE = 123
+
     @SuppressLint("BatteryLife")
     override fun onCreate(savedInstanceState: Bundle?) {
         enableEdgeToEdge(
@@ -104,40 +122,32 @@ class MainActivity : AppCompatActivity() {
             window.isNavigationBarContrastEnforced = false
         }
         super.onCreate(savedInstanceState)
-
         roomBackup = RoomBackup(this)
 
-        val viewModel by viewModels<SharedAppViewModel>()
+        val viewModel by viewModels<AppViewModel>()
 
         installSplashScreen().apply {
-            setKeepOnScreenCondition { !viewModel.container.stateFlow.value.isAppLoaded }
+            setKeepOnScreenCondition { !viewModel.appViewState.value.isAppReady }
         }
 
         setContent {
-            val context = LocalContext.current
             val isTv = isRunningOnTv()
-            val appState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
+            val appUiState by viewModel.uiState.collectAsStateWithLifecycle()
+            val appViewState by viewModel.appViewState.collectAsStateWithLifecycle()
+
             val navController = rememberNavController()
-            val scope = rememberCoroutineScope()
-
-            var pinManagerInitialized by remember { mutableStateOf(false) }
-
-            LaunchedEffect(appState.isAppLoaded) {
-                if (appState.isAppLoaded) {
-                    if (appState.pinLockEnabled && !pinManagerInitialized) {
-                        PinManager.initialize(this@MainActivity)
-                        pinManagerInitialized = true
-                    }
-                    appState.locale.let { LocaleUtil.changeLocale(it) }
-                }
-            }
-
+            val backStackEntry by navController.currentBackStackEntryAsState()
+            val navBarState by
+                currentNavBackStackEntryAsNavBarState(
+                    navController,
+                    backStackEntry,
+                    viewModel,
+                    appUiState,
+                    appViewState,
+                )
             val snackbar = remember { SnackbarHostState() }
             var showVpnPermissionDialog by remember { mutableStateOf(false) }
             var vpnPermissionDenied by remember { mutableStateOf(false) }
-            var requestingAppMode by remember {
-                mutableStateOf<Pair<AppMode?, TunnelConf?>>(Pair(null, null))
-            }
 
             val vpnActivity =
                 rememberLauncherForActivityResult(
@@ -149,237 +159,214 @@ class MainActivity : AppCompatActivity() {
                         } else {
                             vpnPermissionDenied = false
                             showVpnPermissionDialog = false
-                            val (appMode, config) = requestingAppMode
-                            when (appMode) {
-                                AppMode.VPN -> if (config != null) viewModel.startTunnel(config)
-                                AppMode.LOCK_DOWN -> viewModel.setAppMode(AppMode.LOCK_DOWN)
-                                else -> Unit
-                            }
                         }
-                        requestingAppMode = Pair(null, null)
                     },
                 )
 
+            LaunchedEffect(appUiState.tunnels) {
+                if (!appViewState.isAppReady) {
+                    viewModel.handleEvent(AppEvent.AppReadyCheck(appUiState.tunnels))
+                }
+            }
+
             val batteryActivity =
                 rememberLauncherForActivityResult(
                     ActivityResultContracts.StartActivityForResult()
                 ) { _: ActivityResult ->
-                    viewModel.disableBatteryOptimizationsShown()
+                    viewModel.handleEvent(AppEvent.SetBatteryOptimizeDisableShown)
                 }
 
-            fun requestDisableBatteryOptimizations() {
-                batteryActivity.launch(
-                    Intent().apply {
-                        action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
-                        data = "package:${this@MainActivity.packageName}".toUri()
+            with(appViewState) {
+                LaunchedEffect(isConfigChanged) {
+                    if (isConfigChanged) {
+                        Intent(this@MainActivity, MainActivity::class.java).also {
+                            startActivity(it)
+                            exitProcess(0)
+                        }
                     }
-                )
-            }
-
-            LaunchedEffect(Unit) {
-                viewModel.globalSideEffect.collect { sideEffect ->
-                    when (sideEffect) {
-                        GlobalSideEffect.ConfigChanged -> restartApp()
-                        GlobalSideEffect.PopBackStack -> navController.popBackStack()
-                        GlobalSideEffect.RequestBatteryOptimizationDisabled ->
-                            requestDisableBatteryOptimizations()
-                        is GlobalSideEffect.RequestVpnPermission -> {
-                            requestingAppMode = Pair(sideEffect.requestingMode, sideEffect.config)
+                }
+                LaunchedEffect(errorMessage) {
+                    errorMessage?.let {
+                        snackbar.showSnackbar(it.asString(this@MainActivity))
+                        viewModel.handleEvent(AppEvent.MessageShown)
+                    }
+                }
+                LaunchedEffect(popBackStack) {
+                    if (popBackStack) {
+                        navController.popBackStack()
+                        viewModel.handleEvent(AppEvent.PopBackStack(false))
+                    }
+                }
+                LaunchedEffect(requestVpnPermission) {
+                    if (requestVpnPermission) {
+                        if (!vpnPermissionDenied) {
                             vpnActivity.launch(VpnService.prepare(this@MainActivity))
+                        } else {
+                            showVpnPermissionDialog = true
                         }
-                        is GlobalSideEffect.ShareFile -> context.launchShareFile(sideEffect.file)
-                        is GlobalSideEffect.Snackbar ->
-                            scope.launch {
-                                snackbar.showSnackbar(sideEffect.message.asString(context))
+                        viewModel.handleEvent(AppEvent.VpnPermissionRequested)
+                    }
+                }
+                LaunchedEffect(requestBatteryPermission) {
+                    if (requestBatteryPermission) {
+                        batteryActivity.launch(
+                            Intent().apply {
+                                action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
+                                data = "package:${this@MainActivity.packageName}".toUri()
                             }
-                        is GlobalSideEffect.Toast ->
-                            scope.launch { context.showToast(sideEffect.message.asString(context)) }
-                        is GlobalSideEffect.LaunchUrl -> context.openWebUrl(sideEffect.url)
-                        is GlobalSideEffect.InstallApk -> context.installApk(sideEffect.apk)
+                        )
                     }
                 }
             }
 
-            if (!appState.isAppLoaded) return@setContent
-
-            CompositionLocalProvider(
-                LocalIsAndroidTV provides isTv,
-                LocalSharedVm provides viewModel,
-                LocalNavController provides navController,
-            ) {
-                WireguardAutoTunnelTheme(theme = appState.theme) {
-                    VpnDeniedDialog(
-                        showVpnPermissionDialog,
-                        onDismiss = {
-                            showVpnPermissionDialog = false
-                            vpnPermissionDenied = false
-                        },
-                    )
-
-                    Box(modifier = Modifier.fillMaxSize()) {
-                        if (appState.settings.appMode == AppMode.LOCK_DOWN) {
-                            AppAlertBanner(
-                                stringResource(R.string.locked_down).uppercase(Locale.getDefault()),
-                                OffWhite,
-                                AlertRed,
-                                modifier = Modifier.fillMaxWidth().zIndex(2f),
-                            )
-                        }
-
-                        Scaffold(
-                            snackbarHost = {
-                                SnackbarHost(snackbar) { snackbarData ->
-                                    CustomSnackBar(
-                                        snackbarData.visuals.message,
-                                        isRtl = false,
-                                        containerColor =
-                                            MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp),
-                                    )
-                                }
+            CompositionLocalProvider(LocalIsAndroidTV provides isTv) {
+                CompositionLocalProvider(LocalNavController provides navController) {
+                    WireguardAutoTunnelTheme(theme = appUiState.appState.theme) {
+                        VpnDeniedDialog(
+                            showVpnPermissionDialog,
+                            onDismiss = {
+                                showVpnPermissionDialog = false
+                                vpnPermissionDenied = false
                             },
-                            topBar = { DynamicTopAppBar(appState.navBarState) },
-                            bottomBar = {
-                                BottomNavbar(
-                                    appState.isAutoTunnelActive,
-                                    appState.navBarState,
-                                    navController,
+                        )
+
+                        Box(modifier = Modifier.fillMaxSize()) {
+                            // Top banner if in locked down mode
+                            if (appUiState.appSettings.appMode == AppMode.LOCK_DOWN) {
+                                AppAlertBanner(
+                                    stringResource(R.string.locked_down)
+                                        .uppercase(Locale.getDefault()),
+                                    OffWhite,
+                                    AlertRed,
+                                    modifier =
+                                        Modifier.fillMaxWidth().zIndex(2f), // Draw above everything
                                 )
-                            },
-                        ) { padding ->
-                            Box(
-                                modifier =
-                                    Modifier.fillMaxSize()
-                                        .background(MaterialTheme.colorScheme.surface)
-                                        .padding(padding)
-                                        .consumeWindowInsets(padding)
-                                        .imePadding()
-                            ) {
-                                NavHost(
-                                    navController = navController,
-                                    startDestination =
-                                        if (appState.pinLockEnabled && !appState.isAuthorized)
-                                            Route.Lock
-                                        else Route.TunnelsGraph,
-                                ) {
-                                    composable<Route.Lock> { PinLockScreen() }
-                                    navigation<Route.TunnelsGraph>(
-                                        startDestination = Route.Tunnels
-                                    ) {
-                                        composable<Route.Tunnels> {
-                                            val viewModel =
-                                                it.sharedViewModel<TunnelsViewModel>(navController)
-                                            TunnelsScreen(viewModel)
-                                        }
-                                        composable<Route.Sort> {
-                                            val viewModel =
-                                                it.sharedViewModel<TunnelsViewModel>(navController)
-                                            SortScreen(viewModel)
-                                        }
-                                        composable<Route.TunnelOptions> { backStackEntry ->
-                                            val args = backStackEntry.toRoute<Route.TunnelOptions>()
-                                            val viewModel =
-                                                backStackEntry.sharedViewModel<TunnelsViewModel>(
-                                                    navController
-                                                )
-                                            TunnelOptionsScreen(args.id, viewModel)
-                                        }
-                                        composable<Route.SplitTunnel> { backStackEntry ->
-                                            val args = backStackEntry.toRoute<Route.SplitTunnel>()
-                                            SplitTunnelScreen(args.id)
-                                        }
-                                        composable<Route.TunnelAutoTunnel> { backStackEntry ->
-                                            val args =
-                                                backStackEntry.toRoute<Route.TunnelAutoTunnel>()
-                                            val viewModel =
-                                                backStackEntry.sharedViewModel<TunnelsViewModel>(
-                                                    navController
-                                                )
-                                            TunnelAutoTunnelScreen(args.id, viewModel)
-                                        }
-                                        composable<Route.Config> { backStackEntry ->
-                                            val args = backStackEntry.toRoute<Route.Config>()
-                                            val viewModel =
-                                                backStackEntry.sharedViewModel<TunnelsViewModel>(
-                                                    navController
-                                                )
-                                            ConfigScreen(args.id, viewModel)
-                                        }
-                                    }
+                            }
 
-                                    navigation<Route.AutoTunnelGraph>(
-                                        startDestination =
-                                            if (appState.isLocationDisclosureShown) Route.AutoTunnel
-                                            else Route.LocationDisclosure
+                            Scaffold(
+                                modifier =
+                                    Modifier.pointerInput(Unit) {
+                                        detectTapGestures {
+                                            viewModel.handleEvent(AppEvent.ClearSelectedTunnels)
+                                        }
+                                    },
+                                snackbarHost = {
+                                    SnackbarHost(snackbar) { snackbarData: SnackbarData ->
+                                        CustomSnackBar(
+                                            snackbarData.visuals.message,
+                                            isRtl = false,
+                                            containerColor =
+                                                MaterialTheme.colorScheme.surfaceColorAtElevation(
+                                                    2.dp
+                                                ),
+                                        )
+                                    }
+                                },
+                                topBar = { DynamicTopAppBar(navBarState) },
+                                bottomBar = {
+                                    AnimatedVisibility(
+                                        visible = navBarState.showBottom,
+                                        enter = slideInVertically(initialOffsetY = { it }),
+                                        exit = slideOutVertically(targetOffsetY = { it }),
                                     ) {
+                                        BottomNavbar(appUiState = appUiState)
+                                    }
+                                },
+                            ) { padding ->
+                                Box(
+                                    modifier =
+                                        Modifier.fillMaxSize()
+                                            .background(MaterialTheme.colorScheme.surface)
+                                            .padding(padding)
+                                            .consumeWindowInsets(padding)
+                                            .imePadding()
+                                ) {
+                                    NavHost(
+                                        navController,
+                                        startDestination =
+                                            (if (appUiState.appState.isPinLockEnabled) Route.Lock
+                                            else Route.Main),
+                                    ) {
+                                        composable<Route.Main> {
+                                            MainScreen(appUiState, appViewState, viewModel)
+                                        }
+                                        composable<Route.Settings> {
+                                            SettingsScreen(appUiState, appViewState, viewModel)
+                                        }
                                         composable<Route.LocationDisclosure> {
-                                            val viewModel =
-                                                it.sharedViewModel<AutoTunnelViewModel>(
-                                                    navController
-                                                )
                                             LocationDisclosureScreen(viewModel)
                                         }
                                         composable<Route.AutoTunnel> {
-                                            val viewModel =
-                                                it.sharedViewModel<AutoTunnelViewModel>(
-                                                    navController
-                                                )
-                                            AutoTunnelScreen(viewModel)
+                                            AutoTunnelScreen(appUiState, viewModel)
                                         }
-                                        composable<Route.AdvancedAutoTunnel> {
-                                            val viewModel =
-                                                it.sharedViewModel<AutoTunnelViewModel>(
-                                                    navController
-                                                )
-                                            AutoTunnelAdvancedScreen(viewModel)
-                                        }
-                                        composable<Route.WifiDetectionMethod> {
-                                            val viewModel =
-                                                it.sharedViewModel<AutoTunnelViewModel>(
-                                                    navController
-                                                )
-                                            WifiDetectionMethodScreen(viewModel)
-                                        }
-                                    }
-
-                                    navigation<Route.SettingsGraph>(
-                                        startDestination = Route.Settings
-                                    ) {
-                                        composable<Route.Settings> {
-                                            val viewModel =
-                                                it.sharedViewModel<SettingsViewModel>(navController)
-                                            SettingsScreen(viewModel)
-                                        }
-                                        composable<Route.TunnelMonitoring> {
-                                            val viewModel =
-                                                it.sharedViewModel<SettingsViewModel>(navController)
-                                            TunnelMonitoringScreen(viewModel)
-                                        }
-                                        composable<Route.SystemFeatures> {
-                                            val viewModel =
-                                                it.sharedViewModel<SettingsViewModel>(navController)
-                                            SystemFeaturesScreen(viewModel)
-                                        }
-                                        composable<Route.Dns> {
-                                            val viewModel =
-                                                it.sharedViewModel<SettingsViewModel>(navController)
-                                            DnsSettingsScreen(viewModel)
-                                        }
-                                        composable<Route.ProxySettings> { ProxySettingsScreen() }
                                         composable<Route.Appearance> { AppearanceScreen() }
-                                        composable<Route.Language> { LanguageScreen() }
-                                        composable<Route.Display> { DisplayScreen() }
-                                        composable<Route.Logs> { LogsScreen() }
-                                    }
-
-                                    navigation<Route.SupportGraph>(
-                                        startDestination = Route.Support
-                                    ) {
+                                        composable<Route.Language> {
+                                            LanguageScreen(appUiState, viewModel)
+                                        }
+                                        composable<Route.Display> {
+                                            DisplayScreen(appUiState, viewModel)
+                                        }
                                         composable<Route.Support> {
-                                            val viewModel =
-                                                it.sharedViewModel<SupportViewModel>(navController)
-                                            SupportScreen(viewModel)
+                                            SupportScreen(appViewModel = viewModel)
                                         }
                                         composable<Route.License> { LicenseScreen() }
+                                        composable<Route.AutoTunnelAdvanced> {
+                                            AutoTunnelAdvancedScreen(appUiState, viewModel)
+                                        }
+                                        composable<Route.WifiDetectionMethod> {
+                                            WifiDetectionMethodScreen(appUiState, viewModel)
+                                        }
+                                        composable<Route.Logs> {
+                                            LogsScreen(appViewState, viewModel)
+                                        }
+                                        composable<Route.Config> { backStack ->
+                                            val args = backStack.toRoute<Route.Config>()
+                                            val config =
+                                                appUiState.tunnels.firstOrNull { it.id == args.id }
+                                            ConfigScreen(config, appUiState, viewModel)
+                                        }
+                                        composable<Route.TunnelOptions> { backStack ->
+                                            val args = backStack.toRoute<Route.TunnelOptions>()
+                                            appUiState.tunnels
+                                                .firstOrNull { it.id == args.id }
+                                                ?.let { config ->
+                                                    TunnelOptionsScreen(
+                                                        config,
+                                                        viewModel,
+                                                        appViewState,
+                                                        appUiState.appSettings,
+                                                    )
+                                                }
+                                        }
+                                        composable<Route.Lock> { PinLockScreen(viewModel) }
+                                        composable<Route.SplitTunnel> {
+                                            SplitTunnelScreen(viewModel)
+                                        }
+                                        composable<Route.TunnelAutoTunnel> { backStack ->
+                                            val args = backStack.toRoute<Route.TunnelOptions>()
+                                            appUiState.tunnels
+                                                .firstOrNull { it.id == args.id }
+                                                ?.let {
+                                                    TunnelAutoTunnelScreen(
+                                                        it,
+                                                        appUiState.appSettings,
+                                                        viewModel,
+                                                    )
+                                                }
+                                        }
+                                        composable<Route.Sort> { SortScreen(appUiState, viewModel) }
+                                        composable<Route.TunnelMonitoring> {
+                                            TunnelMonitoringScreen(appUiState, viewModel)
+                                        }
+                                        composable<Route.ProxySettings> {
+                                            ProxySettingsScreen(appUiState, viewModel)
+                                        }
+                                        composable<Route.SystemFeatures> {
+                                            SystemFeaturesScreen(appUiState, viewModel)
+                                        }
+                                        composable<Route.Dns> {
+                                            DnsSettingsScreen(appUiState, viewModel)
+                                        }
                                     }
                                 }
                             }
@@ -402,15 +389,15 @@ class MainActivity : AppCompatActivity() {
     }
 
     fun performBackup() =
-        lifecycleScope.launch {
+        lifecycleScope.launch(ioDispatcher) {
             roomBackup
                 .database(appDatabase)
                 .backupLocation(RoomBackup.BACKUP_FILE_LOCATION_CUSTOM_DIALOG)
                 .enableLogDebug(true)
                 .maxFileCount(5)
                 .apply {
-                    onCompleteListener { success, _, _ ->
-                        lifecycleScope.launch {
+                    onCompleteListener { success, message, exitCode ->
+                        lifecycleScope.launch(mainDispatcher) {
                             if (success) {
                                 showToast(
                                     getString(
@@ -419,9 +406,7 @@ class MainActivity : AppCompatActivity() {
                                     )
                                 )
                                 restartApp()
-                            } else {
-                                showToast(R.string.backup_failed)
-                            }
+                            } else showToast(R.string.backup_failed)
                         }
                     }
                 }
@@ -435,8 +420,8 @@ class MainActivity : AppCompatActivity() {
                 .enableLogDebug(true)
                 .backupLocation(RoomBackup.BACKUP_FILE_LOCATION_CUSTOM_DIALOG)
                 .apply {
-                    onCompleteListener { success, _, _ ->
-                        lifecycleScope.launch {
+                    onCompleteListener { success, message, exitCode ->
+                        lifecycleScope.launch(mainDispatcher) {
                             if (success) {
                                 showToast(
                                     getString(
@@ -445,9 +430,7 @@ class MainActivity : AppCompatActivity() {
                                     )
                                 )
                                 restartApp()
-                            } else {
-                                showToast(R.string.restore_failed)
-                            }
+                            } else showToast(R.string.restore_failed)
                         }
                     }
                 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/WireGuardAutoTunnel.kt

@@ -15,16 +15,14 @@ import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.di.MainDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendMode
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
 import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
 import dagger.hilt.android.HiltAndroidApp
 import javax.inject.Inject
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.cancel
+import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
 import timber.log.Timber
 
 @HiltAndroidApp
@@ -66,11 +64,6 @@ class WireGuardAutoTunnel : Application(), Configuration.Provider {
             Timber.plant(ReleaseTree())
         }
 
-        applicationScope.launch(ioDispatcher) {
-            launch { if (appDataRepository.appState.isLocalLogsEnabled()) logReader.start() }
-            launch { notificationMonitor.handleApplicationNotifications() }
-        }
-
         GoBackend.setAlwaysOnCallback {
             applicationScope.launch {
                 val settings = appDataRepository.settings.get()
@@ -84,6 +77,16 @@ class WireGuardAutoTunnel : Application(), Configuration.Provider {
         }
 
         ServiceWorker.start(this)
+
+        applicationScope.launch {
+            launch { notificationMonitor.handleApplicationNotifications() }
+            appDataRepository.appState.getLocale()?.let {
+                withContext(mainDispatcher) { LocaleUtil.changeLocale(it) }
+            }
+            appDataRepository.appState.isLocalLogsEnabled().let { enabled ->
+                if (enabled) logReader.start()
+            }
+        }
     }
 
     override fun onTerminate() {

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/notification/NotificationManager.kt

@@ -16,9 +16,9 @@ interface NotificationManager {
         title: String = "",
         actions: Collection<NotificationCompat.Action> = emptyList(),
         description: String = "",
-        showTimestamp: Boolean = true,
+        showTimestamp: Boolean = false,
         importance: Int = NotificationManager.IMPORTANCE_HIGH,
-        onGoing: Boolean = false,
+        onGoing: Boolean = true,
         onlyAlertOnce: Boolean = true,
     ): Notification
 
@@ -27,9 +27,9 @@ interface NotificationManager {
         title: StringValue,
         actions: Collection<NotificationCompat.Action> = emptyList(),
         description: StringValue,
-        showTimestamp: Boolean = true,
+        showTimestamp: Boolean = false,
         importance: Int = NotificationManager.IMPORTANCE_HIGH,
-        onGoing: Boolean = false,
+        onGoing: Boolean = true,
         onlyAlertOnce: Boolean = true,
     ): Notification
 

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/service/TunnelForegroundService.kt

@@ -131,7 +131,6 @@ class TunnelForegroundService : LifecycleService() {
                         tunnelConf.id,
                     )
                 ),
-            onGoing = true,
         )
     }
 

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/service/autotunnel/AutoTunnelService.kt

@@ -19,14 +19,13 @@ import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus.StopReason.Ping
 import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent
-import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.AutoTunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
-import com.zaneschepke.wireguardautotunnel.util.extensions.to
 import com.zaneschepke.wireguardautotunnel.util.extensions.toMillis
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
@@ -118,7 +117,6 @@ class AutoTunnelService : LifecycleService() {
                             NotificationAction.AUTO_TUNNEL_OFF
                         )
                     ),
-                onGoing = true,
             )
         ServiceCompat.startForeground(
             this,
@@ -242,7 +240,7 @@ class AutoTunnelService : LifecycleService() {
     }
 
     // all relevant settings to auto tunnel
-    private fun areAutoTunnelSettingsTheSame(old: GeneralSettings, new: GeneralSettings): Boolean {
+    private fun areAutoTunnelSettingsTheSame(old: AppSettings, new: AppSettings): Boolean {
         return (old.isTunnelOnWifiEnabled == new.isTunnelOnWifiEnabled &&
             old.isTunnelOnMobileDataEnabled == new.isTunnelOnMobileDataEnabled &&
             old.isTunnelOnEthernetEnabled == new.isTunnelOnEthernetEnabled &&
@@ -256,7 +254,7 @@ class AutoTunnelService : LifecycleService() {
             old.isStopOnNoInternetEnabled == new.isStopOnNoInternetEnabled)
     }
 
-    private fun combineSettings(): Flow<Pair<GeneralSettings, Tunnels>> {
+    private fun combineSettings(): Flow<Pair<AppSettings, Tunnels>> {
         return combine(
                 appDataRepository
                     .get()
@@ -304,7 +302,7 @@ class AutoTunnelService : LifecycleService() {
                 .distinctUntilChanged(::areAutoTunnelPermissionsRequiredTheSame)
                 .map {
                     NetworkPermissionState(
-                        it.settings.wifiDetectionMethod.to(),
+                        it.settings.wifiDetectionMethod,
                         it.networkState.locationServicesEnabled == true,
                         it.networkState.locationPermissionGranted == true,
                         (it.tunnels.any { tunnel -> tunnel.tunnelNetworks.isNotEmpty() } ||

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/service/autotunnel/StateChange.kt

@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.core.service.autotunnel
 
-import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
 import com.zaneschepke.wireguardautotunnel.domain.state.PingState
@@ -11,7 +11,7 @@ import org.amnezia.awg.crypto.Key
 sealed class StateChange {
     data class NetworkChange(val networkState: NetworkState) : StateChange()
 
-    data class SettingsChange(val settings: GeneralSettings, val tunnels: Tunnels) : StateChange()
+    data class SettingsChange(val settings: AppSettings, val tunnels: Tunnels) : StateChange()
 
     data class ActiveTunnelsChange(val activeTunnels: Map<TunnelConf, TunnelState>) : StateChange()
 

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/TunnelManager.kt

@@ -7,7 +7,7 @@ import com.zaneschepke.wireguardautotunnel.domain.enums.BackendMode
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
 import com.zaneschepke.wireguardautotunnel.domain.events.BackendCoreException
 import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
-import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.PingState
@@ -42,13 +42,13 @@ constructor(
     @OptIn(ExperimentalAtomicApi::class)
     private val tunnelProviderFlow: StateFlow<TunnelProvider> = run {
         val currentBackend = AtomicReference(userspaceTunnel)
-        val currentSettings = AtomicReference(GeneralSettings())
+        val currentSettings = AtomicReference(AppSettings())
         val initialEmit = AtomicBoolean(true)
 
         appDataRepository.settings.flow
             .filterNotNull()
             // ignore default state
-            .filterNot { it == GeneralSettings() }
+            .filterNot { it == AppSettings() }
             .distinctUntilChanged { old, new ->
                 old.appMode == new.appMode &&
                     old.isLanOnKillSwitchEnabled == new.isLanOnKillSwitchEnabled

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/UserspaceTunnel.kt

@@ -87,6 +87,7 @@ constructor(
                         )
                     }
                     .build()
+
             backend.setState(tunnel, Tunnel.State.UP, updatedConfig)
         } catch (e: BackendException) {
             Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/AppDatabase.kt

@@ -12,7 +12,7 @@ import com.zaneschepke.wireguardautotunnel.data.entity.TunnelConfig
 
 @Database(
     entities = [Settings::class, TunnelConfig::class, ProxySettings::class],
-    version = 22,
+    version = 21,
     autoMigrations =
         [
             AutoMigration(from = 1, to = 2),
@@ -35,7 +35,6 @@ import com.zaneschepke.wireguardautotunnel.data.entity.TunnelConfig
             AutoMigration(from = 18, to = 19, spec = PingMigration::class),
             AutoMigration(from = 19, to = 20, spec = ProxyMigration::class),
             AutoMigration(from = 20, to = 21, spec = FixProxySettingsMigration::class),
-            AutoMigration(from = 21, to = 22),
         ],
     exportSchema = true,
 )

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/DataStoreManager.kt

@@ -13,6 +13,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import timber.log.Timber
 
@@ -84,5 +85,9 @@ class DataStoreManager(
         }
     }
 
+    fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
+        context.dataStore.data.map { it[key] }.first()
+    }
+
     val preferencesFlow: Flow<Preferences?> = context.dataStore.data.flowOn(ioDispatcher)
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/DatabaseCallback.kt

@@ -2,15 +2,25 @@ package com.zaneschepke.wireguardautotunnel.data
 
 import androidx.room.RoomDatabase
 import androidx.sqlite.db.SupportSQLiteDatabase
+import com.zaneschepke.wireguardautotunnel.data.entity.ProxySettings
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
 import javax.inject.Inject
 import javax.inject.Provider
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 
 class DatabaseCallback @Inject constructor(private val databaseProvider: Provider<AppDatabase>) :
     RoomDatabase.Callback() {
 
     override fun onCreate(db: SupportSQLiteDatabase) {
         super.onCreate(db)
-        db.execSQL("INSERT INTO proxy_settings DEFAULT VALUES")
-        db.execSQL("INSERT INTO Settings DEFAULT VALUES")
+
+        // Launch coroutine to insert default entry
+        CoroutineScope(Dispatchers.IO).launch {
+            val db = databaseProvider.get()
+            db.settingDao().save(Settings())
+            db.proxySettingsDoa().save(ProxySettings())
+        }
     }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/DatabaseConverters.kt

@@ -24,16 +24,6 @@ class DatabaseConverters {
         }
     }
 
-    @TypeConverter
-    fun setToString(value: Set<String>): String {
-        return listToString(value.toList())
-    }
-
-    @TypeConverter
-    fun stringToSet(value: String): Set<String> {
-        return stringToList(value).toSet()
-    }
-
     @TypeConverter fun fromStatus(status: WifiDetectionMethod): Int = status.value
 
     @TypeConverter

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/dao/TunnelConfigDao.kt

@@ -22,8 +22,6 @@ interface TunnelConfigDao {
 
     @Delete suspend fun delete(t: TunnelConfig)
 
-    @Delete suspend fun delete(t: TunnelConfigs)
-
     @Query("SELECT COUNT('id') FROM TunnelConfig") suspend fun count(): Long
 
     @Query("SELECT * FROM TunnelConfig WHERE tunnel_networks LIKE '%' || :name || '%'")

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/entity/ProxySettings.kt

@@ -7,10 +7,10 @@ import androidx.room.PrimaryKey
 @Entity(tableName = "proxy_settings")
 data class ProxySettings(
     @PrimaryKey(autoGenerate = true) val id: Long = 0,
-    @ColumnInfo(name = "socks5_proxy_enabled", defaultValue = "0")
+    @ColumnInfo(name = "socks5_proxy_enabled", defaultValue = "false")
     val socks5ProxyEnabled: Boolean = false,
     @ColumnInfo(name = "socks5_proxy_bind_address") val socks5ProxyBindAddress: String? = null,
-    @ColumnInfo(name = "http_proxy_enable", defaultValue = "0")
+    @ColumnInfo(name = "http_proxy_enable", defaultValue = "false")
     val httpProxyEnabled: Boolean = false,
     @ColumnInfo(name = "http_proxy_bind_address") val httpProxyBindAddress: String? = null,
     @ColumnInfo(name = "proxy_username") val proxyUsername: String? = null,

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/entity/Settings.kt

@@ -10,40 +10,38 @@ import com.zaneschepke.wireguardautotunnel.data.model.WifiDetectionMethod
 @Entity
 data class Settings(
     @PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "is_tunnel_enabled", defaultValue = "0")
-    val isAutoTunnelEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_tunnel_enabled") val isAutoTunnelEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled")
     val isTunnelOnMobileDataEnabled: Boolean = false,
-    @ColumnInfo(name = "trusted_network_ssids", defaultValue = "")
-    val trustedNetworkSSIDs: Set<String> = emptySet(),
-    @ColumnInfo(name = "is_always_on_vpn_enabled", defaultValue = "0")
-    val isAlwaysOnVpnEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled", defaultValue = "0")
+    @ColumnInfo(name = "trusted_network_ssids") val trustedNetworkSSIDs: List<String> = emptyList(),
+    @ColumnInfo(name = "is_always_on_vpn_enabled") val isAlwaysOnVpnEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled")
     val isTunnelOnEthernetEnabled: Boolean = false,
-    @ColumnInfo(name = "is_shortcuts_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_shortcuts_enabled", defaultValue = "false")
     val isShortcutsEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_wifi_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_tunnel_on_wifi_enabled", defaultValue = "false")
     val isTunnelOnWifiEnabled: Boolean = false,
-    @ColumnInfo(name = "is_restore_on_boot_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_restore_on_boot_enabled", defaultValue = "false")
     val isRestoreOnBootEnabled: Boolean = false,
-    @ColumnInfo(name = "is_multi_tunnel_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_multi_tunnel_enabled", defaultValue = "false")
     val isMultiTunnelEnabled: Boolean = false,
-    @ColumnInfo(name = "is_ping_enabled", defaultValue = "0") val isPingEnabled: Boolean = false,
-    @ColumnInfo(name = "is_wildcards_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_ping_enabled", defaultValue = "false")
+    val isPingEnabled: Boolean = false,
+    @ColumnInfo(name = "is_wildcards_enabled", defaultValue = "false")
     val isWildcardsEnabled: Boolean = false,
-    @ColumnInfo(name = "is_stop_on_no_internet_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_stop_on_no_internet_enabled", defaultValue = "false")
     val isStopOnNoInternetEnabled: Boolean = false,
-    @ColumnInfo(name = "is_lan_on_kill_switch_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_lan_on_kill_switch_enabled", defaultValue = "false")
     val isLanOnKillSwitchEnabled: Boolean = false,
     @ColumnInfo(name = "debounce_delay_seconds", defaultValue = "3")
     val debounceDelaySeconds: Int = 3,
-    @ColumnInfo(name = "is_disable_kill_switch_on_trusted_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_disable_kill_switch_on_trusted_enabled", defaultValue = "false")
     val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_unsecure_enabled", defaultValue = "0")
+    @ColumnInfo(name = "is_tunnel_on_unsecure_enabled", defaultValue = "false")
     val isTunnelOnUnsecureEnabled: Boolean = false,
     @ColumnInfo(name = "wifi_detection_method", defaultValue = "0")
     val wifiDetectionMethod: WifiDetectionMethod = WifiDetectionMethod.fromValue(0),
-    @ColumnInfo(name = "is_ping_monitoring_enabled", defaultValue = "1")
+    @ColumnInfo(name = "is_ping_monitoring_enabled", defaultValue = "true")
     val isPingMonitoringEnabled: Boolean = true,
     @ColumnInfo(name = "tunnel_ping_interval_sec", defaultValue = "30")
     val tunnelPingIntervalSeconds: Int = 30,

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/entity/TunnelConfig.kt

@@ -11,7 +11,7 @@ data class TunnelConfig(
     @ColumnInfo(name = "name") val name: String,
     @ColumnInfo(name = "wg_quick") val wgQuick: String,
     @ColumnInfo(name = "tunnel_networks", defaultValue = "")
-    val tunnelNetworks: Set<String> = setOf(),
+    val tunnelNetworks: List<String> = listOf(),
     @ColumnInfo(name = "is_mobile_data_tunnel", defaultValue = "false")
     val isMobileDataTunnel: Boolean = false,
     @ColumnInfo(name = "is_primary_tunnel", defaultValue = "false")
@@ -27,7 +27,7 @@ data class TunnelConfig(
     val isIpv4Preferred: Boolean = true,
     @ColumnInfo(name = "position", defaultValue = "0") val position: Int = 0,
     @ColumnInfo(name = "auto_tunnel_apps", defaultValue = "[]")
-    val autoTunnelApps: Set<String> = setOf(),
+    val autoTunnelApps: List<String> = listOf(),
 ) {
 
     companion object {

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/mapper/SettingsMapper.kt

@@ -1,13 +1,14 @@
 package com.zaneschepke.wireguardautotunnel.data.mapper
 
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
 import com.zaneschepke.wireguardautotunnel.data.entity.Settings
 import com.zaneschepke.wireguardautotunnel.data.model.DnsProtocol
 import com.zaneschepke.wireguardautotunnel.data.model.DnsSettings
 import com.zaneschepke.wireguardautotunnel.data.model.WifiDetectionMethod
-import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 
-fun Settings.toAppSettings(): GeneralSettings {
-    return GeneralSettings(
+fun Settings.toAppSettings(): AppSettings {
+    return AppSettings(
         id = id,
         isAutoTunnelEnabled = isAutoTunnelEnabled,
         isTunnelOnMobileDataEnabled = isTunnelOnMobileDataEnabled,
@@ -25,7 +26,8 @@ fun Settings.toAppSettings(): GeneralSettings {
         debounceDelaySeconds = debounceDelaySeconds,
         isDisableKillSwitchOnTrustedEnabled = isDisableKillSwitchOnTrustedEnabled,
         isTunnelOnUnsecureEnabled = isTunnelOnUnsecureEnabled,
-        wifiDetectionMethod = WifiDetectionMethod.fromValue(wifiDetectionMethod.value),
+        wifiDetectionMethod =
+            AndroidNetworkMonitor.WifiDetectionMethod.fromValue(wifiDetectionMethod.value),
         tunnelPingIntervalSeconds = tunnelPingIntervalSeconds,
         tunnelPingAttempts = tunnelPingAttempts,
         tunnelPingTimeoutSeconds = tunnelPingTimeoutSeconds,
@@ -35,7 +37,7 @@ fun Settings.toAppSettings(): GeneralSettings {
     )
 }
 
-fun GeneralSettings.toSettings(): Settings {
+fun AppSettings.toSettings(): Settings {
     return Settings(
         id = id,
         isAutoTunnelEnabled = isAutoTunnelEnabled,
@@ -64,7 +66,7 @@ fun GeneralSettings.toSettings(): Settings {
     )
 }
 
-fun GeneralSettings.toDomain(): DnsSettings {
+fun AppSettings.toDomain(): DnsSettings {
     return DnsSettings(
         protocol =
             DnsProtocol.entries.toTypedArray().getOrElse(dnsProtocol.value) { DnsProtocol.SYSTEM },
@@ -72,6 +74,6 @@ fun GeneralSettings.toDomain(): DnsSettings {
     )
 }
 
-fun DnsSettings.toAppSettings(existing: GeneralSettings): GeneralSettings {
+fun DnsSettings.toAppSettings(existing: AppSettings): AppSettings {
     return existing.copy(dnsProtocol = protocol, dnsEndpoint = endpoint)
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/model/WifiDetectionMethod.kt

@@ -6,10 +6,6 @@ enum class WifiDetectionMethod(val value: Int) {
     ROOT(2),
     SHIZUKU(3);
 
-    fun needsLocationPermissions(): Boolean {
-        return this == LEGACY || this == DEFAULT
-    }
-
     companion object {
         fun fromValue(value: Int): WifiDetectionMethod =
             entries.find { it.value == value } ?: DEFAULT

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/repository/AppDataRoomRepository.kt

@@ -7,7 +7,7 @@ import javax.inject.Inject
 class AppDataRoomRepository
 @Inject
 constructor(
-    override val settings: GeneralSettingRepository,
+    override val settings: AppSettingRepository,
     override val tunnels: TunnelRepository,
     override val appState: AppStateRepository,
     override val proxySettings: ProxySettingsRepository,

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/repository/DataStoreAppStateRepository.kt

@@ -3,25 +3,15 @@ package com.zaneschepke.wireguardautotunnel.data.repository
 import com.zaneschepke.wireguardautotunnel.data.DataStoreManager
 import com.zaneschepke.wireguardautotunnel.data.entity.GeneralState
 import com.zaneschepke.wireguardautotunnel.data.mapper.GeneralStateMapper
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.model.AppState
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
 import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.plus
 import timber.log.Timber
 
-class DataStoreAppStateRepository(
-    private val dataStoreManager: DataStoreManager,
-    @ApplicationScope private val applicationScope: CoroutineScope,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-) : AppStateRepository {
+class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager) :
+    AppStateRepository {
     override suspend fun isLocationDisclosureShown(): Boolean {
         return dataStoreManager.getFromStore(DataStoreManager.locationDisclosureShown)
             ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
@@ -177,9 +167,4 @@ class DataStoreAppStateRepository(
                 } ?: GeneralState()
             }
             .map(GeneralStateMapper::toAppState)
-            .stateIn(
-                scope = applicationScope + ioDispatcher,
-                started = SharingStarted.Eagerly,
-                initialValue = AppState(),
-            )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/repository/InstalledAndroidPackageRepository.kt

@@ -1,92 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.repository
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.pm.PackageManager
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.model.InstalledPackage
-import com.zaneschepke.wireguardautotunnel.domain.repository.InstalledPackageRepository
-import com.zaneschepke.wireguardautotunnel.util.extensions.getAllInternetCapablePackages
-import com.zaneschepke.wireguardautotunnel.util.extensions.getFriendlyAppName
-import javax.inject.Singleton
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-
-@Singleton
-class InstalledAndroidPackageRepository(
-    private val context: Context,
-    @ApplicationScope val applicationScope: CoroutineScope,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-) : InstalledPackageRepository {
-
-    private var cachedPackages: List<InstalledPackage>? = null
-
-    init {
-        val receiver =
-            object : BroadcastReceiver() {
-                override fun onReceive(context: Context, intent: Intent) {
-                    when (intent.action) {
-                        Intent.ACTION_PACKAGE_ADDED,
-                        Intent.ACTION_PACKAGE_REMOVED,
-                        Intent.ACTION_PACKAGE_CHANGED -> {
-                            // don't update if we have nothing cached
-                            if (cachedPackages == null) return
-                            Timber.d("Updating installed packages cache")
-                            applicationScope.launch { refreshInstalledPackages() }
-                        }
-                    }
-                }
-            }
-        val filter =
-            IntentFilter().apply {
-                addAction(Intent.ACTION_PACKAGE_ADDED)
-                addAction(Intent.ACTION_PACKAGE_REMOVED)
-                addAction(Intent.ACTION_PACKAGE_CHANGED)
-                addDataScheme("package")
-            }
-        context.registerReceiver(receiver, filter)
-    }
-
-    override suspend fun getInstalledPackages(): List<InstalledPackage> =
-        withContext(ioDispatcher) {
-            cachedPackages?.let {
-                return@withContext it
-            }
-            refreshInstalledPackages()
-        }
-
-    override suspend fun refreshInstalledPackages(): List<InstalledPackage> =
-        withContext(ioDispatcher) {
-            val packages = context.getAllInternetCapablePackages()
-
-            val installedPackages =
-                packages.mapNotNull { packageInfo ->
-                    try {
-                        val appInfo =
-                            context.packageManager.getApplicationInfo(packageInfo.packageName, 0)
-                        InstalledPackage(
-                            name =
-                                context.packageManager.getFriendlyAppName(
-                                    packageInfo.packageName,
-                                    appInfo,
-                                ),
-                            packageName = packageInfo.packageName,
-                            uId = appInfo.uid,
-                        )
-                    } catch (e: PackageManager.NameNotFoundException) {
-                        Timber.e(e)
-                        null
-                    }
-                }
-
-            cachedPackages = installedPackages
-
-            installedPackages
-        }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/repository/RoomSettingsRepository.kt

@@ -5,8 +5,8 @@ import com.zaneschepke.wireguardautotunnel.data.entity.Settings
 import com.zaneschepke.wireguardautotunnel.data.mapper.toAppSettings
 import com.zaneschepke.wireguardautotunnel.data.mapper.toSettings
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
-import com.zaneschepke.wireguardautotunnel.domain.repository.GeneralSettingRepository
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.map
@@ -15,16 +15,16 @@ import kotlinx.coroutines.withContext
 class RoomSettingsRepository(
     private val settingsDoa: SettingsDao,
     @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-) : GeneralSettingRepository {
+) : AppSettingRepository {
 
-    override suspend fun save(generalSettings: GeneralSettings) {
-        withContext(ioDispatcher) { settingsDoa.save(generalSettings.toSettings()) }
+    override suspend fun save(appSettings: AppSettings) {
+        withContext(ioDispatcher) { settingsDoa.save(appSettings.toSettings()) }
     }
 
     override val flow =
         settingsDoa.getSettingsFlow().flowOn(ioDispatcher).map { it.toAppSettings() }
 
-    override suspend fun get(): GeneralSettings {
+    override suspend fun get(): AppSettings {
         return withContext(ioDispatcher) {
             (settingsDoa.getAll().firstOrNull() ?: Settings()).toAppSettings()
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/repository/RoomTunnelRepository.kt

@@ -105,10 +105,4 @@ class RoomTunnelRepository(
             tunnelConfigDao.findByPrimary().map(TunnelConfigMapper::toTunnelConf)
         }
     }
-
-    override suspend fun delete(tunnels: List<TunnelConf>) {
-        withContext(ioDispatcher) {
-            tunnelConfigDao.delete(tunnels.map { TunnelConfigMapper.toTunnelConfig(it) })
-        }
-    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/di/AppModule.kt

@@ -23,7 +23,6 @@ import kotlinx.coroutines.SupervisorJob
 @Module
 @InstallIn(SingletonComponent::class)
 class AppModule {
-
     @Singleton
     @ApplicationScope
     @Provides

app/src/main/java/com/zaneschepke/wireguardautotunnel/di/RepositoryModule.kt

@@ -22,28 +22,10 @@ import dagger.hilt.components.SingletonComponent
 import io.ktor.client.*
 import javax.inject.Singleton
 import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
 
 @Module
 @InstallIn(SingletonComponent::class)
 class RepositoryModule {
-
-    @Provides
-    @Singleton
-    fun provideGlobalEffectRepository(): GlobalEffectRepository {
-        return GlobalEffectRepository()
-    }
-
-    @Provides
-    @Singleton
-    fun provideInstalledPackageRepository(
-        @ApplicationContext context: Context,
-        @ApplicationScope applicationScope: CoroutineScope,
-        @IoDispatcher ioDispatcher: CoroutineDispatcher,
-    ): InstalledPackageRepository {
-        return InstalledAndroidPackageRepository(context, applicationScope, ioDispatcher)
-    }
-
     @Provides
     @Singleton
     fun provideDatabase(
@@ -92,7 +74,7 @@ class RepositoryModule {
     fun provideSettingsRepository(
         settingsDao: SettingsDao,
         @IoDispatcher ioDispatcher: CoroutineDispatcher,
-    ): GeneralSettingRepository {
+    ): AppSettingRepository {
         return RoomSettingsRepository(settingsDao, ioDispatcher)
     }
 
@@ -116,18 +98,14 @@ class RepositoryModule {
 
     @Provides
     @Singleton
-    fun provideGeneralStateRepository(
-        dataStoreManager: DataStoreManager,
-        @ApplicationScope applicationScope: CoroutineScope,
-        @IoDispatcher ioDispatcher: CoroutineDispatcher,
-    ): AppStateRepository {
-        return DataStoreAppStateRepository(dataStoreManager, applicationScope, ioDispatcher)
+    fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
+        return DataStoreAppStateRepository(dataStoreManager)
     }
 
     @Provides
     @Singleton
     fun provideAppDataRepository(
-        settingsRepository: GeneralSettingRepository,
+        settingsRepository: AppSettingRepository,
         tunnelRepository: TunnelRepository,
         appStateRepository: AppStateRepository,
         proxySettingsRepository: ProxySettingsRepository,

app/src/main/java/com/zaneschepke/wireguardautotunnel/di/TunnelModule.kt

@@ -10,8 +10,7 @@ import com.zaneschepke.networkmonitor.NetworkMonitor
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.*
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.GeneralSettingRepository
-import com.zaneschepke.wireguardautotunnel.util.extensions.to
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
 import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
 import dagger.Module
 import dagger.Provides
@@ -141,7 +140,7 @@ class TunnelModule {
     @Singleton
     fun provideNetworkMonitor(
         @ApplicationContext context: Context,
-        settingsRepository: GeneralSettingRepository,
+        settingsRepository: AppSettingRepository,
         @ApplicationScope applicationScope: CoroutineScope,
         @AppShell appShell: RootShell,
     ): NetworkMonitor {
@@ -152,7 +151,7 @@ class TunnelModule {
                     get() =
                         settingsRepository.flow
                             .distinctUntilChangedBy { it.wifiDetectionMethod }
-                            .map { it.wifiDetectionMethod.to() }
+                            .map { it.wifiDetectionMethod }
 
                 override val rootShell: RootShell
                     get() = appShell

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/model/AppSettings.kt

@@ -1,14 +1,14 @@
 package com.zaneschepke.wireguardautotunnel.domain.model
 
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
 import com.zaneschepke.wireguardautotunnel.data.model.AppMode
 import com.zaneschepke.wireguardautotunnel.data.model.DnsProtocol
-import com.zaneschepke.wireguardautotunnel.data.model.WifiDetectionMethod
 
-data class GeneralSettings(
+data class AppSettings(
     val id: Int = 0,
     val isAutoTunnelEnabled: Boolean = false,
     val isTunnelOnMobileDataEnabled: Boolean = false,
-    val trustedNetworkSSIDs: Set<String> = emptySet(),
+    val trustedNetworkSSIDs: List<String> = emptyList(),
     val isAlwaysOnVpnEnabled: Boolean = false,
     val isTunnelOnEthernetEnabled: Boolean = false,
     val isShortcutsEnabled: Boolean = false,
@@ -24,9 +24,10 @@ data class GeneralSettings(
     val debounceDelaySeconds: Int = 3,
     val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
     val isTunnelOnUnsecureEnabled: Boolean = false,
-    val wifiDetectionMethod: WifiDetectionMethod = WifiDetectionMethod.DEFAULT,
-    val tunnelPingIntervalSeconds: Int = PING_INTERVAL_DEFAULT,
-    val tunnelPingAttempts: Int = PING_ATTEMPTS_DEFAULT,
+    val wifiDetectionMethod: AndroidNetworkMonitor.WifiDetectionMethod =
+        AndroidNetworkMonitor.WifiDetectionMethod.DEFAULT,
+    val tunnelPingIntervalSeconds: Int = 30,
+    val tunnelPingAttempts: Int = 3,
     val tunnelPingTimeoutSeconds: Int? = null,
     val appMode: AppMode = AppMode.VPN,
     val dnsProtocol: DnsProtocol = DnsProtocol.SYSTEM,
@@ -43,9 +44,4 @@ data class GeneralSettings(
         """
             .trimIndent()
     }
-
-    companion object {
-        const val PING_INTERVAL_DEFAULT = 30
-        const val PING_ATTEMPTS_DEFAULT = 3
-    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/model/AppState.kt

@@ -3,14 +3,14 @@ package com.zaneschepke.wireguardautotunnel.domain.model
 import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
 
 data class AppState(
-    val isLocationDisclosureShown: Boolean = false,
-    val isBatteryOptimizationDisableShown: Boolean = false,
-    val isPinLockEnabled: Boolean = false,
-    val expandedTunnelIds: List<Int> = emptyList(),
-    val isLocalLogsEnabled: Boolean = false,
-    val isRemoteControlEnabled: Boolean = false,
-    val showDetailedPingStats: Boolean = false,
-    val remoteKey: String? = null,
-    val locale: String? = null,
-    val theme: Theme = Theme.AUTOMATIC,
+    val isLocationDisclosureShown: Boolean,
+    val isBatteryOptimizationDisableShown: Boolean,
+    val isPinLockEnabled: Boolean,
+    val expandedTunnelIds: List<Int>,
+    val isLocalLogsEnabled: Boolean,
+    val isRemoteControlEnabled: Boolean,
+    val showDetailedPingStats: Boolean,
+    val remoteKey: String?,
+    val locale: String?,
+    val theme: Theme,
 )

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/model/InstalledPackage.kt

@@ -1,3 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.model
-
-data class InstalledPackage(val name: String, val packageName: String, val uId: Int)

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/model/TunnelConf.kt

@@ -1,19 +1,16 @@
 package com.zaneschepke.wireguardautotunnel.domain.model
 
-import android.os.Parcelable
 import com.wireguard.android.backend.Tunnel
 import com.wireguard.config.Config
 import com.zaneschepke.wireguardautotunnel.util.extensions.*
 import java.io.InputStream
 import java.nio.charset.StandardCharsets
-import kotlinx.parcelize.Parcelize
 
-@Parcelize
 data class TunnelConf(
     val id: Int = 0,
     val tunName: String,
     val wgQuick: String,
-    val tunnelNetworks: Set<String> = emptySet(),
+    val tunnelNetworks: List<String> = emptyList(),
     val isMobileDataTunnel: Boolean = false,
     val isPrimaryTunnel: Boolean = false,
     val amQuick: String,
@@ -24,7 +21,7 @@ data class TunnelConf(
     val isIpv4Preferred: Boolean = true,
     val position: Int = 0,
     @Transient private var stateChangeCallback: ((Any) -> Unit)? = null,
-) : Tunnel, org.amnezia.awg.backend.Tunnel, Parcelable {
+) : Tunnel, org.amnezia.awg.backend.Tunnel {
 
     val isNameKernelCompatible: Boolean = (name.length <= 15)
 
@@ -64,7 +61,7 @@ data class TunnelConf(
         id: Int = this.id,
         tunName: String = this.tunName,
         wgQuick: String = this.wgQuick,
-        tunnelNetworks: Set<String> = this.tunnelNetworks,
+        tunnelNetworks: List<String> = this.tunnelNetworks,
         isMobileDataTunnel: Boolean = this.isMobileDataTunnel,
         isPrimaryTunnel: Boolean = this.isPrimaryTunnel,
         amQuick: String = this.amQuick,
@@ -143,17 +140,7 @@ data class TunnelConf(
             }
         }
 
-        fun tunnelConfFromQuick(amQuick: String, name: String? = null): TunnelConf {
-            val config = configFromAmQuick(amQuick)
-            val wgQuick = config.toWgQuickString()
-            return TunnelConf(
-                tunName = name ?: config.defaultName(),
-                wgQuick = wgQuick,
-                amQuick = amQuick,
-            )
-        }
-
-        private fun tunnelConfFromAmConfig(
+        fun tunnelConfigFromAmConfig(
             config: org.amnezia.awg.config.Config,
             name: String? = null,
         ): TunnelConf {

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/repository/AppDataRepository.kt

@@ -7,7 +7,7 @@ interface AppDataRepository {
 
     suspend fun getStartTunnelConfig(): TunnelConf?
 
-    val settings: GeneralSettingRepository
+    val settings: AppSettingRepository
     val tunnels: TunnelRepository
     val appState: AppStateRepository
 

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/repository/AppSettingRepository.kt

@@ -0,0 +1,12 @@
+package com.zaneschepke.wireguardautotunnel.domain.repository
+
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import kotlinx.coroutines.flow.Flow
+
+interface AppSettingRepository {
+    suspend fun save(appSettings: AppSettings)
+
+    val flow: Flow<AppSettings>
+
+    suspend fun get(): AppSettings
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/repository/EffectRepository.kt

@@ -1,18 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.repository
-
-import com.zaneschepke.wireguardautotunnel.domain.sideeffect.GlobalSideEffect
-import javax.inject.Singleton
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
-
-@Singleton
-class GlobalEffectRepository {
-
-    private val _globalEffectFlow =
-        MutableSharedFlow<GlobalSideEffect>(replay = 0, extraBufferCapacity = 1)
-    val flow = _globalEffectFlow.asSharedFlow()
-
-    suspend fun post(effect: GlobalSideEffect) {
-        _globalEffectFlow.emit(effect)
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/repository/GeneralSettingRepository.kt

@@ -1,12 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.repository
-
-import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
-import kotlinx.coroutines.flow.Flow
-
-interface GeneralSettingRepository {
-    suspend fun save(generalSettings: GeneralSettings)
-
-    val flow: Flow<GeneralSettings>
-
-    suspend fun get(): GeneralSettings
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/repository/InstalledPackageRepository.kt

@@ -1,12 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.repository
-
-import com.zaneschepke.wireguardautotunnel.domain.model.InstalledPackage
-
-interface InstalledPackageRepository {
-
-    // gets packages from cache or queries and updates cache if empty
-    suspend fun getInstalledPackages(): List<InstalledPackage>
-
-    // updates the cache and returns the results
-    suspend fun refreshInstalledPackages(): List<InstalledPackage>
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/repository/TunnelRepository.kt

@@ -34,6 +34,4 @@ interface TunnelRepository {
     suspend fun findByMobileDataTunnel(): Tunnels
 
     suspend fun findPrimary(): Tunnels
-
-    suspend fun delete(tunnels: List<TunnelConf>)
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/sideeffect/GlobalSideEffect.kt

@@ -1,27 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.sideeffect
-
-import com.zaneschepke.wireguardautotunnel.data.model.AppMode
-import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
-import com.zaneschepke.wireguardautotunnel.util.StringValue
-import java.io.File
-
-sealed class GlobalSideEffect {
-    data object RequestBatteryOptimizationDisabled : GlobalSideEffect()
-
-    data class Snackbar(val message: StringValue) : GlobalSideEffect()
-
-    data class Toast(val message: StringValue) : GlobalSideEffect()
-
-    data object PopBackStack : GlobalSideEffect()
-
-    data class ShareFile(val file: File) : GlobalSideEffect()
-
-    data class LaunchUrl(val url: String) : GlobalSideEffect()
-
-    data object ConfigChanged : GlobalSideEffect()
-
-    data class RequestVpnPermission(val requestingMode: AppMode, val config: TunnelConf?) :
-        GlobalSideEffect()
-
-    data class InstallApk(val apk: File) : GlobalSideEffect()
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/state/AutoTunnelState.kt

@@ -3,14 +3,14 @@ package com.zaneschepke.wireguardautotunnel.domain.state
 import com.zaneschepke.wireguardautotunnel.core.service.autotunnel.StateChange
 import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent
 import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent.*
-import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.util.extensions.isMatchingToWildcardList
 
 data class AutoTunnelState(
     val activeTunnels: Map<TunnelConf, TunnelState> = emptyMap(),
     val networkState: NetworkState = NetworkState(),
-    val settings: GeneralSettings = GeneralSettings(),
+    val settings: AppSettings = AppSettings(),
     val tunnels: List<TunnelConf> = emptyList(),
 ) {
 
@@ -137,7 +137,7 @@ data class AutoTunnelState(
 
     private fun hasTrustedWifiName(
         wifiName: String,
-        wifiNames: Set<String> = settings.trustedNetworkSSIDs,
+        wifiNames: List<String> = settings.trustedNetworkSSIDs,
     ): Boolean {
         return if (settings.isWildcardsEnabled) {
             wifiNames.isMatchingToWildcardList(wifiName)

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/Locals.kt

@@ -1,13 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import androidx.compose.runtime.compositionLocalOf
-import androidx.compose.runtime.staticCompositionLocalOf
-import androidx.navigation.NavHostController
-import com.zaneschepke.wireguardautotunnel.viewmodel.SharedAppViewModel
-
-val LocalNavController =
-    compositionLocalOf<NavHostController> { error("NavController was not provided") }
-
-val LocalIsAndroidTV = staticCompositionLocalOf { false }
-
-val LocalSharedVm = staticCompositionLocalOf<SharedAppViewModel> { error("No SharedVm") }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/Route.kt

@@ -1,58 +1,54 @@
-package com.zaneschepke.wireguardautotunnel.ui.navigation
+package com.zaneschepke.wireguardautotunnel.ui
 
 import kotlinx.serialization.Serializable
 
-@Serializable
 sealed class Route {
-    @Serializable data object TunnelsGraph : Route()
-
-    @Serializable data object AutoTunnelGraph : Route()
-
-    @Serializable data object SettingsGraph : Route()
-
-    @Serializable data object SupportGraph : Route()
-
     @Serializable data object Support : Route()
 
+    @Serializable data object Settings : Route()
+
+    @Serializable data object AutoTunnel : Route()
+
+    @Serializable data object AutoTunnelAdvanced : Route()
+
+    @Serializable data object WifiDetectionMethod : Route()
+
+    @Serializable data object LocationDisclosure : Route()
+
+    @Serializable data object Appearance : Route()
+
+    @Serializable data object Display : Route()
+
+    @Serializable data object Language : Route()
+
+    @Serializable data object Main : Route()
+
+    @Serializable data class TunnelOptions(val id: Int) : Route()
+
     @Serializable data object Lock : Route()
 
     @Serializable data object License : Route()
 
-    @Serializable data object Logs : Route()
+    @Serializable data class Config(val id: Int) : Route()
 
-    @Serializable data object Appearance : Route()
-
-    @Serializable data object Language : Route()
-
-    @Serializable data object Display : Route()
-
-    @Serializable data object Tunnels : Route()
-
-    @Serializable data class TunnelOptions(val id: Int) : Route()
-
-    @Serializable data class Config(val id: Int?) : Route()
-
-    @Serializable data class SplitTunnel(val id: Int) : Route()
+    @Serializable
+    data class SplitTunnel(val id: Int) : Route() {
+        companion object {
+            const val KEY_ID = "id"
+        }
+    }
 
     @Serializable data class TunnelAutoTunnel(val id: Int) : Route()
 
-    @Serializable data object Sort : Route()
+    @Serializable data object Logs : Route()
 
-    @Serializable data object Settings : Route()
+    @Serializable data object Sort : Route()
 
     @Serializable data object TunnelMonitoring : Route()
 
     @Serializable data object SystemFeatures : Route()
 
-    @Serializable data object Dns : Route()
-
     @Serializable data object ProxySettings : Route()
 
-    @Serializable data object AutoTunnel : Route()
-
-    @Serializable data object AdvancedAutoTunnel : Route()
-
-    @Serializable data object WifiDetectionMethod : Route()
-
-    @Serializable data object LocationDisclosure : Route()
+    @Serializable data object Dns : Route()
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/ExpandingRowListItem.kt

@@ -22,7 +22,7 @@ fun ExpandingRowListItem(
     text: String,
     trailing: @Composable () -> Unit,
     isSelected: Boolean,
-    expanded: (@Composable () -> Unit),
+    expanded: @Composable () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     Box(

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/button/ActionIconButton.kt

@@ -1,21 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common.button
-
-import androidx.compose.foundation.layout.size
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.res.stringResource
-import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
-
-@Composable
-fun ActionIconButton(icon: ImageVector, labelRes: Int, onClick: () -> Unit) {
-    IconButton(onClick = onClick) {
-        Icon(
-            icon,
-            contentDescription = stringResource(labelRes),
-            modifier = Modifier.size(iconSize),
-        )
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/button/IconSurfaceButton.kt

@@ -12,8 +12,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItemLabel
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionLabelType
 
 @Composable
 fun IconSurfaceButton(
@@ -57,7 +55,7 @@ fun IconSurfaceButton(
                     ) {
                         leading?.invoke()
                         Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
-                            SelectionItemLabel(title, SelectionLabelType.TITLE)
+                            Text(title, style = MaterialTheme.typography.titleMedium)
                             description?.let {
                                 Text(
                                     description,

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/button/SelectionItemButton.kt

@@ -4,28 +4,24 @@ import androidx.compose.foundation.clickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.ripple
+import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItemLabel
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionLabelType
 
 @Composable
 fun SelectionItemButton(
-    buttonText: String,
-    description: String? = null,
-    onClick: () -> Unit,
-    modifier: Modifier = Modifier,
     leading: (@Composable () -> Unit)? = null,
+    buttonText: String,
     trailing: (@Composable () -> Unit)? = null,
+    onClick: () -> Unit,
     ripple: Boolean = true,
+    modifier: Modifier = Modifier,
 ) {
     Card(
         modifier =
@@ -36,38 +32,24 @@ fun SelectionItemButton(
                     interactionSource = remember { MutableInteractionSource() },
                     onClick = { onClick() },
                 )
-                .height(IntrinsicSize.Min)
-                .padding(horizontal = 12.dp)
-                .padding(end = 12.dp),
+                .height(56.dp),
         colors = CardDefaults.cardColors(containerColor = Color.Transparent),
     ) {
         Row(
             verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.SpaceBetween,
             modifier = Modifier.fillMaxSize().padding(horizontal = 12.dp),
         ) {
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.spacedBy(24.dp),
-            ) {
+            Row {
                 leading?.let { it() }
-                Column(
-                    horizontalAlignment = Alignment.Start,
-                    modifier = Modifier.weight(1f).padding(end = 12.dp),
-                    verticalArrangement = Arrangement.Center,
-                ) {
-                    SelectionItemLabel(
-                        buttonText,
-                        SelectionLabelType.TITLE,
-                        modifier = Modifier.weight(1f).padding(end = 24.dp),
-                    )
-                    description?.let {
-                        SelectionItemLabel(
-                            it,
-                            SelectionLabelType.DESCRIPTION,
-                            modifier = Modifier.weight(1f).padding(end = 24.dp),
-                        )
-                    }
-                }
+                Text(
+                    buttonText,
+                    style = MaterialTheme.typography.labelMedium,
+                    color = MaterialTheme.colorScheme.onSurface,
+                    modifier = Modifier.fillMaxWidth(3 / 4f),
+                    maxLines = 2,
+                    overflow = TextOverflow.Ellipsis,
+                )
             }
             trailing?.let { it() }
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/button/surface/SelectionItemLabel.kt

@@ -22,7 +22,6 @@ fun SelectionItemLabel(text: String, labelType: SelectionLabelType, modifier: Mo
 }
 
 enum class SelectionLabelType {
-
     DESCRIPTION,
     TITLE,
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/functions/Functions.kt

@@ -9,8 +9,8 @@ import androidx.activity.compose.ManagedActivityResultLauncher
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.runtime.Composable
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
-import com.zaneschepke.wireguardautotunnel.util.FileUtils
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import timber.log.Timber
 
 @Composable
@@ -26,9 +26,9 @@ fun rememberFileImportLauncherForResult(
                     super.createIntent(context, input).apply {
                         type =
                             if (isTv) {
-                                FileUtils.ALLOWED_TV_FILE_TYPES
+                                Constants.ALLOWED_TV_FILE_TYPES
                             } else {
-                                FileUtils.ALL_FILE_TYPES
+                                Constants.ALL_FILE_TYPES
                             }
                     }
 
@@ -51,8 +51,8 @@ fun rememberFileImportLauncherForResult(
                 if (
                     activitiesToResolveIntent.all {
                         val name = it.activityInfo.packageName
-                        name.startsWith(FileUtils.GOOGLE_TV_EXPLORER_STUB) ||
-                            name.startsWith(FileUtils.ANDROID_TV_EXPLORER_STUB)
+                        name.startsWith(Constants.GOOGLE_TV_EXPLORER_STUB) ||
+                            name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
                     }
                 ) {
                     onNoFileExplorer()
@@ -68,7 +68,7 @@ fun rememberFileImportLauncherForResult(
 
 @Composable
 fun rememberFileExportLauncherForResult(
-    mimeType: String = FileUtils.ZIP_FILE_MIME_TYPE,
+    mimeType: String = Constants.ZIP_FILE_MIME_TYPE,
     onResult: (Uri?) -> Unit,
 ): ManagedActivityResultLauncher<String, Uri?> {
     val isTv = LocalIsAndroidTV.current
@@ -82,7 +82,7 @@ fun rememberFileExportLauncherForResult(
                             addCategory(Intent.CATEGORY_OPENABLE)
                             type =
                                 if (isTv) {
-                                    FileUtils.ALLOWED_TV_FILE_TYPES
+                                    Constants.ALLOWED_TV_FILE_TYPES
                                 } else {
                                     mimeType
                                 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/snackbar/CustomSnackbar.kt

@@ -16,7 +16,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
 
 @Composable
 fun CustomSnackBar(

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/navigation/BottomNavItem.kt

@@ -1,11 +1,12 @@
 package com.zaneschepke.wireguardautotunnel.ui.navigation
 
 import androidx.compose.ui.graphics.vector.ImageVector
+import com.zaneschepke.wireguardautotunnel.ui.Route
 
 data class BottomNavItem(
     val name: String,
+    val route: Route,
     val icon: ImageVector,
     val onClick: () -> Unit,
     val active: Boolean = false,
-    val route: Route,
 )

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/navigation/Extensions.kt

@@ -0,0 +1,20 @@
+package com.zaneschepke.wireguardautotunnel.ui.navigation
+
+import android.annotation.SuppressLint
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavDestination.Companion.hasRoute
+import androidx.navigation.NavDestination.Companion.hierarchy
+import androidx.navigation.NavHostController
+import com.zaneschepke.wireguardautotunnel.ui.Route
+import kotlin.reflect.KClass
+
+@SuppressLint("RestrictedApi")
+fun <T : Route> NavBackStackEntry?.isCurrentRoute(cls: KClass<T>): Boolean {
+    return this?.destination?.hierarchy?.any { it.hasRoute(route = cls) } == true
+}
+
+val LocalNavController =
+    compositionLocalOf<NavHostController> { error("NavController was not provided") }
+val LocalIsAndroidTV = staticCompositionLocalOf { false }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/navigation/components/BottomNavbar.kt

@@ -1,153 +1,107 @@
 package com.zaneschepke.wireguardautotunnel.ui.navigation.components
 
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
 import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Bolt
 import androidx.compose.material.icons.rounded.Home
 import androidx.compose.material.icons.rounded.QuestionMark
 import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material3.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import androidx.navigation.NavGraph.Companion.findStartDestination
-import androidx.navigation.NavHostController
 import androidx.navigation.compose.currentBackStackEntryAsState
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.navigation.BottomNavItem
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
+import com.zaneschepke.wireguardautotunnel.ui.navigation.isCurrentRoute
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.ui.theme.SilverTree
-import com.zaneschepke.wireguardautotunnel.util.extensions.debounce
-
-@Composable
-fun NavHostController.getCurrentGraph(): State<Route?> {
-    val navBackStackEntry by currentBackStackEntryAsState()
-
-    return remember(navBackStackEntry) {
-        derivedStateOf {
-            val parentRouteString = navBackStackEntry?.destination?.parent?.route
-            when (parentRouteString) {
-                Route.TunnelsGraph::class.qualifiedName -> Route.TunnelsGraph
-                Route.AutoTunnelGraph::class.qualifiedName -> Route.AutoTunnelGraph
-                Route.SettingsGraph::class.qualifiedName -> Route.SettingsGraph
-                Route.SupportGraph::class.qualifiedName -> Route.SupportGraph
-                else -> null
-            }
-        }
-    }
-}
+import com.zaneschepke.wireguardautotunnel.util.extensions.goFromRoot
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
-fun BottomNavbar(
-    isAutoTunnelActive: Boolean,
-    navbarState: NavbarState,
-    navController: NavHostController,
-) {
-
-    val currentGraph by navController.getCurrentGraph()
-    val coroutineScope = rememberCoroutineScope()
-
-    val navigateToDebounced =
-        remember<(Route) -> Unit> {
-            debounce(scope = coroutineScope, 150L) { route ->
-                navController.navigate(route) {
-                    popUpTo(navController.graph.findStartDestination().id) { saveState = true }
-                    launchSingleTop = true
-                    restoreState = true
-                }
-            }
-        }
+fun BottomNavbar(appUiState: AppUiState) {
+    val navController = LocalNavController.current
+    val navBackStackEntry by navController.currentBackStackEntryAsState()
 
     val items =
         listOf(
             BottomNavItem(
                 name = stringResource(R.string.tunnels),
+                route = Route.Main,
                 icon = Icons.Rounded.Home,
-                onClick = { navigateToDebounced(Route.TunnelsGraph) },
-                route = Route.TunnelsGraph,
+                onClick = { navController.goFromRoot(Route.Main) },
             ),
             BottomNavItem(
                 name = stringResource(R.string.auto_tunnel),
+                route = Route.AutoTunnel,
                 icon = Icons.Rounded.Bolt,
-                onClick = { navigateToDebounced(Route.AutoTunnelGraph) },
-                route = Route.AutoTunnelGraph,
-                active = isAutoTunnelActive,
+                onClick = {
+                    val route =
+                        if (appUiState.appState.isLocationDisclosureShown) {
+                            Route.AutoTunnel
+                        } else Route.LocationDisclosure
+                    navController.goFromRoot(route)
+                },
+                active = appUiState.isAutoTunnelActive,
             ),
             BottomNavItem(
                 name = stringResource(R.string.settings),
+                route = Route.Settings,
                 icon = Icons.Rounded.Settings,
-                onClick = { navigateToDebounced(Route.SettingsGraph) },
-                route = Route.SettingsGraph,
+                onClick = { navController.goFromRoot(Route.Settings) },
             ),
             BottomNavItem(
                 name = stringResource(R.string.support),
+                route = Route.Support,
                 icon = Icons.Rounded.QuestionMark,
-                onClick = { navigateToDebounced(Route.SupportGraph) },
-                route = Route.SupportGraph,
+                onClick = { navController.goFromRoot(Route.Support) },
             ),
         )
 
-    if (!navbarState.removeBottom) {
-        NavigationBar(containerColor = MaterialTheme.colorScheme.surface) {
-            AnimatedVisibility(
-                visible = navbarState.showBottomItems,
-                enter = slideInVertically(initialOffsetY = { it }),
-                exit = slideOutVertically(targetOffsetY = { it }),
-            ) {
-                Row(
-                    modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.spacedBy(0.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                ) {
-                    items.forEach { item ->
-                        val interactionSource = remember { MutableInteractionSource() }
-                        NavigationBarItem(
-                            icon = {
-                                if (item.active) {
-                                    BadgedBox(
-                                        badge = {
-                                            Badge(
-                                                modifier =
-                                                    Modifier.offset(x = 8.dp, y = (-8).dp)
-                                                        .size(6.dp),
-                                                containerColor = SilverTree,
-                                            )
-                                        }
-                                    ) {
-                                        Icon(
-                                            imageVector = item.icon,
-                                            contentDescription = item.name,
-                                        )
-                                    }
-                                } else {
-                                    Icon(imageVector = item.icon, contentDescription = item.name)
-                                }
-                            },
-                            onClick = item.onClick,
-                            selected = currentGraph == item.route,
-                            enabled = true,
-                            label = null,
-                            alwaysShowLabel = false,
-                            colors =
-                                NavigationBarItemDefaults.colors(
-                                    selectedIconColor = MaterialTheme.colorScheme.primary,
-                                    unselectedIconColor = MaterialTheme.colorScheme.onBackground,
-                                    indicatorColor = Color.Transparent,
-                                ),
-                            interactionSource = interactionSource,
-                        )
+    NavigationBar(containerColor = MaterialTheme.colorScheme.surface) {
+        items.forEach { item ->
+            val isSelected = navBackStackEntry.isCurrentRoute(item.route::class)
+            val interactionSource = remember { MutableInteractionSource() }
+
+            NavigationBarItem(
+                icon = {
+                    if (item.active) {
+                        BadgedBox(
+                            badge = {
+                                Badge(
+                                    modifier = Modifier.offset(x = 8.dp, y = (-8).dp).size(6.dp),
+                                    containerColor = SilverTree,
+                                )
+                            }
+                        ) {
+                            Icon(imageVector = item.icon, contentDescription = item.name)
+                        }
+                    } else {
+                        Icon(imageVector = item.icon, contentDescription = item.name)
                     }
-                }
-            }
+                },
+                onClick = item.onClick,
+                selected = isSelected,
+                enabled = true,
+                label = null,
+                alwaysShowLabel = false,
+                colors =
+                    NavigationBarItemDefaults.colors(
+                        selectedIconColor = MaterialTheme.colorScheme.primary,
+                        unselectedIconColor = MaterialTheme.colorScheme.onBackground,
+                        indicatorColor = Color.Transparent,
+                    ),
+                interactionSource = interactionSource,
+            )
         }
     }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/navigation/components/DynamicTopAppBar.kt

@@ -1,5 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.navigation.components
 
+import androidx.compose.animation.*
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -9,20 +10,32 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.state.NavBarState
 import com.zaneschepke.wireguardautotunnel.ui.theme.LockedDownBannerHeight
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
-fun DynamicTopAppBar(navBarState: NavbarState, modifier: Modifier = Modifier) {
+fun DynamicTopAppBar(navBarState: NavBarState, modifier: Modifier = Modifier) {
     TopAppBar(
         modifier = modifier.padding(top = LockedDownBannerHeight),
         colors = TopAppBarDefaults.topAppBarColors().copy(Color.Transparent),
         title = {
-            Box(modifier = Modifier.padding(start = 10.dp)) { navBarState.topTitle?.invoke() }
+            AnimatedVisibility(
+                visible = navBarState.showTop,
+                enter = slideInVertically() + fadeIn(),
+                exit = slideOutVertically() + fadeOut(),
+            ) {
+                Box(modifier = Modifier.padding(start = 10.dp)) { navBarState.topTitle?.invoke() }
+            }
         },
         actions = {
-            Box(modifier = Modifier.padding(end = 10.dp)) { navBarState.topTrailing?.invoke() }
+            AnimatedVisibility(
+                visible = navBarState.showTop,
+                enter = slideInVertically() + fadeIn(),
+                exit = slideOutVertically() + fadeOut(),
+            ) {
+                Box(modifier = Modifier.padding(end = 10.dp)) { navBarState.topTrailing?.invoke() }
+            }
         },
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/navigation/components/currentNavBackStackEntryAsNavBarState.kt

@@ -0,0 +1,335 @@
+package com.zaneschepke.wireguardautotunnel.ui.navigation.components
+
+import android.os.Build
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.rounded.Sort
+import androidx.compose.material.icons.rounded.*
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavController
+import androidx.navigation.toRoute
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.isCurrentRoute
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
+import com.zaneschepke.wireguardautotunnel.ui.state.AppViewState
+import com.zaneschepke.wireguardautotunnel.ui.state.NavBarState
+import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.UiEvent
+
+@Composable
+fun currentNavBackStackEntryAsNavBarState(
+    navController: NavController,
+    backStackEntry: NavBackStackEntry?,
+    viewModel: AppViewModel,
+    uiState: AppUiState,
+    appViewState: AppViewState,
+): State<NavBarState> {
+    val context = LocalContext.current
+
+    fun isActiveSelected() =
+        uiState.activeTunnels.any { active ->
+            appViewState.selectedTunnels.any { it.id == active.key.id }
+        }
+
+    @Composable
+    fun ActionIconButton(icon: ImageVector, labelRes: Int, onClick: () -> Unit) {
+        IconButton(onClick = onClick) {
+            Icon(
+                icon,
+                contentDescription = stringResource(labelRes),
+                modifier = Modifier.size(iconSize),
+            )
+        }
+    }
+
+    @Composable
+    fun TunnelActionBar() {
+        val selectedCount = appViewState.selectedTunnels.size
+        val showDelete = !isActiveSelected()
+
+        Row {
+            if (selectedCount == 0) {
+                val showSort = remember(uiState.tunnels) { uiState.tunnels.size > 1 }
+                if (showSort)
+                    ActionIconButton(Icons.AutoMirrored.Rounded.Sort, R.string.sort) {
+                        navController.navigate(Route.Sort)
+                    }
+                ActionIconButton(Icons.Rounded.Add, R.string.add_tunnel) {
+                    viewModel.handleEvent(
+                        AppEvent.SetBottomSheet(AppViewState.BottomSheet.IMPORT_TUNNELS)
+                    )
+                }
+                return@Row
+            }
+            ActionIconButton(Icons.Rounded.SelectAll, R.string.select_all) {
+                viewModel.handleEvent(AppEvent.ToggleSelectAllTunnels)
+            }
+            // due to permissions, and SAF issues on TV, not support less than Android 10 on
+            // Android TV for file exports
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                ActionIconButton(Icons.Rounded.Download, R.string.download) {
+                    viewModel.handleEvent(
+                        AppEvent.SetBottomSheet(AppViewState.BottomSheet.EXPORT_TUNNELS)
+                    )
+                }
+            }
+
+            if (selectedCount == 1) {
+                ActionIconButton(Icons.Rounded.CopyAll, R.string.copy) {
+                    viewModel.handleEvent(AppEvent.CopySelectedTunnel)
+                }
+            }
+
+            if (showDelete) {
+                ActionIconButton(Icons.Rounded.Delete, R.string.delete_tunnel) {
+                    viewModel.handleEvent(AppEvent.SetShowModal(AppViewState.ModalType.DELETE))
+                }
+            }
+        }
+    }
+
+    return produceState(
+        initialValue = NavBarState(),
+        key1 = backStackEntry,
+        key2 = uiState,
+        key3 = appViewState,
+    ) {
+        value =
+            when {
+                backStackEntry.isCurrentRoute(Route.Main::class) -> {
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.tunnels)) },
+                        topTrailing = { TunnelActionBar() },
+                        route = Route.Main,
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.AutoTunnel::class) -> {
+
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.auto_tunnel)) },
+                        route = Route.AutoTunnel,
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.Logs::class) -> {
+                    NavBarState(
+                        showBottom = false,
+                        topTitle = { Text(stringResource(R.string.logs)) },
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Menu, R.string.quick_actions) {
+                                viewModel.handleEvent(
+                                    AppEvent.SetBottomSheet(AppViewState.BottomSheet.LOGS)
+                                )
+                            }
+                        },
+                        route = Route.Logs,
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.Settings::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.settings)) },
+                        route = Route.Settings,
+                        topTrailing = {
+                            ActionIconButton(
+                                Icons.Rounded.SettingsBackupRestore,
+                                R.string.quick_actions,
+                            ) {
+                                viewModel.handleEvent(
+                                    AppEvent.SetBottomSheet(
+                                        AppViewState.BottomSheet.BACKUP_AND_RESTORE
+                                    )
+                                )
+                            }
+                        },
+                    )
+
+                backStackEntry.isCurrentRoute(Route.Appearance::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.appearance)) },
+                        route = Route.Appearance,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.Language::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.language)) },
+                        route = Route.Language,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.Display::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.display_theme)) },
+                        route = Route.Display,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.TunnelMonitoring::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.tunnel_monitoring)) },
+                        route = Route.TunnelMonitoring,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.ProxySettings::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.proxy_settings)) },
+                        route = Route.ProxySettings,
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                viewModel.handleEvent(AppEvent.InvokeScreenAction)
+                            }
+                        },
+                    )
+
+                backStackEntry.isCurrentRoute(Route.WifiDetectionMethod::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.wifi_detection_method)) },
+                        route = Route.WifiDetectionMethod,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.SystemFeatures::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.android_integrations)) },
+                        route = Route.SystemFeatures,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.Dns::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.dns_settings)) },
+                        route = Route.Dns,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.Support::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.support)) },
+                        route = Route.Support,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.Sort::class) -> {
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { Text(stringResource(R.string.sort)) },
+                        topTrailing = {
+                            Row {
+                                ActionIconButton(Icons.Rounded.SortByAlpha, R.string.sort) {
+                                    viewModel.handleUiEvent(UiEvent.SortTunnels)
+                                }
+                                ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                    viewModel.handleEvent(AppEvent.InvokeScreenAction)
+                                }
+                            }
+                        },
+                        route = Route.Sort,
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.License::class) -> {
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { Text(stringResource(R.string.licenses)) },
+                        route = Route.License,
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.AutoTunnelAdvanced::class) ->
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { Text(stringResource(R.string.advanced_settings)) },
+                        route = Route.AutoTunnelAdvanced,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.TunnelOptions::class) -> {
+                    val args = backStackEntry?.toRoute<Route.TunnelOptions>()
+                    val tunnel = uiState.tunnels.find { it.id == args?.id }
+
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { tunnel?.name?.let { Text(it) } },
+                        topTrailing = {
+                            Row {
+                                ActionIconButton(Icons.Rounded.QrCode2, R.string.show_qr) {
+                                    tunnel?.id?.let {
+                                        viewModel.handleEvent(
+                                            AppEvent.SetShowModal(AppViewState.ModalType.QR)
+                                        )
+                                    }
+                                }
+                                ActionIconButton(Icons.Rounded.Edit, R.string.edit_tunnel) {
+                                    tunnel?.id?.let { navController.navigate(Route.Config(it)) }
+                                }
+                            }
+                        },
+                        route = args?.let { Route.TunnelOptions(it.id) },
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.SplitTunnel::class) -> {
+                    val args = backStackEntry?.toRoute<Route.SplitTunnel>()
+                    val name = uiState.tunnels.find { it.id == args?.id }?.name
+
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { name?.let { Text(it) } },
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                viewModel.handleEvent(AppEvent.InvokeScreenAction)
+                            }
+                        },
+                        route = args?.let { Route.SplitTunnel(it.id) },
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.Config::class) -> {
+                    val args = backStackEntry?.toRoute<Route.Config>()
+                    val name =
+                        uiState.tunnels.find { it.id == args?.id }?.name
+                            ?: context.getString(R.string.new_tunnel)
+
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { Text(name) },
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                viewModel.handleEvent(AppEvent.InvokeScreenAction)
+                            }
+                        },
+                        route = args?.let { Route.Config(it.id) },
+                    )
+                }
+
+                backStackEntry.isCurrentRoute(Route.TunnelAutoTunnel::class) -> {
+                    val args = backStackEntry?.toRoute<Route.TunnelAutoTunnel>()
+                    val name = uiState.tunnels.find { it.id == args?.id }?.name
+
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { name?.let { Text(it) } },
+                        route = args?.let { Route.TunnelAutoTunnel(it.id) },
+                    )
+                }
+
+                else -> NavBarState(showTop = false, showBottom = false)
+            }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/AutoTunnelScreen.kt

@@ -17,75 +17,61 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
+import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
 import com.zaneschepke.wireguardautotunnel.ui.common.banner.WarningBanner
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.AdvancedSettingsItem
-import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.networkTunnelingItems
-import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.wifiTunnelingItems
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.NetworkTunnelingItems
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.WifiTunnelingItems
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchAppSettings
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchLocationServicesSettings
-import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @OptIn(ExperimentalPermissionsApi::class)
 @Composable
-fun AutoTunnelScreen(viewModel: AutoTunnelViewModel = hiltViewModel()) {
-    val context = LocalContext.current
-    val sharedViewModel = LocalSharedVm.current
+fun AutoTunnelScreen(uiState: AppUiState, viewModel: AppViewModel) {
     val navController = LocalNavController.current
-    val autoTunnelState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
-
-    if (!autoTunnelState.stateInitialized) return
-
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.auto_tunnel)) },
-            )
-        )
-    }
+    val context = LocalContext.current
 
+    var currentText by remember { mutableStateOf("") }
     var showLocationDialog by remember { mutableStateOf(false) }
 
     val showLocationServicesWarning by
         remember(
-            autoTunnelState.connectivityState?.wifiState,
-            autoTunnelState.generalSettings.trustedNetworkSSIDs,
-            autoTunnelState.generalSettings.wifiDetectionMethod,
+            uiState.connectivityState?.wifiState,
+            uiState.appSettings.trustedNetworkSSIDs,
+            uiState.appSettings.wifiDetectionMethod,
         ) {
             derivedStateOf {
-                autoTunnelState.connectivityState?.wifiState?.locationServicesEnabled == false &&
-                    autoTunnelState.generalSettings.wifiDetectionMethod
-                        .needsLocationPermissions() &&
-                    autoTunnelState.generalSettings.trustedNetworkSSIDs.isNotEmpty()
+                uiState.connectivityState?.wifiState?.locationServicesEnabled == false &&
+                    uiState.appSettings.wifiDetectionMethod.needsLocationPermissions() &&
+                    uiState.appSettings.trustedNetworkSSIDs.isNotEmpty()
             }
         }
 
     val showLocationPermissionsWarning by
         remember(
-            autoTunnelState.connectivityState?.wifiState,
-            autoTunnelState.generalSettings.trustedNetworkSSIDs,
-            autoTunnelState.generalSettings.wifiDetectionMethod,
+            uiState.connectivityState?.wifiState,
+            uiState.appSettings.trustedNetworkSSIDs,
+            uiState.appSettings.wifiDetectionMethod,
         ) {
             derivedStateOf {
-                autoTunnelState.connectivityState?.wifiState?.locationPermissionsGranted == false &&
-                    autoTunnelState.generalSettings.wifiDetectionMethod
-                        .needsLocationPermissions() &&
-                    autoTunnelState.generalSettings.trustedNetworkSSIDs.isNotEmpty()
+                uiState.connectivityState?.wifiState?.locationPermissionsGranted == false &&
+                    uiState.appSettings.wifiDetectionMethod.needsLocationPermissions() &&
+                    uiState.appSettings.trustedNetworkSSIDs.isNotEmpty()
             }
         }
 
+    LaunchedEffect(uiState.appSettings.trustedNetworkSSIDs) { currentText = "" }
+
     if (showLocationDialog) {
         InfoDialog(
             onAttest = {
@@ -135,8 +121,8 @@ fun AutoTunnelScreen(viewModel: AutoTunnelViewModel = hiltViewModel()) {
             },
         )
         val (title, buttonText, icon) =
-            remember(autoTunnelState.autoTunnelActive) {
-                when (autoTunnelState.autoTunnelActive) {
+            remember(uiState.isAutoTunnelActive) {
+                when (uiState.isAutoTunnelActive) {
                     true ->
                         Triple(
                             context.getString(R.string.auto_tunnel_running),
@@ -158,7 +144,7 @@ fun AutoTunnelScreen(viewModel: AutoTunnelViewModel = hiltViewModel()) {
                         leading = { Icon(icon, null) },
                         title = { Text(title) },
                         trailing = {
-                            Button({ viewModel.toggleAutoTunnel() }) {
+                            Button({ viewModel.handleEvent(AppEvent.ToggleAutoTunnel) }) {
                                 Text(
                                     buttonText,
                                     fontWeight = FontWeight.Bold,
@@ -173,16 +159,16 @@ fun AutoTunnelScreen(viewModel: AutoTunnelViewModel = hiltViewModel()) {
                 )
         )
         SurfaceSelectionGroupButton(
-            items = wifiTunnelingItems(autoTunnelState, viewModel, navController)
+            items = WifiTunnelingItems(uiState, viewModel, currentText) { currentText = it }
         )
         SectionDivider()
-        SurfaceSelectionGroupButton(items = networkTunnelingItems(autoTunnelState, viewModel))
+        SurfaceSelectionGroupButton(items = NetworkTunnelingItems(uiState, viewModel))
         SectionDivider()
         SurfaceSelectionGroupButton(
             items =
                 listOf(
                     AdvancedSettingsItem(
-                        onClick = { navController.navigate(Route.AdvancedAutoTunnel) }
+                        onClick = { navController.navigate(Route.AutoTunnelAdvanced) }
                     )
                 )
         )

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/advanced/AutoTunnelAdvancedScreen.kt

@@ -12,33 +12,18 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.dropdown.LabelledDropdown
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
-import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun AutoTunnelAdvancedScreen(viewModel: AutoTunnelViewModel) {
-    val sharedViewModel = LocalSharedVm.current
-    val autoTunnelState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
-
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.advanced_settings)) },
-            )
-        )
-    }
-
+fun AutoTunnelAdvancedScreen(appUiState: AppUiState, viewModel: AppViewModel) {
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),
@@ -59,9 +44,11 @@ fun AutoTunnelAdvancedScreen(viewModel: AutoTunnelViewModel) {
                 )
             },
             leading = { Icon(Icons.Outlined.PauseCircle, null) },
-            onSelected = { selected -> viewModel.setDebounceDelay(selected!!) },
+            onSelected = { selected ->
+                viewModel.handleEvent(AppEvent.SetDebounceDelay(selected!!))
+            },
             options = (0..10).toList(),
-            currentValue = autoTunnelState.generalSettings.debounceDelaySeconds,
+            currentValue = appUiState.appSettings.debounceDelaySeconds,
             optionToString = { it?.toString() ?: stringResource(R.string._default) },
         )
     }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/components/NetworkTunnelingItems.kt

@@ -14,14 +14,12 @@ import androidx.compose.ui.text.style.TextOverflow
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ScaledSwitch
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
-import com.zaneschepke.wireguardautotunnel.ui.state.AutoTunnelUiState
-import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun networkTunnelingItems(
-    autoTunnelState: AutoTunnelUiState,
-    viewModel: AutoTunnelViewModel,
-): List<SelectionItem> {
+fun NetworkTunnelingItems(uiState: AppUiState, viewModel: AppViewModel): List<SelectionItem> {
     return listOf(
         SelectionItem(
             leading = { Icon(Icons.Outlined.SignalCellular4Bar, contentDescription = null) },
@@ -36,15 +34,15 @@ fun networkTunnelingItems(
             },
             trailing = {
                 ScaledSwitch(
-                    enabled = !autoTunnelState.generalSettings.isAlwaysOnVpnEnabled,
-                    checked = autoTunnelState.generalSettings.isTunnelOnMobileDataEnabled,
-                    onClick = { viewModel.setTunnelOnCellular(it) },
+                    enabled = !uiState.appSettings.isAlwaysOnVpnEnabled,
+                    checked = uiState.appSettings.isTunnelOnMobileDataEnabled,
+                    onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnCellular) },
                 )
             },
             description = {
                 val cellularActive =
-                    remember(autoTunnelState.connectivityState) {
-                        autoTunnelState.connectivityState?.cellularConnected ?: false
+                    remember(uiState.connectivityState) {
+                        uiState.connectivityState?.cellularConnected ?: false
                     }
                 Text(
                     text =
@@ -58,11 +56,7 @@ fun networkTunnelingItems(
                     overflow = TextOverflow.Ellipsis,
                 )
             },
-            onClick = {
-                viewModel.setTunnelOnCellular(
-                    !autoTunnelState.generalSettings.isTunnelOnMobileDataEnabled
-                )
-            },
+            onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnCellular) },
         ),
         SelectionItem(
             leading = { Icon(Icons.Outlined.SettingsEthernet, contentDescription = null) },
@@ -77,15 +71,15 @@ fun networkTunnelingItems(
             },
             trailing = {
                 ScaledSwitch(
-                    enabled = !autoTunnelState.generalSettings.isAlwaysOnVpnEnabled,
-                    checked = autoTunnelState.generalSettings.isTunnelOnEthernetEnabled,
-                    onClick = { viewModel.setTunnelOnEthernet(it) },
+                    enabled = !uiState.appSettings.isAlwaysOnVpnEnabled,
+                    checked = uiState.appSettings.isTunnelOnEthernetEnabled,
+                    onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnEthernet) },
                 )
             },
             description = {
                 val ethernetActive =
-                    remember(autoTunnelState.connectivityState) {
-                        autoTunnelState.connectivityState?.ethernetConnected ?: false
+                    remember(uiState.connectivityState) {
+                        uiState.connectivityState?.ethernetConnected ?: false
                     }
                 Text(
                     text =
@@ -99,11 +93,7 @@ fun networkTunnelingItems(
                     overflow = TextOverflow.Ellipsis,
                 )
             },
-            onClick = {
-                viewModel.setTunnelOnEthernet(
-                    !autoTunnelState.generalSettings.isTunnelOnEthernetEnabled
-                )
-            },
+            onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnEthernet) },
         ),
         SelectionItem(
             leading = { Icon(Icons.Outlined.PublicOff, contentDescription = null) },
@@ -125,15 +115,11 @@ fun networkTunnelingItems(
             },
             trailing = {
                 ScaledSwitch(
-                    checked = autoTunnelState.generalSettings.isStopOnNoInternetEnabled,
-                    onClick = { viewModel.setStopOnNoInternetEnabled(it) },
-                )
-            },
-            onClick = {
-                viewModel.setStopOnNoInternetEnabled(
-                    !autoTunnelState.generalSettings.isStopOnNoInternetEnabled
+                    checked = uiState.appSettings.isStopOnNoInternetEnabled,
+                    onClick = { viewModel.handleEvent(AppEvent.ToggleStopTunnelOnNoInternet) },
                 )
             },
+            onClick = { viewModel.handleEvent(AppEvent.ToggleStopTunnelOnNoInternet) },
         ),
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/components/TrustNetworksTextBox.kt

@@ -20,14 +20,14 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ClickableIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.textbox.CustomTextField
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
 
 @OptIn(ExperimentalLayoutApi::class)
 @Composable
 fun TrustedNetworkTextBox(
-    trustedNetworks: Set<String>,
+    trustedNetworks: List<String>,
     onDelete: (ssid: String) -> Unit,
     currentText: String,
     onSave: (ssid: String) -> Unit,

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/components/wifiTunnelingItems.kt

@@ -3,48 +3,46 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Filter1
-import androidx.compose.material.icons.outlined.Security
-import androidx.compose.material.icons.outlined.Wifi
-import androidx.compose.material.icons.outlined.WifiFind
+import androidx.compose.material.icons.outlined.*
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
-import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ScaledSwitch
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberClipboardHelper
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.LearnMoreLinkLabel
-import com.zaneschepke.wireguardautotunnel.ui.state.AutoTunnelUiState
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
 import com.zaneschepke.wireguardautotunnel.util.extensions.asTitleString
 import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
-import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun wifiTunnelingItems(
-    autoTunnelState: AutoTunnelUiState,
-    viewModel: AutoTunnelViewModel,
-    navController: NavController,
+fun WifiTunnelingItems(
+    uiState: AppUiState,
+    viewModel: AppViewModel,
+    currentText: String,
+    onTextChange: (String) -> Unit,
 ): List<SelectionItem> {
     val context = LocalContext.current
+    val navController = LocalNavController.current
     val clipboardHelper = rememberClipboardHelper()
 
-    var currentText by rememberSaveable { mutableStateOf("") }
-
-    LaunchedEffect(autoTunnelState.generalSettings.trustedNetworkSSIDs) { currentText = "" }
-
     val baseItems =
         listOf(
             SelectionItem(
@@ -60,16 +58,16 @@ fun wifiTunnelingItems(
                 },
                 trailing = {
                     ScaledSwitch(
-                        enabled = !autoTunnelState.generalSettings.isAlwaysOnVpnEnabled,
-                        checked = autoTunnelState.generalSettings.isTunnelOnWifiEnabled,
-                        onClick = { viewModel.setAutoTunnelOnWifiEnabled(it) },
+                        enabled = !uiState.appSettings.isAlwaysOnVpnEnabled,
+                        checked = uiState.appSettings.isTunnelOnWifiEnabled,
+                        onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnWifi) },
                     )
                 },
                 description = {
                     val wifiInfo by
-                        remember(autoTunnelState.connectivityState) {
+                        remember(uiState.connectivityState) {
                             derivedStateOf {
-                                autoTunnelState.connectivityState
+                                uiState.connectivityState
                                     ?.wifiState
                                     ?.takeIf { it.connected }
                                     .let { Pair(it?.ssid, it?.securityType) }
@@ -103,15 +101,11 @@ fun wifiTunnelingItems(
                         }
                     }
                 },
-                onClick = {
-                    viewModel.setAutoTunnelOnWifiEnabled(
-                        !autoTunnelState.generalSettings.isTunnelOnWifiEnabled
-                    )
-                },
+                onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnWifi) },
             )
         )
 
-    return if (autoTunnelState.generalSettings.isTunnelOnWifiEnabled) {
+    return if (uiState.appSettings.isTunnelOnWifiEnabled) {
         baseItems +
             listOf(
                 SelectionItem(
@@ -129,9 +123,7 @@ fun wifiTunnelingItems(
                         Text(
                             stringResource(
                                 R.string.current_template,
-                                autoTunnelState.generalSettings.wifiDetectionMethod.asTitleString(
-                                    context
-                                ),
+                                uiState.appSettings.wifiDetectionMethod.asTitleString(context),
                             ),
                             style =
                                 MaterialTheme.typography.bodySmall.copy(
@@ -163,15 +155,11 @@ fun wifiTunnelingItems(
                     },
                     trailing = {
                         ScaledSwitch(
-                            checked = autoTunnelState.generalSettings.isWildcardsEnabled,
-                            onClick = { viewModel.setWildcardsEnabled(it) },
-                        )
-                    },
-                    onClick = {
-                        viewModel.setWildcardsEnabled(
-                            !autoTunnelState.generalSettings.isWildcardsEnabled
+                            checked = uiState.appSettings.isWildcardsEnabled,
+                            onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelWildcards) },
                         )
                     },
+                    onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelWildcards) },
                 ),
                 SelectionItem(
                     title = {
@@ -207,18 +195,41 @@ fun wifiTunnelingItems(
                     },
                     description = {
                         TrustedNetworkTextBox(
-                            autoTunnelState.generalSettings.trustedNetworkSSIDs,
-                            onDelete = { viewModel.removeTrustedNetworkName(it) },
+                            uiState.appSettings.trustedNetworkSSIDs,
+                            onDelete = { viewModel.handleEvent(AppEvent.DeleteTrustedSSID(it)) },
                             currentText = currentText,
-                            onSave = { ssid -> viewModel.saveTrustedNetworkName(ssid) },
-                            onValueChange = { currentText = it },
+                            onSave = { ssid ->
+                                viewModel.handleEvent(AppEvent.SaveTrustedSSID(ssid))
+                            },
+                            onValueChange = onTextChange,
                             supporting = {
-                                if (autoTunnelState.generalSettings.isWildcardsEnabled)
-                                    WildcardsLabel()
+                                if (uiState.appSettings.isWildcardsEnabled) WildcardsLabel()
                             },
                         )
                     },
                 ),
+                SelectionItem(
+                    leading = { Icon(Icons.Outlined.VpnKeyOff, contentDescription = null) },
+                    title = {
+                        Text(
+                            stringResource(R.string.kill_switch_off),
+                            style =
+                                MaterialTheme.typography.bodyMedium.copy(
+                                    MaterialTheme.colorScheme.onSurface
+                                ),
+                        )
+                    },
+                    trailing = {
+                        ScaledSwitch(
+                            enabled = uiState.appSettings.isVpnKillSwitchEnabled,
+                            checked = uiState.appSettings.isDisableKillSwitchOnTrustedEnabled,
+                            onClick = {
+                                viewModel.handleEvent(AppEvent.ToggleStopKillSwitchOnTrusted)
+                            },
+                        )
+                    },
+                    onClick = { viewModel.handleEvent(AppEvent.ToggleStopKillSwitchOnTrusted) },
+                ),
             )
     } else {
         baseItems

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/detection/WifiDetectionMethodScreen.kt

@@ -4,53 +4,34 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.model.WifiDetectionMethod
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
 import com.zaneschepke.wireguardautotunnel.ui.common.button.IconSurfaceButton
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.util.extensions.asDescriptionString
 import com.zaneschepke.wireguardautotunnel.util.extensions.asTitleString
-import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun WifiDetectionMethodScreen(viewModel: AutoTunnelViewModel) {
+fun WifiDetectionMethodScreen(uiState: AppUiState, viewModel: AppViewModel) {
     val context = LocalContext.current
-    val sharedViewModel = LocalSharedVm.current
-
-    val autoTunnelState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
-
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                topTitle = { Text(stringResource(R.string.wifi_detection_method)) },
-                showBottomItems = true,
-            )
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(24.dp, Alignment.Top),
         modifier = Modifier.fillMaxSize().padding(top = 24.dp).padding(horizontal = 24.dp),
     ) {
-        enumValues<WifiDetectionMethod>().forEach {
+        enumValues<AndroidNetworkMonitor.WifiDetectionMethod>().forEach {
             val title = it.asTitleString(context)
             val description = it.asDescriptionString(context)
             IconSurfaceButton(
                 title = title,
-                onClick = { sharedViewModel.setWifiDetectionMethod(it) },
-                selected = autoTunnelState.generalSettings.wifiDetectionMethod == it,
+                onClick = { viewModel.handleEvent(AppEvent.SetDetectionMethod(it)) },
+                selected = uiState.appSettings.wifiDetectionMethod == it,
                 description = description,
             )
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/disclosure/LocationDisclosureScreen.kt

@@ -9,23 +9,17 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.LocationDisclosureHeader
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.appSettingsItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.skipItem
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
-import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun LocationDisclosureScreen(viewModel: AutoTunnelViewModel) {
-    val navController = LocalNavController.current
-    val sharedViewModel = LocalSharedVm.current
+fun LocationDisclosureScreen(viewModel: AppViewModel) {
 
-    LaunchedEffect(Unit) { sharedViewModel.updateNavbarState(NavbarState(showBottomItems = true)) }
-
-    LaunchedEffect(Unit) { viewModel.setLocationDisclosureShown() }
+    LaunchedEffect(Unit) { viewModel.handleEvent(AppEvent.SetLocationDisclosureShown) }
 
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
@@ -34,6 +28,6 @@ fun LocationDisclosureScreen(viewModel: AutoTunnelViewModel) {
     ) {
         LocationDisclosureHeader()
         SurfaceSelectionGroupButton(items = listOf(appSettingsItem()))
-        SurfaceSelectionGroupButton(items = listOf(skipItem(navController)))
+        SurfaceSelectionGroupButton(items = listOf(skipItem()))
     }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/disclosure/components/AppSettingsItem.kt

@@ -3,14 +3,14 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.com
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.LocationOn
 import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItemLabel
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionLabelType
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchAppSettings
 
 @Composable
@@ -20,9 +20,9 @@ fun appSettingsItem(): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.Outlined.LocationOn, contentDescription = null) },
         title = {
-            SelectionItemLabel(
-                stringResource(R.string.launch_app_settings),
-                labelType = SelectionLabelType.TITLE,
+            Text(
+                text = stringResource(R.string.launch_app_settings),
+                style = MaterialTheme.typography.bodyLarge.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
         trailing = { ForwardButton { context.launchAppSettings() } },

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/disclosure/components/LocationDisclosureHeader.kt

@@ -20,14 +20,14 @@ fun LocationDisclosureHeader() {
     Icon(
         imageVector = icon,
         contentDescription = icon.name,
-        modifier = Modifier.padding(24.dp).size(100.dp),
+        modifier = Modifier.padding(30.dp).size(128.dp),
     )
     Text(
         text = stringResource(R.string.prominent_background_location_title),
-        style = MaterialTheme.typography.titleMedium.copy(fontWeight = FontWeight.Bold),
+        style = MaterialTheme.typography.titleLarge.copy(fontWeight = FontWeight.Bold),
     )
     Text(
         text = stringResource(R.string.prominent_background_location_message),
-        style = MaterialTheme.typography.bodyMedium,
+        style = MaterialTheme.typography.bodyLarge,
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/autotunnel/disclosure/components/SkipItem.kt

@@ -1,22 +1,27 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components
 
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
-import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItemLabel
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionLabelType
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
+import com.zaneschepke.wireguardautotunnel.util.extensions.goFromRoot
 
 @Composable
-fun skipItem(navController: NavController): SelectionItem {
+fun skipItem(): SelectionItem {
+    val navController = LocalNavController.current
     return SelectionItem(
         title = {
-            SelectionItemLabel(stringResource(R.string.skip), labelType = SelectionLabelType.TITLE)
+            Text(
+                text = stringResource(R.string.skip),
+                style = MaterialTheme.typography.bodyLarge.copy(MaterialTheme.colorScheme.onSurface),
+            )
         },
-        trailing = { ForwardButton { navController.navigate(Route.AutoTunnelGraph) } },
-        onClick = { navController.navigate(Route.AutoTunnelGraph) },
+        trailing = { ForwardButton { navController.goFromRoot(Route.AutoTunnel) } },
+        onClick = { navController.goFromRoot(Route.AutoTunnel) },
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/MainScreen.kt

@@ -0,0 +1,140 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main
+
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.journeyapps.barcodescanner.ScanContract
+import com.journeyapps.barcodescanner.ScanOptions
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.Route
+import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
+import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberClipboardHelper
+import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberFileImportLauncherForResult
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.ExportTunnelsBottomSheet
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.TunnelImportSheet
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.TunnelList
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.UrlImportDialog
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
+import com.zaneschepke.wireguardautotunnel.ui.state.AppViewState
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+
+@Composable
+fun MainScreen(appUiState: AppUiState, appViewState: AppViewState, viewModel: AppViewModel) {
+    val navController = LocalNavController.current
+    val clipboard = rememberClipboardHelper()
+
+    var showUrlImportDialog by remember { mutableStateOf(false) }
+
+    val tunnelFileImportResultLauncher =
+        rememberFileImportLauncherForResult(
+            onNoFileExplorer = {
+                viewModel.handleEvent(
+                    AppEvent.ShowMessage(
+                        StringValue.StringResource(R.string.error_no_file_explorer)
+                    )
+                )
+            },
+            onData = { data -> viewModel.handleEvent(AppEvent.ImportTunnelFromFile(data)) },
+        )
+
+    val scanLauncher =
+        rememberLauncherForActivityResult(
+            contract = ScanContract(),
+            onResult = { result ->
+                if (result != null && result.contents.isNotEmpty())
+                    viewModel.handleEvent(AppEvent.ImportTunnelFromQrCode(result.contents))
+            },
+        )
+
+    val requestPermissionLauncher =
+        rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted
+            ->
+            if (!isGranted) {
+                viewModel.handleEvent(
+                    AppEvent.ShowMessage(
+                        StringValue.StringResource(R.string.camera_permission_required)
+                    )
+                )
+                return@rememberLauncherForActivityResult
+            }
+            scanLauncher.launch(
+                ScanOptions().setDesiredBarcodeFormats(ScanOptions.QR_CODE).setBeepEnabled(false)
+            )
+        }
+
+    if (appViewState.showModal == AppViewState.ModalType.DELETE) {
+        InfoDialog(
+            onDismiss = {
+                viewModel.handleEvent(AppEvent.SetShowModal(AppViewState.ModalType.NONE))
+            },
+            onAttest = {
+                viewModel.handleEvent(AppEvent.DeleteSelectedTunnels)
+                viewModel.handleEvent(AppEvent.SetShowModal(AppViewState.ModalType.NONE))
+            },
+            title = { Text(text = stringResource(R.string.delete_tunnel)) },
+            body = { Text(text = stringResource(R.string.delete_tunnel_message)) },
+            confirmText = { Text(text = stringResource(R.string.yes)) },
+        )
+    }
+
+    when (appViewState.bottomSheet) {
+        AppViewState.BottomSheet.EXPORT_TUNNELS -> {
+            ExportTunnelsBottomSheet(viewModel)
+        }
+        AppViewState.BottomSheet.IMPORT_TUNNELS -> {
+            TunnelImportSheet(
+                onDismiss = {
+                    viewModel.handleEvent(AppEvent.SetBottomSheet(AppViewState.BottomSheet.NONE))
+                },
+                onFileClick = {
+                    tunnelFileImportResultLauncher.launch(Constants.ALLOWED_TV_FILE_TYPES)
+                },
+                onQrClick = {
+                    requestPermissionLauncher.launch(android.Manifest.permission.CAMERA)
+                },
+                onClipboardClick = {
+                    clipboard.paste { result ->
+                        if (result != null)
+                            viewModel.handleEvent(AppEvent.ImportTunnelFromClipboard(result))
+                    }
+                },
+                onManualImportClick = {
+                    navController.navigate(Route.Config(Constants.MANUAL_TUNNEL_CONFIG_ID))
+                },
+                onUrlClick = { showUrlImportDialog = true },
+            )
+        }
+        else -> Unit
+    }
+
+    if (showUrlImportDialog) {
+        UrlImportDialog(
+            onDismiss = { showUrlImportDialog = false },
+            onConfirm = { url ->
+                viewModel.handleEvent(AppEvent.ImportTunnelFromUrl(url))
+                showUrlImportDialog = false
+            },
+        )
+    }
+
+    TunnelList(
+        appUiState = appUiState,
+        selectedTunnels = appViewState.selectedTunnels,
+        onToggleTunnel = { tunnel, checked ->
+            if (checked) viewModel.handleEvent(AppEvent.StartTunnel(tunnel))
+            else viewModel.handleEvent(AppEvent.StopTunnel(tunnel))
+        },
+        modifier = Modifier.fillMaxSize().padding(vertical = 24.dp).padding(horizontal = 12.dp),
+        viewModel = viewModel,
+    )
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/autotunnel/TunnelAutoTunnelScreen.kt

@@ -0,0 +1,57 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components.MobileDataTunnelItem
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components.PingRestartItem
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components.WifiTunnelItem
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components.ethernetTunnelItem
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+
+@Composable
+fun TunnelAutoTunnelScreen(
+    tunnelConf: TunnelConf,
+    appSettings: AppSettings,
+    viewModel: AppViewModel,
+) {
+    var currentText by remember { mutableStateOf("") }
+
+    LaunchedEffect(tunnelConf.tunnelNetworks) { currentText = "" }
+
+    Column(
+        horizontalAlignment = Alignment.Start,
+        verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),
+        modifier =
+            Modifier.fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(vertical = 24.dp)
+                .padding(horizontal = 12.dp),
+    ) {
+        SurfaceSelectionGroupButton(
+            items =
+                buildList {
+                    if (appSettings.isPingEnabled) {
+                        add(PingRestartItem(tunnelConf, viewModel))
+                    }
+                    add(MobileDataTunnelItem(tunnelConf, viewModel))
+                    add(ethernetTunnelItem(tunnelConf, viewModel))
+                    add(
+                        WifiTunnelItem(tunnelConf, appSettings, viewModel, currentText) {
+                            currentText = it
+                        }
+                    )
+                }
+        )
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/autotunnel/components/MobileDataTunnelItem.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.PhoneAndroid
@@ -8,11 +8,14 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ScaledSwitch
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun MobileDataTunnelItem(enabled: Boolean, onClick: (Boolean) -> Unit): SelectionItem {
+fun MobileDataTunnelItem(tunnelConf: TunnelConf, viewModel: AppViewModel): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.Outlined.PhoneAndroid, contentDescription = null) },
         title = {
@@ -28,7 +31,12 @@ fun MobileDataTunnelItem(enabled: Boolean, onClick: (Boolean) -> Unit): Selectio
                 style = MaterialTheme.typography.bodySmall.copy(MaterialTheme.colorScheme.outline),
             )
         },
-        trailing = { ScaledSwitch(checked = enabled, onClick = onClick) },
-        onClick = { onClick(!enabled) },
+        trailing = {
+            ScaledSwitch(
+                checked = tunnelConf.isMobileDataTunnel,
+                onClick = { viewModel.handleEvent(AppEvent.ToggleMobileDataTunnel(tunnelConf)) },
+            )
+        },
+        onClick = { viewModel.handleEvent(AppEvent.ToggleMobileDataTunnel(tunnelConf)) },
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/autotunnel/components/PingRestartItem.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.NetworkPing
@@ -8,11 +8,14 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ScaledSwitch
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun PingRestartItem(enabled: Boolean, onClick: (Boolean) -> Unit): SelectionItem {
+fun PingRestartItem(tunnelConf: TunnelConf, viewModel: AppViewModel): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.Outlined.NetworkPing, contentDescription = null) },
         title = {
@@ -22,7 +25,12 @@ fun PingRestartItem(enabled: Boolean, onClick: (Boolean) -> Unit): SelectionItem
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        trailing = { ScaledSwitch(checked = enabled, onClick = onClick) },
-        onClick = { onClick(!enabled) },
+        trailing = {
+            ScaledSwitch(
+                checked = tunnelConf.restartOnPingFailure,
+                onClick = { viewModel.handleEvent(AppEvent.ToggleRestartOnPingFailure(tunnelConf)) },
+            )
+        },
+        onClick = { viewModel.handleEvent(AppEvent.ToggleRestartOnPingFailure(tunnelConf)) },
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/autotunnel/components/WifiTunnelItem.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components
 
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.icons.Icons
@@ -6,30 +6,29 @@ import androidx.compose.material.icons.outlined.Security
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
-import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.TrustedNetworkTextBox
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.WildcardsLabel
 import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
 fun WifiTunnelItem(
-    tunnelNetworks: Set<String>,
-    isWildcardsEnabled: Boolean,
-    onSaveTunnelNetwork: (String) -> Unit,
-    onDeleteTunnelNetwork: (String) -> Unit,
+    tunnelConf: TunnelConf,
+    appSettings: AppSettings,
+    viewModel: AppViewModel,
+    currentText: String,
+    onTextChange: (String) -> Unit,
 ): SelectionItem {
-
-    var currentText by rememberSaveable { mutableStateOf("") }
-
-    LaunchedEffect(tunnelNetworks) { currentText = "" }
-
     return SelectionItem(
         title = {
             Row(
@@ -54,13 +53,16 @@ fun WifiTunnelItem(
         },
         description = {
             TrustedNetworkTextBox(
-                trustedNetworks = tunnelNetworks,
-                onDelete = onDeleteTunnelNetwork,
+                trustedNetworks = tunnelConf.tunnelNetworks,
+                onDelete = { viewModel.handleEvent(AppEvent.DeleteTunnelRunSSID(it, tunnelConf)) },
                 currentText = currentText,
-                onSave = onSaveTunnelNetwork,
-                onValueChange = { currentText = it },
+                onSave = {
+                    viewModel.handleEvent(AppEvent.AddTunnelRunSSID(it, tunnelConf))
+                    onTextChange("") // Reset the text field after saving
+                },
+                onValueChange = onTextChange,
                 supporting = {
-                    if (isWildcardsEnabled) {
+                    if (appSettings.isWildcardsEnabled) {
                         WildcardsLabel()
                     }
                 },

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/autotunnel/components/ethernetTunnelItem.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.components
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.SettingsEthernet
@@ -8,11 +8,14 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ScaledSwitch
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @Composable
-fun ethernetTunnelItem(enabled: Boolean, onClick: (Boolean) -> Unit): SelectionItem {
+fun ethernetTunnelItem(tunnelConf: TunnelConf, viewModel: AppViewModel): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.Outlined.SettingsEthernet, contentDescription = null) },
         title = {
@@ -28,7 +31,12 @@ fun ethernetTunnelItem(enabled: Boolean, onClick: (Boolean) -> Unit): SelectionI
                 style = MaterialTheme.typography.bodySmall.copy(MaterialTheme.colorScheme.outline),
             )
         },
-        trailing = { ScaledSwitch(checked = enabled, onClick = onClick) },
-        onClick = { onClick(!enabled) },
+        trailing = {
+            ScaledSwitch(
+                checked = tunnelConf.isEthernetTunnel,
+                onClick = { viewModel.handleEvent(AppEvent.ToggleEthernetTunnel(tunnelConf)) },
+            )
+        },
+        onClick = { viewModel.handleEvent(AppEvent.ToggleEthernetTunnel(tunnelConf)) },
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/ExportTunnelsBottomSheet.kt

@@ -1,6 +1,5 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
-import android.net.Uri
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.FolderZip
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -9,25 +8,22 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.domain.enums.ConfigType
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberFileExportLauncherForResult
 import com.zaneschepke.wireguardautotunnel.ui.common.sheet.CustomBottomSheet
 import com.zaneschepke.wireguardautotunnel.ui.common.sheet.SheetOption
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.AuthorizationPromptWrapper
+import com.zaneschepke.wireguardautotunnel.ui.state.AppViewState
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.extensions.hasSAFSupport
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
-fun ExportTunnelsBottomSheet(
-    onExport: (configType: ConfigType, uri: Uri?) -> Unit,
-    onDismiss: () -> Unit,
-) {
+fun ExportTunnelsBottomSheet(viewModel: AppViewModel) {
     val context = LocalContext.current
     val isTv = LocalIsAndroidTV.current
-    val sharedViewModel = LocalSharedVm.current
 
     var exportConfigType by remember { mutableStateOf(ConfigType.WG) }
     var showAuthPrompt by remember { mutableStateOf(false) }
@@ -36,19 +32,22 @@ fun ExportTunnelsBottomSheet(
 
     val selectedTunnelsExportLauncher =
         rememberFileExportLauncherForResult(
-            mimeType = FileUtils.ZIP_FILE_MIME_TYPE,
+            mimeType = Constants.ZIP_FILE_MIME_TYPE,
             onResult = { file ->
                 if (file != null) {
-                    onExport(ConfigType.WG, file)
-                } else onDismiss()
+                    viewModel.handleEvent(AppEvent.ExportSelectedTunnels(exportConfigType, file))
+                } else {
+                    viewModel.handleEvent(AppEvent.ClearSelectedTunnels)
+                    viewModel.handleEvent(AppEvent.SetBottomSheet(AppViewState.BottomSheet.NONE))
+                }
             },
         )
 
     fun handleFileExport() {
-        if (context.hasSAFSupport(FileUtils.ZIP_FILE_MIME_TYPE)) {
+        if (context.hasSAFSupport(Constants.ZIP_FILE_MIME_TYPE)) {
             selectedTunnelsExportLauncher.launch(Constants.DEFAULT_EXPORT_FILE_NAME)
         } else {
-            onExport(exportConfigType, null)
+            viewModel.handleEvent(AppEvent.ExportSelectedTunnels(exportConfigType, null))
         }
     }
 
@@ -67,6 +66,7 @@ fun ExportTunnelsBottomSheet(
                 isAuthorized = true
                 shouldExport = true
             },
+            viewModel = viewModel,
         )
     }
 
@@ -98,6 +98,6 @@ fun ExportTunnelsBottomSheet(
             ),
         )
     ) {
-        onDismiss()
+        viewModel.handleEvent(AppEvent.SetBottomSheet(AppViewState.BottomSheet.NONE))
     }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/GettingStartedLabel.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/ScrollDismissMultiFab.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.slideInVertically

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/TunnelImportSheet.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.*
@@ -6,9 +6,9 @@ import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
 import com.zaneschepke.wireguardautotunnel.ui.common.sheet.CustomBottomSheet
 import com.zaneschepke.wireguardautotunnel.ui.common.sheet.SheetOption
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/TunnelList.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.combinedClickable
@@ -17,27 +17,29 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.dp
-import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.core.tunnel.getValueById
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
-import com.zaneschepke.wireguardautotunnel.ui.state.TunnelsUiState
+import com.zaneschepke.wireguardautotunnel.ui.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
-import com.zaneschepke.wireguardautotunnel.viewmodel.SharedAppViewModel
-import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
 fun TunnelList(
-    tunnelsState: TunnelsUiState,
+    appUiState: AppUiState,
+    selectedTunnels: List<TunnelConf>,
     modifier: Modifier = Modifier,
-    viewModel: TunnelsViewModel,
-    sharedViewModel: SharedAppViewModel,
-    navController: NavController,
+    onToggleTunnel: (TunnelConf, Boolean) -> Unit,
+    viewModel: AppViewModel,
 ) {
     val isTv = LocalIsAndroidTV.current
     val context = LocalContext.current
+    val navController = LocalNavController.current
 
     val lazyListState = rememberLazyListState()
 
@@ -46,54 +48,52 @@ fun TunnelList(
         verticalArrangement = Arrangement.spacedBy(5.dp, Alignment.Top),
         modifier =
             modifier
-                .pointerInput(Unit) {
-                    if (tunnelsState.tunnels.isEmpty()) return@pointerInput
-                    viewModel.clearSelectedTunnels()
-                }
+                .pointerInput(Unit) { if (appUiState.tunnels.isEmpty()) return@pointerInput }
                 .overscroll(rememberOverscrollEffect()),
         state = lazyListState,
         userScrollEnabled = true,
         reverseLayout = false,
         flingBehavior = ScrollableDefaults.flingBehavior(),
     ) {
-        if (tunnelsState.tunnels.isEmpty()) {
+        if (appUiState.tunnels.isEmpty()) {
             item { GettingStartedLabel(onClick = { context.openWebUrl(it) }) }
         }
-        items(tunnelsState.tunnels, key = { it.id }) { tunnel ->
+        items(appUiState.tunnels, key = { it.id }) { tunnel ->
             val tunnelState =
-                remember(tunnelsState.activeTunnels) {
-                    tunnelsState.activeTunnels.getValueById(tunnel.id) ?: TunnelState()
-                }
-            val selected =
-                remember(tunnelsState.selectedTunnels) {
-                    tunnelsState.selectedTunnels.any { it.id == tunnel.id }
+                remember(appUiState.activeTunnels) {
+                    appUiState.activeTunnels.getValueById(tunnel.id) ?: TunnelState()
                 }
+            val selected = remember(selectedTunnels) { selectedTunnels.any { it.id == tunnel.id } }
             TunnelRowItem(
                 state = tunnelState,
                 isSelected = selected,
                 tunnel = tunnel,
                 tunnelState = tunnelState,
-                onTvClick = { navController.navigate(Route.TunnelOptions(tunnel.id)) },
-                onToggleSelectedTunnel = { tunnel -> viewModel.toggleSelectedTunnel(tunnel.id) },
-                onSwitchClick = { checked ->
-                    if (checked) sharedViewModel.startTunnel(tunnel)
-                    else sharedViewModel.stopTunnel(tunnel)
+                appSettings = appUiState.appSettings,
+                onTvClick = {
+                    navController.navigate(Route.TunnelOptions(tunnel.id))
+                    viewModel.handleEvent(AppEvent.ClearSelectedTunnels)
                 },
+                onToggleSelectedTunnel = {
+                    viewModel.handleEvent(AppEvent.ToggleSelectedTunnel(it))
+                },
+                onSwitchClick = { checked -> onToggleTunnel(tunnel, checked) },
                 isTv = isTv,
-                isPingEnabled = tunnelsState.isPingEnabled,
-                showDetailedStats = tunnelsState.showPingStats,
+                showDetailedStats = appUiState.appState.showDetailedPingStats,
                 modifier =
                     if (!isTv)
                         Modifier.combinedClickable(
                             onClick = {
-                                if (tunnelsState.selectedTunnels.isNotEmpty()) {
-                                    viewModel.toggleSelectedTunnel(tunnel.id)
+                                if (selectedTunnels.isNotEmpty()) {
+                                    viewModel.handleEvent(AppEvent.ToggleSelectedTunnel(tunnel))
                                 } else {
                                     navController.navigate(Route.TunnelOptions(tunnel.id))
-                                    viewModel.clearSelectedTunnels()
+                                    viewModel.handleEvent(AppEvent.ClearSelectedTunnels)
                                 }
                             },
-                            onLongClick = { viewModel.toggleSelectedTunnel(tunnel.id) },
+                            onLongClick = {
+                                viewModel.handleEvent(AppEvent.ToggleSelectedTunnel(tunnel))
+                            },
                             interactionSource = remember { MutableInteractionSource() },
                             indication = null,
                         )

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/TunnelRowItem.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -20,6 +20,7 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.common.ExpandingRowListItem
@@ -32,11 +33,11 @@ fun TunnelRowItem(
     isSelected: Boolean,
     tunnel: TunnelConf,
     tunnelState: TunnelState,
+    appSettings: AppSettings,
     onTvClick: () -> Unit,
     onToggleSelectedTunnel: (TunnelConf) -> Unit,
     onSwitchClick: (Boolean) -> Unit,
     isTv: Boolean,
-    isPingEnabled: Boolean,
     showDetailedStats: Boolean,
     modifier: Modifier = Modifier,
 ) {
@@ -111,7 +112,12 @@ fun TunnelRowItem(
         text = tunnel.tunName,
         expanded = {
             if (tunnelState.status != TunnelStatus.Down) {
-                TunnelStatisticsRow(tunnelState, tunnel, isPingEnabled, showDetailedStats)
+                TunnelStatisticsRow(
+                    tunnelState,
+                    tunnel,
+                    appSettings.isPingEnabled,
+                    showDetailedStats,
+                )
             }
         },
         trailing = {

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/TunnelStatisticsRow.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.layout.*

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/components/UrlImportDialog.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
 
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxWidth

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/ConfigScreen.kt

@@ -0,0 +1,128 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.ui.common.SecureScreenFromRecording
+import com.zaneschepke.wireguardautotunnel.ui.common.prompt.AuthorizationPrompt
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components.AddPeerButton
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components.InterfaceSection
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components.PeersSection
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+
+@Composable
+fun ConfigScreen(
+    tunnelConf: TunnelConf?,
+    appUiState: AppUiState,
+    appViewModel: AppViewModel,
+    viewModel: ConfigViewModel = hiltViewModel(),
+) {
+    val context = LocalContext.current
+    val keyboardController = LocalSoftwareKeyboardController.current
+
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    var save by remember { mutableStateOf(false) }
+
+    val isTunnelNameTaken by
+        remember(uiState.tunnelName, appUiState.tunnels) {
+            derivedStateOf {
+                appUiState.tunnels
+                    .filter { it.id != tunnelConf?.id }
+                    .any { it.name == uiState.tunnelName }
+            }
+        }
+
+    SecureScreenFromRecording()
+
+    LaunchedEffect(Unit) {
+        // set callback for navbar to invoke save
+        appViewModel.handleEvent(
+            AppEvent.SetScreenAction {
+                keyboardController?.hide()
+                if (!isTunnelNameTaken) {
+                    save = true
+                }
+            }
+        )
+    }
+
+    LaunchedEffect(tunnelConf) { viewModel.initFromTunnel(tunnelConf) }
+
+    // TODO improve error messages
+    LaunchedEffect(save) {
+        if (save) {
+            try {
+                appViewModel.handleEvent(
+                    AppEvent.SaveTunnel(
+                        uiState.configProxy.buildTunnelConfFromState(uiState.tunnelName, tunnelConf)
+                    )
+                )
+                appViewModel.handleEvent(
+                    AppEvent.ShowMessage(StringValue.StringResource(R.string.config_changes_saved))
+                )
+                appViewModel.handleEvent(AppEvent.PopBackStack(true))
+            } catch (e: Exception) {
+                val message = e.message ?: context.resources.getString(R.string.unknown_error)
+                appViewModel.handleEvent(AppEvent.ShowMessage(StringValue.DynamicString(message)))
+            } finally {
+                save = false
+            }
+        }
+    }
+
+    if (uiState.showAuthPrompt) {
+        AuthorizationPrompt(
+            onSuccess = {
+                viewModel.toggleShowAuthPrompt()
+                viewModel.onAuthenticated()
+            },
+            onError = {
+                viewModel.toggleShowAuthPrompt()
+                appViewModel.handleEvent(
+                    AppEvent.ShowMessage(
+                        StringValue.StringResource(R.string.error_authentication_failed)
+                    )
+                )
+            },
+            onFailure = {
+                viewModel.toggleShowAuthPrompt()
+                appViewModel.handleEvent(
+                    AppEvent.ShowMessage(
+                        StringValue.StringResource(R.string.error_authorization_failed)
+                    )
+                )
+            },
+        )
+    }
+
+    Column(
+        horizontalAlignment = Alignment.Start,
+        verticalArrangement = Arrangement.spacedBy(24.dp, Alignment.Top),
+        modifier =
+            Modifier.fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(top = 12.dp, bottom = 24.dp)
+                .padding(horizontal = 12.dp),
+    ) {
+        InterfaceSection(isTunnelNameTaken, uiState, viewModel)
+        PeersSection(uiState, viewModel)
+        AddPeerButton(viewModel)
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/ConfigViewModel.kt

@@ -0,0 +1,119 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config
+
+import androidx.lifecycle.ViewModel
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.state.ConfigUiState
+import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
+import com.zaneschepke.wireguardautotunnel.ui.state.InterfaceProxy
+import com.zaneschepke.wireguardautotunnel.ui.state.PeerProxy
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+
+@HiltViewModel
+class ConfigViewModel @Inject constructor() : ViewModel() {
+
+    private val _uiState = MutableStateFlow(ConfigUiState())
+    val uiState: StateFlow<ConfigUiState> = _uiState.asStateFlow()
+
+    fun initFromTunnel(tunnelConf: TunnelConf?) {
+        if (tunnelConf == null) return
+        _uiState.update {
+            val proxy = ConfigProxy.from(tunnelConf.toAmConfig())
+            it.copy(
+                tunnelName = tunnelConf.name,
+                configProxy = proxy,
+                showScripts = proxy.hasScripts(),
+                showAmneziaValues = proxy.`interface`.junkPacketCount.isNotBlank(),
+                isAuthenticated = false,
+            )
+        }
+    }
+
+    fun updateTunnelName(name: String) {
+        _uiState.update { it.copy(tunnelName = name) }
+    }
+
+    fun updateInterface(newInterface: InterfaceProxy) {
+        _uiState.update { it.copy(configProxy = it.configProxy.copy(`interface` = newInterface)) }
+    }
+
+    fun toggleAmneziaValues() {
+        _uiState.update { it.copy(showAmneziaValues = !it.showAmneziaValues) }
+    }
+
+    fun toggleScripts() {
+        _uiState.update { it.copy(showScripts = !it.showScripts) }
+    }
+
+    fun toggleAmneziaCompatibility() {
+        val (show, `interface`) =
+            with(_uiState.value.configProxy) {
+                if (`interface`.isAmneziaCompatibilityModeSet()) {
+                    Pair(false, `interface`.resetAmneziaProperties())
+                } else {
+                    Pair(true, `interface`.toAmneziaCompatibilityConfig())
+                }
+            }
+        _uiState.update {
+            it.copy(
+                showAmneziaValues = show,
+                configProxy = it.configProxy.copy(`interface` = `interface`),
+            )
+        }
+    }
+
+    fun addPeer() {
+        _uiState.update { currentState ->
+            currentState.copy(
+                configProxy =
+                    currentState.configProxy.copy(
+                        peers = currentState.configProxy.peers + PeerProxy()
+                    )
+            )
+        }
+    }
+
+    fun removePeer(index: Int) {
+        _uiState.update { currentState ->
+            currentState.copy(
+                configProxy =
+                    currentState.configProxy.copy(
+                        peers =
+                            currentState.configProxy.peers.toMutableList().apply { removeAt(index) }
+                    )
+            )
+        }
+    }
+
+    fun updatePeer(index: Int, peer: PeerProxy) {
+        _uiState.update { currentState ->
+            currentState.copy(
+                configProxy =
+                    currentState.configProxy.copy(
+                        peers =
+                            currentState.configProxy.peers.toMutableList().apply {
+                                set(index, peer)
+                            }
+                    )
+            )
+        }
+    }
+
+    fun toggleLanExclusion(index: Int) {
+        val peer = _uiState.value.configProxy.peers[index]
+        val updated = if (peer.isLanExcluded()) peer.includeLan() else peer.excludeLan()
+        updatePeer(index, updated)
+    }
+
+    fun onAuthenticated() {
+        _uiState.update { it.copy(isAuthenticated = true) }
+    }
+
+    fun toggleShowAuthPrompt() {
+        _uiState.update { it.copy(showAuthPrompt = !it.showAuthPrompt) }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/components/AddPeerButton.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -12,14 +12,15 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.ConfigViewModel
 
 @Composable
-fun AddPeerButton(onClick: () -> Unit) {
+fun AddPeerButton(viewModel: ConfigViewModel) {
     Row(
         horizontalArrangement = Arrangement.Center,
         verticalAlignment = Alignment.CenterVertically,
         modifier = Modifier.fillMaxWidth().padding(bottom = 24.dp),
     ) {
-        TextButton(onClick = onClick) { Text(stringResource(R.string.add_peer)) }
+        TextButton(onClick = { viewModel.addPeer() }) { Text(stringResource(R.string.add_peer)) }
     }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/components/InterfaceDropdown.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components
 
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Column
@@ -24,16 +24,10 @@ fun InterfaceDropdown(
     onToggleScripts: () -> Unit,
     onToggleAmneziaValues: () -> Unit,
     onToggleAmneziaCompatibility: () -> Unit,
-    onMimicQuic: () -> Unit,
-    onMimicDns: () -> Unit,
-    onMimicSip: () -> Unit,
 ) {
     Column {
         IconButton(modifier = Modifier.size(iconSize), onClick = { onExpandedChange(true) }) {
-            Icon(
-                Icons.Rounded.MoreVert,
-                contentDescription = stringResource(R.string.quick_actions),
-            )
+            Icon(Icons.Rounded.MoreVert, contentDescription = "More")
         }
         DropdownMenu(
             expanded = expanded,
@@ -77,27 +71,6 @@ fun InterfaceDropdown(
                     onExpandedChange(false)
                 },
             )
-            DropdownMenuItem(
-                text = { Text(stringResource(R.string.mimic_quic)) },
-                onClick = {
-                    onMimicQuic()
-                    onExpandedChange(false)
-                },
-            )
-            DropdownMenuItem(
-                text = { Text(stringResource(R.string.mimic_dns)) },
-                onClick = {
-                    onMimicDns()
-                    onExpandedChange(false)
-                },
-            )
-            DropdownMenuItem(
-                text = { Text(stringResource(R.string.mimic_sip)) },
-                onClick = {
-                    onMimicSip()
-                    onExpandedChange(false)
-                },
-            )
         }
     }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/components/InterfaceFields.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components
 
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
@@ -18,7 +18,6 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.text.input.VisualTransformation
 import androidx.compose.ui.unit.dp
@@ -33,7 +32,7 @@ import java.util.*
 fun InterfaceFields(
     interfaceState: InterfaceProxy,
     showAuthPrompt: () -> Unit,
-    isAuthorized: Boolean,
+    isAuthenticated: Boolean,
     showScripts: Boolean,
     showAmneziaValues: Boolean,
     onInterfaceChange: (InterfaceProxy) -> Unit,
@@ -42,7 +41,6 @@ fun InterfaceFields(
     val clipboardManager = rememberClipboardHelper()
     val keyboardActions = KeyboardActions(onDone = { keyboardController?.hide() })
     val keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done)
-    val locale = Locale.getDefault()
 
     Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
         ConfigurationTextBox(
@@ -52,14 +50,14 @@ fun InterfaceFields(
                     .lowercase(Locale.getDefault()),
             onValueChange = { onInterfaceChange(interfaceState.copy(privateKey = it)) },
             label = stringResource(R.string.private_key),
-            modifier = Modifier.fillMaxWidth().clickable { if (!isAuthorized) showAuthPrompt() },
+            modifier = Modifier.fillMaxWidth().clickable { if (!isAuthenticated) showAuthPrompt() },
             visualTransformation =
-                if (isAuthorized) VisualTransformation.None else PasswordVisualTransformation(),
+                if (isAuthenticated) VisualTransformation.None else PasswordVisualTransformation(),
             trailing = {
                 IconButton(
                     enabled = true,
                     onClick = {
-                        if (!isAuthorized) return@IconButton showAuthPrompt()
+                        if (!isAuthenticated) return@IconButton showAuthPrompt()
                         val keypair = KeyPair()
                         onInterfaceChange(
                             interfaceState.copy(
@@ -73,12 +71,12 @@ fun InterfaceFields(
                         Icons.Rounded.Refresh,
                         stringResource(R.string.rotate_keys),
                         tint =
-                            if (isAuthorized) MaterialTheme.colorScheme.onSurface
+                            if (isAuthenticated) MaterialTheme.colorScheme.onSurface
                             else MaterialTheme.colorScheme.outline,
                     )
                 }
             },
-            enabled = isAuthorized,
+            enabled = isAuthenticated,
             singleLine = true,
             keyboardOptions = keyboardOptions,
             keyboardActions = keyboardActions,
@@ -110,10 +108,7 @@ fun InterfaceFields(
             onValueChange = { onInterfaceChange(interfaceState.copy(addresses = it)) },
             label = stringResource(R.string.addresses),
             hint =
-                stringResource(
-                        R.string.hint_template,
-                        stringResource(R.string.comma_separated).lowercase(locale),
-                    )
+                stringResource(R.string.hint_template, stringResource(R.string.comma_separated))
                     .lowercase(Locale.getDefault()),
             modifier = Modifier.fillMaxWidth(),
         )
@@ -123,7 +118,6 @@ fun InterfaceFields(
             label = stringResource(R.string.listen_port),
             hint = stringResource(R.string.random),
             modifier = Modifier.fillMaxWidth(),
-            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
         )
         Row(
             modifier = Modifier.fillMaxWidth(),
@@ -135,16 +129,15 @@ fun InterfaceFields(
                 label = stringResource(R.string.dns_servers),
                 hint =
                     stringResource(R.string.hint_template, stringResource(R.string.comma_separated))
-                        .lowercase(locale),
+                        .lowercase(Locale.getDefault()),
                 modifier = Modifier.weight(3f),
             )
             ConfigurationTextBox(
                 value = interfaceState.mtu,
                 onValueChange = { onInterfaceChange(interfaceState.copy(mtu = it)) },
                 label = stringResource(R.string.mtu),
-                hint = stringResource(R.string.auto).lowercase(locale),
+                hint = stringResource(R.string.auto).lowercase(Locale.getDefault()),
                 modifier = Modifier.weight(2f),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
             )
         }
         if (showScripts) {
@@ -152,44 +145,28 @@ fun InterfaceFields(
                 value = interfaceState.preUp,
                 onValueChange = { onInterfaceChange(interfaceState.copy(preUp = it)) },
                 label = stringResource(R.string.pre_up),
-                hint =
-                    stringResource(
-                        R.string.hint_template,
-                        stringResource(R.string.comma_separated).lowercase(locale),
-                    ),
+                hint = stringResource(R.string.hint_template, (R.string.comma_separated)),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
                 value = interfaceState.postUp,
                 onValueChange = { onInterfaceChange(interfaceState.copy(postUp = it)) },
                 label = stringResource(R.string.post_up),
-                hint =
-                    stringResource(
-                        R.string.hint_template,
-                        stringResource(R.string.comma_separated).lowercase(locale),
-                    ),
+                hint = stringResource(R.string.hint_template, (R.string.comma_separated)),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
                 value = interfaceState.preDown,
                 onValueChange = { onInterfaceChange(interfaceState.copy(preDown = it)) },
                 label = stringResource(R.string.pre_down),
-                hint =
-                    stringResource(
-                        R.string.hint_template,
-                        stringResource(R.string.comma_separated).lowercase(locale),
-                    ),
+                hint = stringResource(R.string.hint_template, (R.string.comma_separated)),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
                 value = interfaceState.postDown,
                 onValueChange = { onInterfaceChange(interfaceState.copy(postDown = it)) },
                 label = stringResource(R.string.post_down),
-                hint =
-                    stringResource(
-                        R.string.hint_template,
-                        stringResource(R.string.comma_separated).lowercase(locale),
-                    ),
+                hint = stringResource(R.string.hint_template, (R.string.comma_separated)),
                 modifier = Modifier.fillMaxWidth(),
             )
         }
@@ -198,32 +175,28 @@ fun InterfaceFields(
                 value = interfaceState.junkPacketCount,
                 onValueChange = { onInterfaceChange(interfaceState.copy(junkPacketCount = it)) },
                 label = stringResource(R.string.junk_packet_count),
-                hint = stringResource(R.string.range_hint, 1, 128),
+                hint = stringResource(R.string.hint_template, (R.string.comma_separated)),
                 modifier = Modifier.fillMaxWidth(),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
             )
             ConfigurationTextBox(
                 value = interfaceState.junkPacketMinSize,
                 onValueChange = { onInterfaceChange(interfaceState.copy(junkPacketMinSize = it)) },
                 label = stringResource(R.string.junk_packet_minimum_size),
-                hint = stringResource(R.string.range_hint, 1, 1279),
+                hint = stringResource(R.string.junk_packet_minimum_size).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
             )
             ConfigurationTextBox(
                 value = interfaceState.junkPacketMaxSize,
                 onValueChange = { onInterfaceChange(interfaceState.copy(junkPacketMaxSize = it)) },
                 label = stringResource(R.string.junk_packet_maximum_size),
-                hint = stringResource(R.string.range_hint, 2, 1280),
+                hint = stringResource(R.string.junk_packet_maximum_size).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
             )
             ConfigurationTextBox(
                 value = interfaceState.initPacketJunkSize,
                 onValueChange = { onInterfaceChange(interfaceState.copy(initPacketJunkSize = it)) },
                 label = stringResource(R.string.init_packet_junk_size),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                hint = stringResource(R.string.range_hint, 0, 64),
+                hint = stringResource(R.string.init_packet_junk_size).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
@@ -232,8 +205,7 @@ fun InterfaceFields(
                     onInterfaceChange(interfaceState.copy(responsePacketJunkSize = it))
                 },
                 label = stringResource(R.string.response_packet_junk_size),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                hint = stringResource(R.string.range_hint, 0, 64),
+                hint = stringResource(R.string.response_packet_junk_size).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
@@ -242,8 +214,7 @@ fun InterfaceFields(
                     onInterfaceChange(interfaceState.copy(initPacketMagicHeader = it))
                 },
                 label = stringResource(R.string.init_packet_magic_header),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                hint = stringResource(R.string.range_hint, 1, 4),
+                hint = stringResource(R.string.init_packet_magic_header).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
@@ -252,8 +223,7 @@ fun InterfaceFields(
                     onInterfaceChange(interfaceState.copy(responsePacketMagicHeader = it))
                 },
                 label = stringResource(R.string.response_packet_magic_header),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                hint = stringResource(R.string.range_hint, 1, 4),
+                hint = stringResource(R.string.response_packet_magic_header).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
@@ -262,8 +232,7 @@ fun InterfaceFields(
                     onInterfaceChange(interfaceState.copy(underloadPacketMagicHeader = it))
                 },
                 label = stringResource(R.string.underload_packet_magic_header),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                hint = stringResource(R.string.range_hint, 1, 4),
+                hint = stringResource(R.string.underload_packet_magic_header).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
             )
             ConfigurationTextBox(
@@ -272,76 +241,7 @@ fun InterfaceFields(
                     onInterfaceChange(interfaceState.copy(transportPacketMagicHeader = it))
                 },
                 label = stringResource(R.string.transport_packet_magic_header),
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                hint = stringResource(R.string.range_hint, 1, 4),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.i1,
-                onValueChange = { onInterfaceChange(interfaceState.copy(i1 = it)) },
-                label = "I1",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.i2,
-                onValueChange = { onInterfaceChange(interfaceState.copy(i2 = it)) },
-                label = "I2",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.i3,
-                onValueChange = { onInterfaceChange(interfaceState.copy(i3 = it)) },
-                label = "I3",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.i4,
-                onValueChange = { onInterfaceChange(interfaceState.copy(i4 = it)) },
-                label = "I4",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.i5,
-                onValueChange = { onInterfaceChange(interfaceState.copy(i5 = it)) },
-                label = "I5",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.j1,
-                onValueChange = { onInterfaceChange(interfaceState.copy(j1 = it)) },
-                label = "J1",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.j2,
-                onValueChange = { onInterfaceChange(interfaceState.copy(j2 = it)) },
-                label = "J2",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.j3,
-                onValueChange = { onInterfaceChange(interfaceState.copy(j3 = it)) },
-                label = "J3",
-                hint = stringResource(R.string.hint_template, "<b 0x1A2B3C>"),
-                modifier = Modifier.fillMaxWidth(),
-            )
-            ConfigurationTextBox(
-                value = interfaceState.itime,
-                onValueChange = { onInterfaceChange(interfaceState.copy(itime = it)) },
-                label = "ITime",
-                keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
-                hint =
-                    stringResource(
-                        R.string.hint_template,
-                        stringResource(R.string.seconds).lowercase(locale),
-                    ),
+                hint = stringResource(R.string.transport_packet_magic_header).lowercase(),
                 modifier = Modifier.fillMaxWidth(),
             )
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/components/InterfaceSection.kt

@@ -0,0 +1,74 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components
+
+import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.common.label.GroupLabel
+import com.zaneschepke.wireguardautotunnel.ui.common.textbox.ConfigurationTextBox
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.ConfigViewModel
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.state.ConfigUiState
+import java.util.*
+
+@Composable
+fun InterfaceSection(
+    isTunnelNameTaken: Boolean,
+    uiState: ConfigUiState,
+    viewModel: ConfigViewModel,
+) {
+    var isDropDownExpanded by remember { mutableStateOf(false) }
+    val isAmneziaCompatibilitySet =
+        remember(uiState.configProxy.`interface`) {
+            uiState.configProxy.`interface`.isAmneziaCompatibilityModeSet()
+        }
+
+    Surface(shape = RoundedCornerShape(12.dp), color = MaterialTheme.colorScheme.surface) {
+        Column(
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+            modifier = Modifier.padding(horizontal = 16.dp).focusGroup(),
+        ) {
+            Row(
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth(),
+            ) {
+                GroupLabel(stringResource(R.string.interface_))
+                InterfaceDropdown(
+                    expanded = isDropDownExpanded,
+                    onExpandedChange = { isDropDownExpanded = it },
+                    showScripts = uiState.showScripts,
+                    showAmneziaValues = uiState.showAmneziaValues,
+                    isAmneziaCompatibilitySet = isAmneziaCompatibilitySet,
+                    onToggleScripts = viewModel::toggleScripts,
+                    onToggleAmneziaValues = viewModel::toggleAmneziaValues,
+                    onToggleAmneziaCompatibility = viewModel::toggleAmneziaCompatibility,
+                )
+            }
+            ConfigurationTextBox(
+                value = uiState.tunnelName,
+                onValueChange = viewModel::updateTunnelName,
+                label = stringResource(R.string.name),
+                isError = isTunnelNameTaken,
+                hint =
+                    stringResource(R.string.hint_template, stringResource(R.string.tunnel_name))
+                        .lowercase(Locale.getDefault()),
+                modifier = Modifier.fillMaxWidth(),
+            )
+            InterfaceFields(
+                interfaceState = uiState.configProxy.`interface`,
+                showAuthPrompt = { viewModel.toggleShowAuthPrompt() },
+                showScripts = uiState.showScripts,
+                showAmneziaValues = uiState.showAmneziaValues,
+                onInterfaceChange = viewModel::updateInterface,
+                isAuthenticated = uiState.isAuthenticated,
+            )
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/components/PeerFields.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components
 
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.fillMaxWidth

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/components/PeersSection.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config.components
 
 import androidx.compose.foundation.background
 import androidx.compose.foundation.focusGroup
@@ -16,20 +16,13 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.common.label.GroupLabel
-import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
-import com.zaneschepke.wireguardautotunnel.ui.state.PeerProxy
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.ConfigViewModel
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.state.ConfigUiState
 import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
 
 @Composable
-fun PeersSection(
-    configProxy: ConfigProxy,
-    isAuthorized: Boolean,
-    onRemove: (index: Int) -> Unit,
-    onToggleLan: (index: Int) -> Unit,
-    onUpdatePeer: (PeerProxy, index: Int) -> Unit,
-    showAuth: () -> Unit,
-) {
-    configProxy.peers.forEachIndexed { index, peer ->
+fun PeersSection(uiState: ConfigUiState, viewModel: ConfigViewModel) {
+    uiState.configProxy.peers.forEachIndexed { index, peer ->
         var isDropDownExpanded by remember { mutableStateOf(false) }
 
         Surface(shape = RoundedCornerShape(12.dp), color = MaterialTheme.colorScheme.surface) {
@@ -49,7 +42,7 @@ fun PeersSection(
                     ) {
                         IconButton(
                             modifier = Modifier.size(iconSize),
-                            onClick = { onRemove(index) },
+                            onClick = { viewModel.removePeer(index) },
                         ) {
                             Icon(
                                 Icons.Rounded.Delete,
@@ -82,7 +75,7 @@ fun PeersSection(
                                         )
                                     },
                                     onClick = {
-                                        onToggleLan(index)
+                                        viewModel.toggleLanExclusion(index)
                                         isDropDownExpanded = false
                                     },
                                 )
@@ -92,9 +85,9 @@ fun PeersSection(
                 }
                 PeerFields(
                     peer = peer,
-                    onPeerChange = { onUpdatePeer(it, index) },
-                    showAuthPrompt = showAuth,
-                    isAuthenticated = isAuthorized,
+                    onPeerChange = { viewModel.updatePeer(index, it) },
+                    showAuthPrompt = { viewModel.toggleShowAuthPrompt() },
+                    isAuthenticated = uiState.isAuthenticated,
                 )
             }
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/config/state/ConfigUiState.kt

@@ -0,0 +1,16 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.config.state
+
+import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
+import com.zaneschepke.wireguardautotunnel.ui.state.InterfaceProxy
+import com.zaneschepke.wireguardautotunnel.ui.state.PeerProxy
+
+data class ConfigUiState(
+    val tunnelName: String = "",
+    val configProxy: ConfigProxy =
+        ConfigProxy(`interface` = InterfaceProxy(), peers = listOf(PeerProxy())),
+    val showAmneziaValues: Boolean = false,
+    val showScripts: Boolean = false,
+    val isAuthenticated: Boolean = true,
+    val showAuthPrompt: Boolean = false,
+    val saveChanges: Boolean = false,
+)

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/sort/SortScreen.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.sort
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.sort
 
 import androidx.compose.foundation.gestures.ScrollableDefaults
 import androidx.compose.foundation.layout.*
@@ -11,13 +11,9 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowDownward
 import androidx.compose.material.icons.filled.ArrowUpward
 import androidx.compose.material.icons.filled.DragHandle
-import androidx.compose.material.icons.rounded.Save
-import androidx.compose.material.icons.rounded.SortByAlpha
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
 import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
@@ -25,56 +21,58 @@ import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.ExpandingRowListItem
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.util.extensions.isSortedBy
-import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.UiEvent
 import sh.calvin.reorderable.DragGestureDetector
 import sh.calvin.reorderable.ReorderableItem
 import sh.calvin.reorderable.rememberReorderableLazyListState
 
 @Composable
-fun SortScreen(viewModel: TunnelsViewModel) {
-    val sharedViewModel = LocalSharedVm.current
-    val tunnelsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
+fun SortScreen(appUiState: AppUiState, viewModel: AppViewModel) {
+
     val hapticFeedback = LocalHapticFeedback.current
     val isTv = LocalIsAndroidTV.current
 
-    var sortAscending by rememberSaveable { mutableStateOf<Boolean?>(null) }
-    var editableTunnels by rememberSaveable { mutableStateOf(tunnelsState.tunnels) }
+    var sortAscending by remember { mutableStateOf<Boolean?>(null) }
+    var sortedTunnels by remember { mutableStateOf(appUiState.tunnels.sortedBy { it.position }) }
 
     LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.sort)) },
-                topTrailing = {
-                    Row {
-                        ActionIconButton(Icons.Rounded.SortByAlpha, R.string.sort) {
-                            sortAscending =
-                                when (sortAscending) {
-                                    null -> !editableTunnels.isSortedBy { it.name }
-                                    true -> false
-                                    false -> null
-                                }
-                            editableTunnels =
-                                when (sortAscending) {
-                                    true -> editableTunnels.sortedBy { it.name }
-                                    false -> editableTunnels.sortedByDescending { it.name }
-                                    null -> tunnelsState.tunnels
-                                }
+        viewModel.uiEvent.collect { uiEvent ->
+            when (uiEvent) {
+                UiEvent.SortTunnels -> {
+                    sortAscending =
+                        when (sortAscending) {
+                            null -> !sortedTunnels.isSortedBy { it.name }
+                            true -> false
+                            false -> null
                         }
-                        ActionIconButton(Icons.Rounded.Save, R.string.save) {
-                            viewModel.saveSortChanges(editableTunnels)
+                    sortedTunnels =
+                        when (sortAscending) {
+                            true -> sortedTunnels.sortedBy { it.name }
+                            false -> sortedTunnels.sortedByDescending { it.name }
+                            null -> sortedTunnels.sortedBy { it.position }
                         }
-                    }
-                },
-            )
+                }
+            }
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        viewModel.handleEvent(
+            AppEvent.SetScreenAction {
+                viewModel.handleEvent(
+                    AppEvent.SaveAllConfigs(
+                        sortedTunnels.mapIndexed { index, conf -> conf.copy(position = index) }
+                    )
+                )
+                viewModel.handleEvent(AppEvent.PopBackStack(true))
+            }
         )
     }
 
@@ -85,8 +83,8 @@ fun SortScreen(viewModel: TunnelsViewModel) {
             lazyListState,
             scrollThresholdPadding = WindowInsets.systemBars.asPaddingValues(),
         ) { from, to ->
-            editableTunnels =
-                editableTunnels.toMutableList().apply { add(to.index, removeAt(from.index)) }
+            sortedTunnels =
+                sortedTunnels.toMutableList().apply { add(to.index, removeAt(from.index)) }
             hapticFeedback.performHapticFeedback(HapticFeedbackType.SegmentFrequentTick)
         }
 
@@ -94,7 +92,7 @@ fun SortScreen(viewModel: TunnelsViewModel) {
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(5.dp, Alignment.Top),
         modifier =
-            Modifier.pointerInput(Unit) { if (tunnelsState.tunnels.isEmpty()) return@pointerInput }
+            Modifier.pointerInput(Unit) { if (appUiState.tunnels.isEmpty()) return@pointerInput }
                 .overscroll(rememberOverscrollEffect())
                 .padding(horizontal = 16.dp, vertical = 24.dp),
         state = lazyListState,
@@ -102,7 +100,7 @@ fun SortScreen(viewModel: TunnelsViewModel) {
         reverseLayout = false,
         flingBehavior = ScrollableDefaults.flingBehavior(),
     ) {
-        itemsIndexed(editableTunnels, key = { _, tunnel -> tunnel.id }) { index, tunnel ->
+        itemsIndexed(sortedTunnels, key = { _, tunnel -> tunnel.id }) { index, tunnel ->
             ReorderableItem(reorderableLazyListState, tunnel.id) { isDragging ->
                 ExpandingRowListItem(
                     leading = {},
@@ -119,8 +117,8 @@ fun SortScreen(viewModel: TunnelsViewModel) {
                             Row {
                                 IconButton(
                                     onClick = {
-                                        editableTunnels =
-                                            editableTunnels.toMutableList().apply {
+                                        sortedTunnels =
+                                            sortedTunnels.toMutableList().apply {
                                                 add(index - 1, removeAt(index))
                                             }
                                     },
@@ -135,12 +133,12 @@ fun SortScreen(viewModel: TunnelsViewModel) {
                                 }
                                 IconButton(
                                     onClick = {
-                                        editableTunnels =
-                                            editableTunnels.toMutableList().apply {
+                                        sortedTunnels =
+                                            sortedTunnels.toMutableList().apply {
                                                 add(index + 1, removeAt(index))
                                             }
                                     },
-                                    enabled = index != editableTunnels.size - 1,
+                                    enabled = index != sortedTunnels.count() - 1,
                                 ) {
                                     Icon(
                                         Icons.Default.ArrowDownward,

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/SplitTunnelScreen.kt

@@ -0,0 +1,52 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.components.SplitTunnelContent
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+
+@Composable
+fun SplitTunnelScreen(
+    appViewModel: AppViewModel,
+    viewModel: SplitTunnelViewModel = hiltViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    LaunchedEffect(Unit) {
+        appViewModel.handleEvent(AppEvent.SetScreenAction { viewModel.saveChanges() })
+    }
+
+    LaunchedEffect(uiState.success) {
+        if (uiState.success == true) {
+            appViewModel.handleEvent(
+                AppEvent.ShowMessage(StringValue.StringResource(R.string.config_changes_saved))
+            )
+            appViewModel.handleEvent(AppEvent.PopBackStack(true))
+        }
+    }
+    if (uiState.loading) {
+        Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+            CircularProgressIndicator(modifier = Modifier.size(30.dp), strokeWidth = 5.dp)
+        }
+    } else {
+        SplitTunnelContent(
+            uiState = uiState,
+            onSplitOptionChange = viewModel::updateSplitOption,
+            onAppSelectionToggle = viewModel::toggleAppSelection,
+            onQueryChange = viewModel::onSearchQuery,
+        )
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/SplitTunnelViewModel.kt

@@ -0,0 +1,180 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel
+
+import android.content.Context
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
+import com.zaneschepke.wireguardautotunnel.ui.Route
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.SplitOption
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.SplitTunnelUiState
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.TunnelApp
+import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
+import com.zaneschepke.wireguardautotunnel.ui.state.InterfaceProxy
+import com.zaneschepke.wireguardautotunnel.util.extensions.getAllInternetCapablePackages
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.text.Collator
+import java.util.*
+import javax.inject.Inject
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+
+@HiltViewModel
+class SplitTunnelViewModel
+@Inject
+constructor(
+    @ApplicationContext private val context: Context,
+    private val tunnelRepository: TunnelRepository,
+    savedStateHandle: SavedStateHandle,
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(SplitTunnelUiState())
+    val uiState: StateFlow<SplitTunnelUiState> =
+        _uiState.stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5000L),
+            initialValue = SplitTunnelUiState(),
+        )
+
+    private val tunnelId: Int? = savedStateHandle.get<Int>(Route.SplitTunnel.KEY_ID)
+    private var allTunneledApps: List<Pair<TunnelApp, Boolean>> = emptyList()
+
+    init {
+        tunnelId?.let { loadInitialState(it) }
+    }
+
+    private fun loadInitialState(tunnelId: Int) =
+        viewModelScope.launch {
+            val tunnel = tunnelRepository.getById(tunnelId) ?: return@launch
+            val proxyInterface = InterfaceProxy.from(tunnel.toAmConfig().`interface`)
+            val splitOption =
+                when {
+                    proxyInterface.excludedApplications.isNotEmpty() -> SplitOption.EXCLUDE
+                    proxyInterface.includedApplications.isNotEmpty() -> SplitOption.INCLUDE
+                    else -> SplitOption.ALL
+                }
+
+            val packages = context.getAllInternetCapablePackages()
+
+            val installedPackages = packages.map { it.packageName }.toSet()
+
+            // Remove uninstalled apps
+            proxyInterface.includedApplications.retainAll { it in installedPackages }
+            proxyInterface.excludedApplications.retainAll { it in installedPackages }
+
+            var configProxy = ConfigProxy.from(tunnel.toAmConfig())
+            configProxy = configProxy.copy(`interface` = proxyInterface)
+            saveProxyConfig(configProxy, tunnel)
+
+            val collator = Collator.getInstance(Locale.getDefault())
+            val tunneledApps =
+                packages
+                    .filter { it.applicationInfo != null }
+                    .map { pack ->
+                        val selected =
+                            when (splitOption) {
+                                SplitOption.INCLUDE ->
+                                    proxyInterface.includedApplications.contains(pack.packageName)
+                                SplitOption.ALL -> false
+                                SplitOption.EXCLUDE ->
+                                    proxyInterface.excludedApplications.contains(pack.packageName)
+                            }
+                        Pair(
+                            TunnelApp(
+                                name =
+                                    context.packageManager
+                                        .getApplicationLabel(pack.applicationInfo!!)
+                                        .toString(),
+                                `package` = pack.packageName,
+                            ),
+                            selected,
+                        )
+                    }
+                    .sortedWith(
+                        compareByDescending<Pair<TunnelApp, Boolean>> { it.second }
+                            .thenBy(collator) { it.first.name }
+                    )
+
+            allTunneledApps = tunneledApps
+
+            _uiState.update {
+                SplitTunnelUiState(
+                    loading = false,
+                    tunnelConf = tunnel,
+                    tunneledApps = tunneledApps,
+                    queriedApps = tunneledApps,
+                    splitOption = splitOption,
+                )
+            }
+        }
+
+    fun onSearchQuery(query: String) {
+        val filteredApps =
+            if (query.isBlank()) {
+                _uiState.value.tunneledApps
+            } else {
+                _uiState.value.tunneledApps.filter {
+                    it.first.name.contains(query, ignoreCase = true) ||
+                        it.first.`package`.contains(query, ignoreCase = true)
+                }
+            }
+        _uiState.update { it.copy(searchQuery = query, queriedApps = filteredApps) }
+    }
+
+    fun updateSplitOption(newOption: SplitOption) {
+        _uiState.value = _uiState.value.copy(splitOption = newOption)
+    }
+
+    fun toggleAppSelection(packageName: String) {
+        val currentState = _uiState.value
+        val updatedApps =
+            currentState.tunneledApps.map { (app, selected) ->
+                if (app.`package` == packageName) Pair(app, !selected) else Pair(app, selected)
+            }
+        val updatedQueryApps =
+            currentState.queriedApps.map { (app, selected) ->
+                if (app.`package` == packageName) Pair(app, !selected) else Pair(app, selected)
+            }
+        _uiState.value =
+            currentState.copy(tunneledApps = updatedApps, queriedApps = updatedQueryApps)
+    }
+
+    fun saveChanges() =
+        viewModelScope.launch {
+            val state = _uiState.value
+            val tunnel = state.tunnelConf ?: return@launch
+            val configProxy = ConfigProxy.from(tunnel.toAmConfig())
+            val updatedApps = state.tunneledApps
+            with(configProxy.`interface`) {
+                includedApplications.clear()
+                excludedApplications.clear()
+                when (state.splitOption) {
+                    SplitOption.INCLUDE -> {
+                        includedApplications.addAll(
+                            updatedApps.filter { it.second }.map { it.first.`package` }
+                        )
+                    }
+                    SplitOption.EXCLUDE -> {
+                        excludedApplications.addAll(
+                            updatedApps.filter { it.second }.map { it.first.`package` }
+                        )
+                    }
+                    SplitOption.ALL -> Unit
+                }
+            }
+            saveProxyConfig(configProxy, tunnel)
+            _uiState.update { it.copy(success = true) }
+        }
+
+    private suspend fun saveProxyConfig(proxy: ConfigProxy, tunnel: TunnelConf) {
+        val (wg, am) = proxy.buildConfigs()
+        tunnelRepository.save(
+            tunnel.copyWithCallback(
+                amQuick = am.toAwgQuickString(true, false),
+                wgQuick = wg.toWgQuickString(true),
+            )
+        )
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/components/AppListItem.kt

@@ -0,0 +1,50 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.components
+
+import android.content.pm.PackageManager
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.Checkbox
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.google.accompanist.drawablepainter.rememberDrawablePainter
+import com.zaneschepke.wireguardautotunnel.ui.common.button.SelectionItemButton
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.TunnelApp
+import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+
+@Composable
+fun AppListItem(appInfo: TunnelApp, isSelected: Boolean, onToggle: () -> Unit) {
+    val context = LocalContext.current
+    val icon =
+        remember(appInfo.`package`) {
+            try {
+                context.packageManager.getApplicationIcon(appInfo.`package`)
+            } catch (e: PackageManager.NameNotFoundException) {
+                null
+            }
+        }
+
+    SelectionItemButton(
+        leading = {
+            Image(
+                painter = rememberDrawablePainter(icon),
+                contentDescription = appInfo.name,
+                modifier = Modifier.padding(horizontal = 24.dp).size(iconSize),
+            )
+        },
+        buttonText = appInfo.name,
+        onClick = onToggle,
+        trailing = {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.End,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Checkbox(checked = isSelected, onCheckedChange = { onToggle() })
+            }
+        },
+    )
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/components/AppListSection.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.components
 
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
@@ -10,7 +10,8 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Search
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
@@ -18,32 +19,16 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.domain.model.InstalledPackage
 import com.zaneschepke.wireguardautotunnel.ui.common.textbox.CustomTextField
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.state.SplitOption
-import java.util.*
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.TunnelApp
 
 @Composable
 fun AppListSection(
-    splitConfig: Pair<SplitOption, Set<String>>,
-    installedPackages: List<InstalledPackage>,
-    onAppSelectionToggle: (String, Boolean) -> Unit,
+    apps: List<Pair<TunnelApp, Boolean>>,
+    onAppSelectionToggle: (String) -> Unit,
+    onQueryChange: (String) -> Unit,
+    query: String,
 ) {
-
-    var query by remember { mutableStateOf("") }
-
-    val filteredAndSortedPackages by remember {
-        derivedStateOf {
-            installedPackages
-                .filter { pkg ->
-                    query.isBlank() ||
-                        pkg.name.contains(query, ignoreCase = true) ||
-                        pkg.packageName.contains(query, ignoreCase = true)
-                }
-                .sortedBy { pkg -> pkg.name.lowercase(Locale.getDefault()) }
-        }
-    }
-
     val inputHeight = 45.dp
 
     Column(
@@ -57,7 +42,7 @@ fun AppListSection(
                     color = MaterialTheme.colorScheme.onBackground
                 ),
             value = query,
-            onValueChange = { query = it },
+            onValueChange = onQueryChange,
             interactionSource = remember { MutableInteractionSource() },
             label = {},
             leading = { Icon(Icons.Outlined.Search, stringResource(R.string.search)) },
@@ -73,15 +58,14 @@ fun AppListSection(
         )
         LazyColumn(
             horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),
-            contentPadding = PaddingValues(top = 24.dp),
+            verticalArrangement = Arrangement.Top,
+            contentPadding = PaddingValues(top = 10.dp),
         ) {
-            items(filteredAndSortedPackages, key = { it.packageName }) { pkg ->
-                val selected = splitConfig.second.contains(pkg.packageName)
+            items(apps, key = { it.first.`package` }) { app ->
                 AppListItem(
-                    installedPackage = pkg,
-                    isSelected = selected,
-                    onToggle = { onAppSelectionToggle(pkg.packageName, it) },
+                    appInfo = app.first,
+                    isSelected = app.second,
+                    onToggle = { onAppSelectionToggle(app.first.`package`) },
                 )
             }
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/components/SplitOptionsSelector.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.components
 
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -15,7 +15,7 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.state.SplitOption
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.SplitOption
 import java.util.*
 
 @Composable

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/components/SplitTunnelContent.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.components
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
@@ -8,15 +8,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.domain.model.InstalledPackage
-import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.state.SplitOption
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.SplitOption
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state.SplitTunnelUiState
 
 @Composable
 fun SplitTunnelContent(
-    splitConfig: Pair<SplitOption, Set<String>>,
-    installedPackages: List<InstalledPackage>,
+    uiState: SplitTunnelUiState,
     onSplitOptionChange: (SplitOption) -> Unit,
-    onAppSelectionToggle: (String, Boolean) -> Unit,
+    onAppSelectionToggle: (String) -> Unit,
+    onQueryChange: (String) -> Unit,
 ) {
     Column(
         verticalArrangement = Arrangement.spacedBy(24.dp, Alignment.CenterVertically),
@@ -24,14 +24,15 @@ fun SplitTunnelContent(
         modifier = Modifier.fillMaxWidth().padding(top = 24.dp),
     ) {
         SplitOptionSelector(
-            selectedOption = splitConfig.first,
+            selectedOption = uiState.splitOption,
             onOptionChange = onSplitOptionChange,
         )
-        if (splitConfig.first != SplitOption.ALL) {
+        if (uiState.splitOption != SplitOption.ALL) {
             AppListSection(
-                installedPackages = installedPackages,
+                apps = uiState.queriedApps,
                 onAppSelectionToggle = onAppSelectionToggle,
-                splitConfig = splitConfig,
+                onQueryChange = onQueryChange,
+                uiState.searchQuery,
             )
         }
     }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/state/SplitOption.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.state
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/state/SplitTunnelUiState.kt

@@ -0,0 +1,13 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state
+
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+
+data class SplitTunnelUiState(
+    val loading: Boolean = true,
+    val tunnelConf: TunnelConf? = null,
+    val tunneledApps: SplitTunnelApps = emptyList(),
+    val queriedApps: SplitTunnelApps = emptyList(),
+    val splitOption: SplitOption = SplitOption.ALL,
+    val searchQuery: String = "",
+    val success: Boolean? = null,
+)

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/splittunnel/state/TunnelApp.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.state
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.state
 
 data class TunnelApp(val name: String, val `package`: String)
 

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/tunneloptions/TunnelOptionsScreen.kt

@@ -0,0 +1,85 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.tunneloptions
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
+import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.tunneloptions.components.*
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.AuthorizationPromptWrapper
+import com.zaneschepke.wireguardautotunnel.ui.state.AppViewState
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+
+@Composable
+fun TunnelOptionsScreen(
+    tunnelConf: TunnelConf,
+    viewModel: AppViewModel,
+    appViewState: AppViewState,
+    appSettings: AppSettings,
+) {
+    val isTv = LocalIsAndroidTV.current
+
+    var showAuthPrompt by remember { mutableStateOf(!isTv) }
+    var isAuthorized by remember { mutableStateOf(isTv) }
+
+    if (appViewState.showModal == AppViewState.ModalType.QR) {
+
+        // Show authorization prompt if needed
+        if (showAuthPrompt) {
+            AuthorizationPromptWrapper(
+                onDismiss = {
+                    showAuthPrompt = false
+                    viewModel.handleEvent(AppEvent.SetShowModal(AppViewState.ModalType.NONE))
+                },
+                onSuccess = {
+                    showAuthPrompt = false
+                    isAuthorized = true
+                },
+                viewModel = viewModel,
+            )
+        }
+        if (isAuthorized) {
+            QrCodeDialog(
+                tunnelConf = tunnelConf,
+                onDismiss = {
+                    viewModel.handleEvent(AppEvent.SetShowModal(AppViewState.ModalType.NONE))
+                },
+            )
+        }
+    }
+
+    Column(
+        horizontalAlignment = Alignment.Start,
+        verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),
+        modifier =
+            Modifier.fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(top = 24.dp)
+                .padding(horizontal = 12.dp),
+    ) {
+        SurfaceSelectionGroupButton(
+            items =
+                listOf(
+                    PrimaryTunnelItem(tunnelConf, viewModel),
+                    AutoTunnelingItem(tunnelConf),
+                    serverIpv4Item(tunnelConf, viewModel),
+                    SplitTunnelingItem(tunnelConf),
+                )
+        )
+        if (appSettings.isPingEnabled) {
+            SectionDivider()
+            SurfaceSelectionGroupButton(items = listOf(pingConfigItem(tunnelConf, viewModel)))
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/main/tunneloptions/components/AutoTunnelingItem.kt

@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.tunneloptions.components
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.tunneloptions.components
 
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Bolt
@@ -7,15 +7,16 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
-import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
 
 @Composable
-fun AutoTunnelingItem(tunnelConf: TunnelConf, navController: NavController): SelectionItem {
+fun AutoTunnelingItem(tunnelConf: TunnelConf): SelectionItem {
+    val navController = LocalNavController.current
     return SelectionItem(
         leading = { Icon(Icons.Outlined.Bolt, contentDescription = null) },
         title = {