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

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

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

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

app/build.gradle.kts

@@ -201,7 +201,6 @@ dependencies {
     implementation(libs.material.icons.core)
     implementation(libs.material.icons.extended)
 
-    implementation(libs.androidx.biometric.ktx)
     implementation(libs.pin.lock.compose)
 
     implementation(libs.androidx.core)

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/src/main/AndroidManifest.xml

@@ -5,10 +5,11 @@
 	<uses-permission android:name="android.permission.INTERNET" />
 	<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
-    <!--foreground service exempt android 14-->
+    <!--foreground service special use for non VPN service tunnels, android 14-->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
+    <!--foreground service special use for VPN service tunnels, android 14-->
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED" />
-    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"
-		tools:ignore="ProtectedPermissions" />
 
     <!--foreground service permissions-->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
@@ -151,21 +152,45 @@
             android:name=".core.service.autotunnel.AutoTunnelService"
             android:enabled="true"
             android:exported="false"
-            android:foregroundServiceType="systemExempted"
+            android:foregroundServiceType="specialUse"
             android:persistent="true"
             android:stopWithTask="false"
-            tools:node="merge" />
+            tools:node="merge">
+            <property android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                      android:value="This service monitors network changes to automatically
+                      establish and maintain WireGuard VPN tunnels on demand, ensuring seamless connectivity.
+                      It requires persistent foreground execution to detect real-time events,
+                      which cannot be achieved with standard background APIs due to timing and reliability needs for
+                      network connectivity monitoring."/>
+        </service>
+
+        <service
+                android:name=".core.service.TunnelForegroundService"
+                android:enabled="true"
+                android:exported="false"
+                android:foregroundServiceType="specialUse"
+                android:persistent="true"
+                android:stopWithTask="false"
+                tools:node="merge">
+            <property android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
+                      android:value="This service sustains non-VpnService virtual tunnels (using gVisor/netstack for
+                      isolated networking), keeping connections alive for continuous secure data routing.
+                      Persistent foreground operation is essential to handle
+                      low-level tunnel maintenance and avoid interruptions, beyond the capabilities of other
+                      service types or background work."/>
+        </service>
 
 		<service
-			android:name=".core.service.TunnelForegroundService"
+			android:name=".core.service.VpnForegroundService"
 			android:exported="false"
 			android:persistent="true"
-			android:foregroundServiceType="systemExempted"
+            android:foregroundServiceType="systemExempted"
 			android:permission="android.permission.BIND_VPN_SERVICE">
 			<intent-filter>
 				<action android:name="android.net.VpnService" />
 			</intent-filter>
 		</service>
+
         <receiver
             android:name=".core.broadcast.RestartReceiver"
             android:enabled="true"

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

@@ -17,10 +17,12 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
 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.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -50,6 +52,7 @@ import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.CustomSnackBar
 import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
 import com.zaneschepke.wireguardautotunnel.ui.navigation.components.BottomNavbar
 import com.zaneschepke.wireguardautotunnel.ui.navigation.components.DynamicTopAppBar
+import com.zaneschepke.wireguardautotunnel.ui.navigation.components.currentBackStackEntryAsNavbarState
 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
@@ -64,6 +67,8 @@ 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.system.SystemFeaturesScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.DonateScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.crypto.AddressesScreen
 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
@@ -82,6 +87,7 @@ import de.raphaelebner.roomdatabasebackup.core.RoomBackup
 import java.util.*
 import javax.inject.Inject
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import xyz.teamgravity.pin_lock_compose.PinManager
 
 @AndroidEntryPoint
@@ -132,6 +138,8 @@ class MainActivity : AppCompatActivity() {
                 }
             }
 
+            val navState by
+                navController.currentBackStackEntryAsNavbarState(viewModel, navController)
             val snackbar = remember { SnackbarHostState() }
             var showVpnPermissionDialog by remember { mutableStateOf(false) }
             var vpnPermissionDenied by remember { mutableStateOf(false) }
@@ -139,6 +147,8 @@ class MainActivity : AppCompatActivity() {
                 mutableStateOf<Pair<AppMode?, TunnelConf?>>(Pair(null, null))
             }
 
+            LaunchedEffect(navState) { Timber.d("New navbar state $navState") }
+
             val vpnActivity =
                 rememberLauncherForActivityResult(
                     ActivityResultContracts.StartActivityForResult(),
@@ -237,14 +247,14 @@ class MainActivity : AppCompatActivity() {
                                     )
                                 }
                             },
-                            topBar = { DynamicTopAppBar(appState.navBarState) },
+                            topBar = { DynamicTopAppBar(navState) },
                             bottomBar = {
-                                BottomNavbar(
-                                    appState.isAutoTunnelActive,
-                                    appState.navBarState,
-                                    navController,
-                                )
+                                BottomNavbar(appState.isAutoTunnelActive, navState, navController)
                             },
+                            modifier =
+                                Modifier.pointerInput(Unit) {
+                                    detectTapGestures { viewModel.clearSelectedTunnels() }
+                                },
                         ) { padding ->
                             Box(
                                 modifier =
@@ -380,6 +390,8 @@ class MainActivity : AppCompatActivity() {
                                             SupportScreen(viewModel)
                                         }
                                         composable<Route.License> { LicenseScreen() }
+                                        composable<Route.Donate> { DonateScreen(navController) }
+                                        composable<Route.Addresses> { AddressesScreen() }
                                     }
                                 }
                             }

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

@@ -5,7 +5,6 @@ import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
 import androidx.hilt.work.HiltWorkerFactory
 import androidx.work.Configuration
-import com.wireguard.android.backend.GoBackend
 import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationMonitor
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
@@ -25,6 +24,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.GoBackend
 import timber.log.Timber
 
 @HiltAndroidApp

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/broadcast/NotificationActionReceiver.kt

@@ -31,9 +31,9 @@ class NotificationActionReceiver : BroadcastReceiver() {
                 NotificationAction.AUTO_TUNNEL_OFF.name -> serviceManager.stopAutoTunnel()
                 NotificationAction.TUNNEL_OFF.name -> {
                     val tunnelId = intent.getIntExtra(NotificationManager.EXTRA_ID, 0)
-                    if (tunnelId == STOP_ALL_TUNNELS_ID) return@launch tunnelManager.stopTunnel()
-                    val tunnel = tunnelRepository.getById(tunnelId)
-                    tunnelManager.stopTunnel(tunnel)
+                    if (tunnelId == STOP_ALL_TUNNELS_ID)
+                        return@launch tunnelManager.stopActiveTunnels()
+                    tunnelRepository.getById(tunnelId)?.let { tunnelManager.stopTunnel(it.id) }
                 }
             }
         }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/broadcast/RemoteControlReceiver.kt

@@ -71,11 +71,11 @@ class RemoteControlReceiver : BroadcastReceiver() {
                 Action.STOP_TUNNEL -> {
                     val tunnelName =
                         intent.getStringExtra(EXTRA_TUN_NAME)
-                            ?: return@launch tunnelManager.stopTunnel()
+                            ?: return@launch tunnelManager.stopActiveTunnels()
                     val tunnel =
                         appDataRepository.tunnels.findByTunnelName(tunnelName)
-                            ?: return@launch tunnelManager.stopTunnel()
-                    tunnelManager.stopTunnel(tunnel)
+                            ?: return@launch tunnelManager.stopActiveTunnels()
+                    tunnelManager.stopTunnel(tunnel.id)
                 }
                 Action.START_AUTO_TUNNEL -> serviceManager.startAutoTunnel()
                 Action.STOP_AUTO_TUNNEL -> serviceManager.stopAutoTunnel()

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

@@ -22,12 +22,12 @@ constructor(
     }
 
     private suspend fun handleTunnelErrors() =
-        tunnelManager.errorEvents.collectLatest { (tunnelConf, error) ->
+        tunnelManager.errorEvents.collectLatest { (tunName, error) ->
             if (!WireGuardAutoTunnel.uiActive.value) {
                 val notification =
                     notificationManager.createNotification(
                         WireGuardNotification.NotificationChannels.VPN,
-                        title = StringValue.DynamicString(tunnelConf.name),
+                        title = StringValue.DynamicString(tunName),
                         description =
                             when (error) {
                                 is BackendCoreException.BounceFailed -> error.toStringValue()
@@ -46,12 +46,12 @@ constructor(
         }
 
     private suspend fun handleTunnelMessages() =
-        tunnelManager.messageEvents.collectLatest { (tunnelConf, message) ->
+        tunnelManager.messageEvents.collectLatest { (tunName, message) ->
             if (!WireGuardAutoTunnel.uiActive.value) {
                 val notification =
                     notificationManager.createNotification(
                         WireGuardNotification.NotificationChannels.VPN,
-                        title = StringValue.DynamicString(tunnelConf.name),
+                        title = StringValue.DynamicString(tunName),
                         description = message.toStringValue(),
                     )
                 notificationManager.show(

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

@@ -0,0 +1,153 @@
+package com.zaneschepke.wireguardautotunnel.core.service
+
+import android.app.Notification
+import android.content.Intent
+import android.os.IBinder
+import androidx.core.app.ServiceCompat
+import androidx.lifecycle.LifecycleService
+import androidx.lifecycle.lifecycleScope
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
+import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor
+import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.util.extensions.distinctByKeys
+import dagger.hilt.android.AndroidEntryPoint
+import io.ktor.util.collections.*
+import javax.inject.Inject
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import timber.log.Timber
+
+@AndroidEntryPoint
+abstract class BaseTunnelForegroundService : LifecycleService(), TunnelService {
+
+    @Inject lateinit var notificationManager: NotificationManager
+
+    @Inject lateinit var serviceManager: ServiceManager
+
+    @Inject lateinit var tunnelManager: TunnelManager
+
+    @Inject lateinit var tunnelMonitor: TunnelMonitor
+
+    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
+
+    @Inject lateinit var appDataRepository: AppDataRepository
+
+    private val tunnelJobs = ConcurrentMap<Int, Job>()
+
+    protected abstract val fgsType: Int
+
+    override fun onBind(intent: Intent): IBinder {
+        super.onBind(intent)
+        return LocalBinder(this)
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        ServiceCompat.startForeground(
+            this,
+            NotificationManager.VPN_NOTIFICATION_ID,
+            onCreateNotification(),
+            fgsType,
+        )
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        super.onStartCommand(intent, flags, startId)
+        ServiceCompat.startForeground(
+            this,
+            NotificationManager.VPN_NOTIFICATION_ID,
+            onCreateNotification(),
+            fgsType,
+        )
+        start()
+        return START_STICKY
+    }
+
+    override fun start() {
+        lifecycleScope.launch(ioDispatcher) {
+            tunnelManager.activeTunnels.distinctByKeys().collect { activeTunnels ->
+                val activeTunConfigs = activeTunnels.keys
+                val obsoleteJobs = tunnelJobs.keys - activeTunConfigs
+                obsoleteJobs.forEach { tunId -> tunnelJobs[tunId]?.cancel() }
+                activeTunConfigs.forEach { tunId ->
+                    if (tunnelJobs.contains(tunId)) return@forEach
+                    tunnelJobs[tunId] = launch { tunnelMonitor.startMonitoring(tunId, true) }
+                }
+                val tunnels = appDataRepository.tunnels.getAll()
+                val activeConfigs = tunnels.filter { activeTunConfigs.contains(it.id) }
+                updateServiceNotification(activeConfigs)
+            }
+        }
+    }
+
+    // TODO Would be cool to have this include kill switch
+    private fun updateServiceNotification(activeConfigs: List<TunnelConf>) {
+        val notification =
+            when (activeConfigs.size) {
+                0 -> onCreateNotification()
+                1 -> createTunnelNotification(activeConfigs.first())
+                else -> createTunnelsNotification()
+            }
+        ServiceCompat.startForeground(
+            this,
+            NotificationManager.VPN_NOTIFICATION_ID,
+            notification,
+            fgsType,
+        )
+    }
+
+    override fun stop() {
+        Timber.d("Stop called")
+        tunnelJobs.forEach { it.value.cancel() }
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        stopSelf()
+    }
+
+    override fun onDestroy() {
+        tunnelJobs.forEach { it.value.cancel() }
+        serviceManager.handleTunnelServiceDestroy()
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        Timber.d("onDestroy")
+        super.onDestroy()
+    }
+
+    private fun createTunnelNotification(tunnelConf: TunnelConf): Notification {
+        return notificationManager.createNotification(
+            WireGuardNotification.NotificationChannels.VPN,
+            title = "${getString(R.string.tunnel_running)} - ${tunnelConf.tunName}",
+            actions =
+                listOf(
+                    notificationManager.createNotificationAction(
+                        NotificationAction.TUNNEL_OFF,
+                        tunnelConf.id,
+                    )
+                ),
+            onGoing = true,
+        )
+    }
+
+    private fun createTunnelsNotification(): Notification {
+        return notificationManager.createNotification(
+            WireGuardNotification.NotificationChannels.VPN,
+            title = "${getString(R.string.tunnel_running)} - ${getString(R.string.multiple)}",
+            actions =
+                listOf(
+                    notificationManager.createNotificationAction(NotificationAction.TUNNEL_OFF, 0)
+                ),
+        )
+    }
+
+    private fun onCreateNotification(): Notification {
+        return notificationManager.createNotification(
+            WireGuardNotification.NotificationChannels.VPN,
+            title = getString(R.string.tunnel_starting),
+        )
+    }
+}

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

@@ -0,0 +1,5 @@
+package com.zaneschepke.wireguardautotunnel.core.service
+
+import android.os.Binder
+
+class LocalBinder(val service: TunnelService) : Binder()

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

@@ -7,15 +7,16 @@ import android.content.ServiceConnection
 import android.net.VpnService
 import android.os.IBinder
 import com.zaneschepke.wireguardautotunnel.core.service.autotunnel.AutoTunnelService
+import com.zaneschepke.wireguardautotunnel.data.model.AppMode
+import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.util.extensions.requestAutoTunnelTileServiceUpdate
 import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
 import jakarta.inject.Inject
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -26,29 +27,45 @@ class ServiceManager
 @Inject
 constructor(
     private val context: Context,
-    private val ioDispatcher: CoroutineDispatcher,
-    private val applicationScope: CoroutineScope,
+    @IoDispatcher ioDispatcher: CoroutineDispatcher,
+    @ApplicationScope applicationScope: CoroutineScope,
     private val mainDispatcher: CoroutineDispatcher,
     private val appDataRepository: AppDataRepository,
 ) {
 
     private val autoTunnelMutex = Mutex()
+    private val tunnelMutex = Mutex()
 
-    private val _tunnelService = MutableStateFlow<TunnelForegroundService?>(null)
+    private val _tunnelService = MutableStateFlow<TunnelService?>(null)
     private val _autoTunnelService = MutableStateFlow<AutoTunnelService?>(null)
     val autoTunnelService = _autoTunnelService.asStateFlow()
+    val tunnelService = _tunnelService.asStateFlow()
 
     private val tunnelServiceConnection =
         object : ServiceConnection {
             override fun onServiceConnected(name: ComponentName, service: IBinder) {
-                val binder = service as? TunnelForegroundService.LocalBinder
+                val binder = service as? LocalBinder
                 _tunnelService.value = binder?.service
-                Timber.d("TunnelForegroundService connected")
+                val serviceClass =
+                    when {
+                        name.className.contains("VpnForegroundService") -> "VpnForegroundService"
+                        name.className.contains("TunnelForegroundService") ->
+                            "TunnelForegroundService"
+                        else -> "Unknown"
+                    }
+                Timber.d("$serviceClass connected")
             }
 
             override fun onServiceDisconnected(name: ComponentName) {
                 _tunnelService.value = null
-                Timber.d("TunnelForegroundService disconnected")
+                val serviceClass =
+                    when {
+                        name.className.contains("VpnForegroundService") -> "VpnForegroundService"
+                        name.className.contains("TunnelForegroundService") ->
+                            "TunnelForegroundService"
+                        else -> "Unknown"
+                    }
+                Timber.d("$serviceClass disconnected")
             }
         }
 
@@ -66,72 +83,74 @@ constructor(
             }
         }
 
+    init {
+        // Observe changes to the AutoTunnelService and trigger side effects
+        applicationScope.launch(ioDispatcher) {
+            _autoTunnelService
+                .onEach { service ->
+                    withContext(mainDispatcher) { updateAutoTunnelTile() }
+                    if (service == null) {
+                        // The service is disconnected, update the DB state
+                        val settings = appDataRepository.settings.get()
+                        appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = false))
+                    }
+                }
+                .launchIn(this)
+        }
+    }
+
     fun hasVpnPermission(): Boolean {
         return VpnService.prepare(context) == null
     }
 
     suspend fun startAutoTunnel() {
         autoTunnelMutex.withLock {
-            val settings = appDataRepository.settings.get()
-            appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = true))
             if (_autoTunnelService.value != null) return
-            withContext(ioDispatcher) {
-                val intent = Intent(context, AutoTunnelService::class.java)
-                context.startForegroundService(intent)
-                context.bindService(intent, autoTunnelServiceConnection, Context.BIND_AUTO_CREATE)
-                withContext(mainDispatcher) { updateAutoTunnelTile() }
-            }
+            val intent = Intent(context, AutoTunnelService::class.java)
+            context.startForegroundService(intent)
+            context.bindService(intent, autoTunnelServiceConnection, Context.BIND_AUTO_CREATE)
         }
     }
 
-    suspend fun stopAutoTunnel() {
+    suspend fun stopAutoTunnel() =
         autoTunnelMutex.withLock {
-            val settings = appDataRepository.settings.get()
-            appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = false))
-            if (_autoTunnelService.value == null) return
+            if (_autoTunnelService.value == null) return@withLock
             _autoTunnelService.value?.let { service ->
                 service.stop()
                 try {
                     context.unbindService(autoTunnelServiceConnection)
                 } catch (e: Exception) {
                     Timber.e(e, "Failed to unbind AutoTunnelService")
-                } finally {
-                    _tunnelService.value = null
                 }
             }
-            withContext(mainDispatcher) { updateAutoTunnelTile() }
         }
-    }
 
-    suspend fun startTunnelForegroundService() {
-        if (_tunnelService.value != null) return
-        withContext(ioDispatcher) {
-            applicationScope.launch(ioDispatcher) {
-                val intent = Intent(context, TunnelForegroundService::class.java)
-                context.startForegroundService(intent)
-                context.bindService(intent, tunnelServiceConnection, Context.BIND_AUTO_CREATE)
+    suspend fun startTunnelService(appMode: AppMode) =
+        tunnelMutex.withLock {
+            if (_tunnelService.value != null) return@withLock
+            val serviceClass =
+                when (appMode) {
+                    AppMode.VPN,
+                    AppMode.LOCK_DOWN -> VpnForegroundService::class.java
+                    AppMode.KERNEL,
+                    AppMode.PROXY -> TunnelForegroundService::class.java
+                }
+            val intent = Intent(context, serviceClass)
+            context.startForegroundService(intent)
+            context.bindService(intent, tunnelServiceConnection, Context.BIND_AUTO_CREATE)
+        }
+
+    suspend fun stopTunnelService() =
+        tunnelMutex.withLock {
+            _tunnelService.value?.let { service ->
+                service.stop()
+                try {
+                    context.unbindService(tunnelServiceConnection)
+                } catch (e: Exception) {
+                    Timber.e(e, "Failed to stop Tunnel Service")
+                }
             }
         }
-    }
-
-    fun stopTunnelForegroundService() {
-        _tunnelService.value?.let { service ->
-            service.stop()
-            try {
-                context.unbindService(tunnelServiceConnection)
-            } catch (e: Exception) {
-                Timber.e(e, "Failed to stop TunnelForegroundService")
-            } finally {
-                _tunnelService.value = null
-            }
-        }
-    }
-
-    fun toggleAutoTunnel() {
-        applicationScope.launch(ioDispatcher) {
-            if (_autoTunnelService.value != null) stopAutoTunnel() else startAutoTunnel()
-        }
-    }
 
     fun updateAutoTunnelTile() {
         context.requestAutoTunnelTileServiceUpdate()

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

@@ -1,155 +1,8 @@
 package com.zaneschepke.wireguardautotunnel.core.service
 
-import android.app.Notification
-import android.content.Intent
-import android.os.Binder
-import android.os.IBinder
-import androidx.core.app.ServiceCompat
-import androidx.lifecycle.LifecycleService
-import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
-import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
-import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
-import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
-import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
-import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.extensions.distinctByKeys
 import dagger.hilt.android.AndroidEntryPoint
-import io.ktor.util.collections.*
-import javax.inject.Inject
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import timber.log.Timber
 
 @AndroidEntryPoint
-class TunnelForegroundService : LifecycleService() {
-
-    @Inject lateinit var notificationManager: NotificationManager
-
-    @Inject lateinit var serviceManager: ServiceManager
-
-    @Inject lateinit var tunnelManager: TunnelManager
-
-    @Inject lateinit var tunnelMonitor: TunnelMonitor
-
-    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
-
-    @Inject lateinit var appDataRepository: AppDataRepository
-
-    class LocalBinder(val service: TunnelForegroundService) : Binder()
-
-    private val tunnelJobs = ConcurrentMap<TunnelConf, Job>()
-
-    private val binder = LocalBinder(this)
-
-    override fun onCreate() {
-        super.onCreate()
-        ServiceCompat.startForeground(
-            this@TunnelForegroundService,
-            NotificationManager.VPN_NOTIFICATION_ID,
-            onCreateNotification(),
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
-        )
-    }
-
-    override fun onBind(intent: Intent): IBinder {
-        super.onBind(intent)
-        return binder
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        super.onStartCommand(intent, flags, startId)
-        ServiceCompat.startForeground(
-            this@TunnelForegroundService,
-            NotificationManager.VPN_NOTIFICATION_ID,
-            onCreateNotification(),
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
-        )
-        start()
-        return START_STICKY
-    }
-
-    fun start() =
-        lifecycleScope.launch(ioDispatcher) {
-            tunnelManager.activeTunnels.distinctByKeys().collect { activeTunnels ->
-                val activeTunConfigs = activeTunnels.keys
-                val obsoleteJobs = tunnelJobs.keys - activeTunConfigs
-                obsoleteJobs.forEach { tunnelConf -> tunnelJobs[tunnelConf]?.cancel() }
-                activeTunConfigs.forEach { tun ->
-                    if (tunnelJobs.containsKey(tun)) return@forEach
-                    tunnelJobs[tun] = launch { tunnelMonitor.startMonitoring(tun, true) }
-                }
-                updateServiceNotification(activeTunnels)
-            }
-        }
-
-    // TODO Would be cool to have this include kill switch
-    private fun updateServiceNotification(activeTunnels: Map<TunnelConf, TunnelState>) {
-        val notification =
-            when (activeTunnels.size) {
-                0 -> onCreateNotification()
-                1 -> createTunnelNotification(activeTunnels.keys.first())
-                else -> createTunnelsNotification()
-            }
-        ServiceCompat.startForeground(
-            this@TunnelForegroundService,
-            NotificationManager.VPN_NOTIFICATION_ID,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
-        )
-    }
-
-    fun stop() {
-        Timber.d("Stop called")
-        tunnelJobs.forEach { it.value.cancel() }
-        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
-        stopSelf()
-    }
-
-    override fun onDestroy() {
-        tunnelJobs.forEach { it.value.cancel() }
-        serviceManager.handleTunnelServiceDestroy()
-        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
-        Timber.d("onDestroy")
-        super.onDestroy()
-    }
-
-    private fun createTunnelNotification(tunnelConf: TunnelConf): Notification {
-        return notificationManager.createNotification(
-            WireGuardNotification.NotificationChannels.VPN,
-            title = "${getString(R.string.tunnel_running)} - ${tunnelConf.tunName}",
-            actions =
-                listOf(
-                    notificationManager.createNotificationAction(
-                        NotificationAction.TUNNEL_OFF,
-                        tunnelConf.id,
-                    )
-                ),
-            onGoing = true,
-        )
-    }
-
-    private fun createTunnelsNotification(): Notification {
-        return notificationManager.createNotification(
-            WireGuardNotification.NotificationChannels.VPN,
-            title = "${getString(R.string.tunnel_running)} - ${getString(R.string.multiple)}",
-            actions =
-                listOf(
-                    notificationManager.createNotificationAction(NotificationAction.TUNNEL_OFF, 0)
-                ),
-        )
-    }
-
-    private fun onCreateNotification(): Notification {
-        return notificationManager.createNotification(
-            WireGuardNotification.NotificationChannels.VPN,
-            title = getString(R.string.tunnel_starting),
-        )
-    }
-}
+class TunnelForegroundService(override val fgsType: Int = Constants.SPECIAL_USE_SERVICE_TYPE_ID) :
+    BaseTunnelForegroundService()

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

@@ -0,0 +1,7 @@
+package com.zaneschepke.wireguardautotunnel.core.service
+
+interface TunnelService {
+    fun start()
+
+    fun stop()
+}

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

@@ -0,0 +1,8 @@
+package com.zaneschepke.wireguardautotunnel.core.service
+
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import dagger.hilt.android.AndroidEntryPoint
+
+@AndroidEntryPoint
+class VpnForegroundService(override val fgsType: Int = Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID) :
+    BaseTunnelForegroundService()

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

@@ -17,10 +17,8 @@ import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor
 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.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.AutoTunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
@@ -31,7 +29,6 @@ import com.zaneschepke.wireguardautotunnel.util.extensions.toMillis
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
 import javax.inject.Provider
-import kotlin.math.pow
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.sync.Mutex
@@ -61,12 +58,6 @@ class AutoTunnelService : LifecycleService() {
 
     private val autoTunnelStateFlow = MutableStateFlow(defaultState)
 
-    private val bounceCounts = MutableStateFlow<Map<Int, Int>>(emptyMap())
-
-    private var eventHandlerJob: Job? = null
-
-    private val lastBounceTimes = mutableMapOf<Int, Long>()
-
     class LocalBinder(val service: AutoTunnelService) : Binder()
 
     private val binder = LocalBinder(this)
@@ -143,20 +134,10 @@ class AutoTunnelService : LifecycleService() {
             val tunnelsFlow =
                 tunnelManager.activeTunnels.map { StateChange.ActiveTunnelsChange(it) }
 
-            val monitoringFlow =
-                tunnelManager.activeTunnels
-                    .map { map -> map.mapValues { (_, state) -> state.pingStates } }
-                    .distinctUntilChanged()
-                    .map { StateChange.MonitoringChange(it) }
-
             var reevaluationJob: Job? = null
 
             // get everything in sync before we use merge
-            combine(networkFlow, settingsFlow, tunnelsFlow, monitoringFlow) {
-                    network,
-                    settings,
-                    tunnels,
-                    monitoring ->
+            combine(networkFlow, settingsFlow, tunnelsFlow) { network, settings, tunnels ->
                     autoTunnelStateFlow.update {
                         it.copy(
                             activeTunnels = tunnels.activeTunnels,
@@ -170,7 +151,7 @@ class AutoTunnelService : LifecycleService() {
 
             // use merge to limit the noise of a combine and also increase the scalability of auto
             // tunnel handling new states
-            merge(networkFlow, settingsFlow, tunnelsFlow, monitoringFlow).collect { change ->
+            merge(networkFlow, settingsFlow, tunnelsFlow).collect { change ->
                 if (change !is StateChange.ActiveTunnelsChange) {
                     Timber.d("New state changed to ${change.javaClass.simpleName}")
                 }
@@ -201,22 +182,6 @@ class AutoTunnelService : LifecycleService() {
                         autoTunnelStateFlow.update { it.copy(activeTunnels = change.activeTunnels) }
                         return@collect
                     }
-                    is StateChange.MonitoringChange -> {
-                        change.pingStates.forEach { (config, pingState) ->
-                            Timber.d("Ping state $pingState")
-                            if (pingState?.all { it.value.isReachable } == true) {
-                                Timber.d("Clearing bounce count on success")
-                                bounceCounts.update { current ->
-                                    current.toMutableMap().apply { remove(config.id) }
-                                }
-                            }
-                        }
-                        return@collect handleAutoTunnelEvent(
-                            autoTunnelStateFlow.value.determineAutoTunnelEvent(
-                                StateChange.MonitoringChange(change.pingStates)
-                            )
-                        )
-                    }
                 }
 
                 handleAutoTunnelEvent(autoTunnelStateFlow.value.determineAutoTunnelEvent(change))
@@ -381,39 +346,8 @@ class AutoTunnelService : LifecycleService() {
                     (event.tunnelConf ?: appDataRepository.get().getPrimaryOrFirstTunnel())?.let {
                         tunnelManager.startTunnel(it)
                     }
-                is AutoTunnelEvent.Stop -> tunnelManager.stopTunnel()
+                is AutoTunnelEvent.Stop -> tunnelManager.stopActiveTunnels()
                 AutoTunnelEvent.DoNothing -> Timber.i("Auto-tunneling: nothing to do")
-                is AutoTunnelEvent.Bounce ->
-                    handleBounceWithBackoff(event.configsPeerKeyResolvedMap)
-            }
-        }
-    }
-
-    private suspend fun handleBounceWithBackoff(
-        configsPeerKeyResolvedMap: List<Pair<TunnelConf, Map<String, String?>>>
-    ) { // Simplified param: no failureCount
-        val settings = appDataRepository.get().settings.get()
-        val pingIntervalMillis = settings.tunnelPingIntervalSeconds.toMillis()
-        configsPeerKeyResolvedMap.forEach { (config, peerMap) ->
-            val bounceCount = bounceCounts.value.getOrDefault(config.id, 0)
-            val exponent = bounceCount.toDouble()
-            val backoffDelay =
-                (pingIntervalMillis * 2.0.pow(exponent)).toLong().coerceAtMost(MAX_BACKOFF_MS)
-            val currentTime = System.currentTimeMillis()
-            val lastTime = lastBounceTimes.getOrDefault(config.id, 0L)
-            if (currentTime - lastTime >= backoffDelay) {
-                Timber.d(
-                    "Bouncing tunnel ${config.name} after detecting failure, with bounce count $bounceCount and calculated backoff delay $backoffDelay ms"
-                )
-                tunnelManager.bounceTunnel(config, Ping(peerMap))
-                lastBounceTimes[config.id] = currentTime
-                bounceCounts.update { current ->
-                    current.toMutableMap().apply { this[config.id] = (this[config.id] ?: 0) + 1 }
-                }
-            } else {
-                Timber.d(
-                    "Backoff in progress for tunnel ${config.name}, skipping bounce (required delay: $backoffDelay ms)"
-                )
             }
         }
     }
@@ -434,6 +368,5 @@ class AutoTunnelService : LifecycleService() {
     companion object {
         // try to keep this window short as it will interrupt manual overrides
         const val REEVALUATE_CHECK_DELAY = 2_000L
-        const val MAX_BACKOFF_MS = 300_000L // 5 minutes
     }
 }

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

@@ -1,20 +1,14 @@
 package com.zaneschepke.wireguardautotunnel.core.service.autotunnel
 
 import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
-import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
-import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
-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 ActiveTunnelsChange(val activeTunnels: Map<TunnelConf, TunnelState>) : StateChange()
-
-    data class MonitoringChange(val pingStates: Map<TunnelConf, Map<Key, PingState>?>) :
-        StateChange()
+    data class ActiveTunnelsChange(val activeTunnels: Map<Int, TunnelState>) : StateChange()
 }

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

@@ -13,9 +13,7 @@ import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
-import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
 import kotlinx.coroutines.launch
@@ -65,12 +63,15 @@ class TunnelControlTile : TileService(), LifecycleOwner {
 
             when {
                 activeTunnels.isNotEmpty() -> {
-                    val activeIds = activeTunnels.map { it.key.id }
+                    val activeIds = activeTunnels.map { it.key }
                     // TODO improvements would be needed to make this work well with toggling
                     // multiple tunnels
                     // this would be better managed elsewhere
                     WireGuardAutoTunnel.setLastActiveTunnels(activeIds)
-                    updateTileForActiveTunnels(activeTunnels)
+                    val tunnels = appDataRepository.tunnels.getAll()
+                    val activeTunNames =
+                        tunnels.filter { activeTunnels.keys.contains(it.id) }.map { it.tunName }
+                    updateTileForActiveTunnels(activeTunNames)
                 }
                 else -> updateTileForLastActiveTunnels()
             }
@@ -79,10 +80,10 @@ class TunnelControlTile : TileService(), LifecycleOwner {
         }
     }
 
-    private fun updateTileForActiveTunnels(activeTunnels: Map<TunnelConf, TunnelState>) {
+    private fun updateTileForActiveTunnels(activeTunnelNames: List<String>) {
         val tileName =
-            when (activeTunnels.size) {
-                1 -> activeTunnels.keys.first().tunName
+            when (activeTunnelNames.size) {
+                1 -> activeTunnelNames[0]
                 else -> getString(R.string.multiple)
             }
         updateTile(tileName, true)
@@ -111,7 +112,7 @@ class TunnelControlTile : TileService(), LifecycleOwner {
         unlockAndRun {
             lifecycleScope.launch {
                 if (tunnelManager.activeTunnels.value.isNotEmpty())
-                    return@launch tunnelManager.stopTunnel()
+                    return@launch tunnelManager.stopActiveTunnels()
                 val lastActive = WireGuardAutoTunnel.getLastActiveTunnels()
                 if (lastActive.isEmpty()) {
                     appDataRepository.getStartTunnelConfig()?.let { tunnelManager.startTunnel(it) }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/shortcut/ShortcutsActivity.kt

@@ -44,7 +44,7 @@ class ShortcutsActivity : ComponentActivity() {
                         tunnelConfig?.let {
                             when (intent.action) {
                                 Action.START.name -> tunnelManager.startTunnel(it)
-                                Action.STOP.name -> tunnelManager.stopTunnel()
+                                Action.STOP.name -> tunnelManager.stopActiveTunnels()
                                 else -> Unit
                             }
                         }

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

@@ -1,22 +1,21 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel
 
-import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
+import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
+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.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.LogHealthState
 import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
-import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
-import com.zaneschepke.wireguardautotunnel.util.extensions.asTunnelState
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.coroutines.cancellation.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
@@ -25,58 +24,60 @@ import org.amnezia.awg.crypto.Key
 import timber.log.Timber
 
 abstract class BaseTunnel(
-    private val applicationScope: CoroutineScope,
-    private val appDataRepository: AppDataRepository,
-    private val serviceManager: ServiceManager,
+    @ApplicationScope protected val applicationScope: CoroutineScope,
+    protected val appDataRepository: AppDataRepository,
+    protected val serviceManager: ServiceManager,
 ) : TunnelProvider {
 
-    private val _errorEvents = MutableSharedFlow<Pair<TunnelConf, BackendCoreException>>()
-    override val errorEvents = _errorEvents.asSharedFlow()
+    protected val errors = MutableSharedFlow<Pair<String, BackendCoreException>>()
+    override val errorEvents = errors.asSharedFlow()
 
-    private val _messageEvents = MutableSharedFlow<Pair<TunnelConf, BackendMessage>>()
+    private val _messageEvents = MutableSharedFlow<Pair<String, BackendMessage>>()
     override val messageEvents = _messageEvents.asSharedFlow()
 
-    private val activeTuns = MutableStateFlow<Map<TunnelConf, TunnelState>>(emptyMap())
-    private val tunJobs = ConcurrentHashMap<Int, Job>()
+    protected val activeTuns = MutableStateFlow<Map<Int, TunnelState>>(emptyMap())
     override val activeTunnels = activeTuns.asStateFlow()
 
+    private val tunJobs = ConcurrentHashMap<Int, Job>()
     private val tunMutex = Mutex()
     private val tunStatusMutex = Mutex()
-    private val bounceTunnelMutex = Mutex()
 
-    override val bouncingTunnelIds = ConcurrentHashMap<Int, TunnelStatus.StopReason>()
+    abstract fun tunnelStateFlow(tunnelConf: TunnelConf): Flow<TunnelStatus>
 
-    abstract suspend fun startBackend(tunnel: TunnelConf)
+    abstract override fun setBackendMode(backendMode: BackendMode)
 
-    abstract fun stopBackend(tunnel: TunnelConf)
+    abstract override fun getBackendMode(): BackendMode
+
+    abstract override fun handleDnsReresolve(tunnelConf: TunnelConf): Boolean
+
+    abstract override fun getStatistics(tunnelId: Int): TunnelStatistics?
 
     override fun hasVpnPermission(): Boolean {
         return serviceManager.hasVpnPermission()
     }
 
     override suspend fun updateTunnelStatus(
-        tunnelConf: TunnelConf,
+        tunnelId: Int,
         status: TunnelStatus?,
         stats: TunnelStatistics?,
         pingStates: Map<Key, PingState>?,
-        handshakeSuccessLogs: Boolean?,
+        logHealthState: LogHealthState?,
     ) {
         tunStatusMutex.withLock {
             activeTuns.update { currentTuns ->
-                val originalConf = currentTuns.getKeyById(tunnelConf.id) ?: tunnelConf
-                val existingState = currentTuns.getValueById(tunnelConf.id) ?: TunnelState()
+                val existingState = currentTuns[tunnelId] ?: TunnelState()
                 val newStatus = status ?: existingState.status
                 if (newStatus == TunnelStatus.Down) {
-                    Timber.d("Removing tunnel ${tunnelConf.id} from activeTunnels as state is DOWN")
-                    cleanUpTunJob(tunnelConf)
-                    currentTuns - originalConf
+                    Timber.d("Removing tunnel $tunnelId from activeTunnels as state is DOWN")
+                    cleanUpTunJob(tunnelId)
+                    currentTuns - tunnelId
                 } else if (
                     existingState.status == newStatus &&
                         stats == null &&
                         pingStates == null &&
-                        handshakeSuccessLogs == null
+                        logHealthState == null
                 ) {
-                    Timber.d("Skipping redundant state update for ${tunnelConf.id}: $newStatus")
+                    Timber.d("Skipping redundant state update for ${tunnelId}: $newStatus")
                     currentTuns
                 } else {
                     val updated =
@@ -84,17 +85,15 @@ abstract class BaseTunnel(
                             status = newStatus,
                             statistics = stats ?: existingState.statistics,
                             pingStates = pingStates ?: existingState.pingStates,
-                            handshakeSuccessLogs =
-                                handshakeSuccessLogs ?: existingState.handshakeSuccessLogs,
+                            logHealthState = logHealthState ?: existingState.logHealthState,
                         )
-                    currentTuns + (originalConf to updated)
+                    currentTuns + (tunnelId to updated)
                 }
             }
-            handleServiceStateOnChange()
         }
     }
 
-    private suspend fun stopActiveTunnels() {
+    override suspend fun stopActiveTunnels() {
         activeTunnels.value.forEach { (config, state) ->
             if (state.status.isUpOrStarting()) {
                 stopTunnel(config)
@@ -102,191 +101,43 @@ abstract class BaseTunnel(
         }
     }
 
-    private fun configureTunnelCallbacks(tunnelConf: TunnelConf) {
-        Timber.d("Configuring TunnelConf instance: ${tunnelConf.hashCode()}")
-        tunnelConf.setStateChangeCallback { state ->
-            applicationScope.launch {
-                Timber.d(
-                    "State change callback triggered for tunnel ${tunnelConf.id}: ${tunnelConf.tunName} with state $state at ${System.currentTimeMillis()}"
-                )
-                when (state) {
-                    is Tunnel.State -> updateTunnelStatus(tunnelConf, state.asTunnelState())
-                    is org.amnezia.awg.backend.Tunnel.State ->
-                        updateTunnelStatus(tunnelConf, state.asTunnelState())
-                }
-                handleServiceStateOnChange()
-            }
-            serviceManager.updateTunnelTile()
-        }
-    }
-
     override suspend fun startTunnel(tunnelConf: TunnelConf) {
-        if (activeTuns.exists(tunnelConf.id) || tunJobs.containsKey(tunnelConf.id))
-            return Timber.w("Tunnel is already running ${tunnelConf.name}")
-        // For userspace, we need to make sure all previous tunnels are down
-        if (this@BaseTunnel is UserspaceTunnel) stopActiveTunnels()
         tunMutex.withLock {
+            if (activeTuns.value.containsKey(tunnelConf.id) || tunJobs.containsKey(tunnelConf.id)) {
+                return Timber.w("Tunnel is already running: ${tunnelConf.tunName}")
+            }
+
+            updateTunnelStatus(tunnelConf.id, TunnelStatus.Starting)
+
             val job =
                 applicationScope.launch {
                     try {
-                        Timber.d("Starting tunnel ${tunnelConf.id}...")
-                        startTunnelInner(tunnelConf)
-                        Timber.d("Started complete for tunnel ${tunnelConf.name}...")
-                        // catch cancellation that could occur before and during startTunnelInner
-                        // and trigger at that suspend point
-                    } catch (e: CancellationException) {
-                        Timber.w(
-                            "Tunnel start has been cancelled as ${tunnelConf.name} failed to start"
-                        )
-                    }
+                        tunnelStateFlow(tunnelConf).collect { status ->
+                            updateTunnelStatus(tunnelConf.id, status)
+                            serviceManager.updateTunnelTile()
+                        }
+                    } catch (e: BackendCoreException) {
+                        errors.emit(tunnelConf.tunName to e)
+                        updateTunnelStatus(tunnelConf.id, TunnelStatus.Down)
+                    } catch (_: CancellationException) {}
                 }
             tunJobs[tunnelConf.id] = job
             job.invokeOnCompletion {
                 tunJobs.remove(tunnelConf.id)
-                Timber.d("Start job completed for tunnel ${tunnelConf.id}")
+                activeTuns.update { it - tunnelConf.id }
             }
         }
     }
 
-    private suspend fun startTunnelInner(tunnelConf: TunnelConf) {
-        configureTunnelCallbacks(tunnelConf)
-        Timber.d("Starting backend for tunnel ${tunnelConf.id}...")
-
-        var currentConf = tunnelConf
-        var restoreAttempted = false
-        var originalError: BackendCoreException? = null
-
-        while (true) {
-            try {
-                startBackend(currentConf)
-                updateTunnelStatus(currentConf, TunnelStatus.Up)
-                Timber.d("Started for tun ${currentConf.id}...")
-                saveTunnelActiveState(currentConf, true)
-                serviceManager.startTunnelForegroundService()
-                if (restoreAttempted)
-                    _messageEvents.emit(tunnelConf to BackendMessage.BounceRecovery)
-                if (bouncingTunnelIds[currentConf.id] is TunnelStatus.StopReason.Ping) {
-                    _messageEvents.emit(tunnelConf to BackendMessage.BounceSuccess)
-                }
-                return // Success, return
-            } catch (e: BackendCoreException) {
-                originalError = originalError ?: e
-                val bounceReason = bouncingTunnelIds[currentConf.id]
-                if (!restoreAttempted && bounceReason is TunnelStatus.StopReason.Ping) {
-                    Timber.i(
-                        "Attempting to recover bounce failure with previously resolved endpoints for ${currentConf.name}"
-                    )
-                    try {
-                        val previouslyResolved = bounceReason.previouslyResolvedEndpoints
-                        val configProxy = ConfigProxy.from(currentConf.toAmConfig())
-                        val updatedConfigProxy =
-                            configProxy.copy(
-                                peers =
-                                    configProxy.peers.map {
-                                        it.copy(
-                                            endpoint =
-                                                previouslyResolved[it.publicKey] ?: it.endpoint
-                                        )
-                                    }
-                            )
-                        val (wg, amnezia) = updatedConfigProxy.buildConfigs()
-                        currentConf =
-                            currentConf.copyWithCallback(
-                                amQuick = amnezia.toAwgQuickString(true, false),
-                                wgQuick = wg.toWgQuickString(true),
-                            )
-                        bouncingTunnelIds.remove(currentConf.id)
-                        restoreAttempted = true
-                        continue // Retry
-                    } catch (e: Exception) {
-                        Timber.e(
-                            e,
-                            "Failed to update config with resolved endpoints for ${currentConf.name}",
-                        )
-                        // Fall through to failure (will emit BounceFailed since
-                        // retryAttempted=true)
-                    }
-                }
-                Timber.e(e, "Failed to start backend for ${currentConf.name}")
-                val emitError =
-                    if (restoreAttempted) BackendCoreException.BounceFailed(originalError) else e
-                _errorEvents.emit(currentConf to emitError)
-                updateTunnelStatus(currentConf, TunnelStatus.Down)
-                return
-            }
-        }
-    }
-
-    private suspend fun saveTunnelActiveState(tunnelConf: TunnelConf, active: Boolean) {
-        val tunnelCopy = tunnelConf.copyWithCallback(isActive = active)
-        appDataRepository.tunnels.save(tunnelCopy)
-    }
-
-    override suspend fun stopTunnel(tunnelConf: TunnelConf?, reason: TunnelStatus.StopReason) {
-        if (tunnelConf == null) return stopActiveTunnels()
+    override suspend fun stopTunnel(tunnelId: Int) {
         tunMutex.withLock {
-            if (activeTuns.isStarting(tunnelConf.id))
-                return handleStuckStartingTunnelShutdown(tunnelConf)
-            updateTunnelStatus(tunnelConf, TunnelStatus.Stopping(reason))
-            stopTunnelInner(tunnelConf)
+            updateTunnelStatus(tunnelId, TunnelStatus.Stopping)
+            tunJobs[tunnelId]?.cancel() // Triggers awaitClose to stop backend
         }
     }
 
-    private suspend fun stopTunnelInner(tunnelConf: TunnelConf) {
-        try {
-            val tunnel = activeTuns.findTunnel(tunnelConf.id) ?: return
-            stopBackend(tunnel)
-            saveTunnelActiveState(tunnelConf, false)
-            removeActiveTunnel(tunnel)
-        } catch (e: BackendCoreException) {
-            Timber.e(e, "Failed to stop tunnel ${tunnelConf.id}")
-            _errorEvents.emit(tunnelConf to e)
-            updateTunnelStatus(tunnelConf, TunnelStatus.Down)
-        }
-    }
-
-    private fun handleServiceStateOnChange() {
-        if (activeTuns.value.isEmpty()) serviceManager.stopTunnelForegroundService()
-    }
-
-    private suspend fun handleStuckStartingTunnelShutdown(tunnel: TunnelConf) {
-        Timber.d("Stuck in starting state so cancelling job for tunnel ${tunnel.name}")
-        try {
-            tunJobs[tunnel.id]?.cancel() ?: Timber.d("No job found for ${tunnel.name}")
-        } catch (e: Exception) {
-            Timber.e(e, "Failed to cancel job for ${tunnel.name}")
-        } finally {
-            updateTunnelStatus(tunnel, TunnelStatus.Down)
-        }
-    }
-
-    private fun cleanUpTunJob(tunnel: TunnelConf) {
-        Timber.d("Removing job for ${tunnel.name}")
-        tunJobs -= tunnel.id
-    }
-
-    private fun removeActiveTunnel(tunnelConf: TunnelConf) {
-        activeTuns.update { current -> current.toMutableMap().apply { remove(tunnelConf) } }
-    }
-
-    override suspend fun bounceTunnel(tunnelConf: TunnelConf, reason: TunnelStatus.StopReason) {
-        bounceTunnelMutex.withLock {
-            Timber.i(
-                "Bounce tunnel ${tunnelConf.name} for reason: $reason, current bouncing: ${bouncingTunnelIds.size}"
-            )
-            bouncingTunnelIds[tunnelConf.id] = reason
-            runCatching {
-                stopTunnel(tunnelConf, reason)
-                delay(BOUNCE_DELAY)
-                startTunnel(tunnelConf)
-            }
-        }
-    }
-
-    override suspend fun runningTunnelNames(): Set<String> =
-        activeTuns.value.keys.map { it.tunName }.toSet()
-
-    companion object {
-        const val BOUNCE_DELAY = 300L
+    private fun cleanUpTunJob(tunnelId: Int) {
+        Timber.d("Removing job for $tunnelId")
+        tunJobs -= tunnelId
     }
 }

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

@@ -2,7 +2,7 @@ package com.zaneschepke.wireguardautotunnel.core.tunnel
 
 import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.BackendException
-import com.wireguard.android.backend.Tunnel
+import com.wireguard.android.backend.Tunnel as WgTunnel
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.di.Kernel
@@ -13,50 +13,78 @@ import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.domain.state.WireGuardStatistics
+import com.zaneschepke.wireguardautotunnel.util.extensions.asTunnelState
 import com.zaneschepke.wireguardautotunnel.util.extensions.toBackendCoreException
+import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.launch
 import timber.log.Timber
 
 class KernelTunnel
 @Inject
 constructor(
-    @ApplicationScope private val applicationScope: CoroutineScope,
+    @ApplicationScope applicationScope: CoroutineScope,
     serviceManager: ServiceManager,
     appDataRepository: AppDataRepository,
     @Kernel private val backend: Backend,
 ) : BaseTunnel(applicationScope, appDataRepository, serviceManager) {
 
-    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
-        return try {
-            WireGuardStatistics(backend.getStatistics(tunnelConf))
-        } catch (e: Exception) {
-            Timber.e(e)
-            null
-        }
-    }
+    private val runtimeTunnels = ConcurrentHashMap<Int, WgTunnel>()
+
+    // TODO Add DNS settings
+    override fun tunnelStateFlow(tunnelConf: TunnelConf): Flow<TunnelStatus> = callbackFlow {
+        if (!tunnelConf.isNameKernelCompatible) close(BackendCoreException.TunnelNameTooLong)
+
+        val stateChannel = Channel<WgTunnel.State>()
+
+        val runtimeTunnel = RuntimeWgTunnel(tunnelConf, stateChannel)
+        runtimeTunnels[tunnelConf.id] = runtimeTunnel
+
+        val consumerJob = launch {
+            stateChannel.consumeAsFlow().collect { state -> trySend(state.asTunnelState()) }
+        }
 
-    override suspend fun startBackend(tunnel: TunnelConf) {
-        // name too long for kernel mode
-        if (!tunnel.isNameKernelCompatible) throw BackendCoreException.TunnelNameTooLong
         try {
-            updateTunnelStatus(tunnel, TunnelStatus.Starting)
-            backend.setState(tunnel, Tunnel.State.UP, tunnel.toWgConfig())
+            updateTunnelStatus(tunnelConf.id, TunnelStatus.Starting)
+            backend.setState(runtimeTunnel, WgTunnel.State.UP, tunnelConf.toWgConfig())
         } catch (e: BackendException) {
-            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
-            throw e.toBackendCoreException()
+            close(e.toBackendCoreException())
         } catch (e: IllegalArgumentException) {
-            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
-            throw BackendCoreException.Config
+            Timber.e(e, "Invalid backend arguments")
+            close(BackendCoreException.Config)
+        } catch (e: Exception) {
+            Timber.e(e, "Error while setting tunnel state")
+            close(BackendCoreException.Unknown)
+        }
+
+        awaitClose {
+            try {
+                backend.setState(runtimeTunnel, WgTunnel.State.DOWN, null)
+            } catch (e: BackendException) {
+                errors.tryEmit(tunnelConf.tunName to e.toBackendCoreException())
+            } finally {
+                consumerJob.cancel()
+                stateChannel.close()
+                runtimeTunnels.remove(tunnelConf.id)
+                trySend(TunnelStatus.Down)
+                close()
+            }
         }
     }
 
-    override fun stopBackend(tunnel: TunnelConf) {
-        Timber.i("Stopping tunnel ${tunnel.id} kernel")
-        try {
-            backend.setState(tunnel, Tunnel.State.DOWN, tunnel.toWgConfig())
-        } catch (e: BackendException) {
-            throw e.toBackendCoreException()
+    override fun getStatistics(tunnelId: Int): TunnelStatistics? {
+        return try {
+            val runtimeTunnel = runtimeTunnels[tunnelId] ?: return null
+            WireGuardStatistics(backend.getStatistics(runtimeTunnel))
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to get stats for $tunnelId")
+            null
         }
     }
 
@@ -68,6 +96,10 @@ constructor(
         return BackendMode.Inactive
     }
 
+    override fun handleDnsReresolve(tunnelConf: TunnelConf): Boolean {
+        throw NotImplementedError()
+    }
+
     override suspend fun runningTunnelNames(): Set<String> {
         return backend.runningTunnelNames
     }

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

@@ -0,0 +1,19 @@
+package com.zaneschepke.wireguardautotunnel.core.tunnel
+
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import kotlinx.coroutines.channels.Channel
+import org.amnezia.awg.backend.Tunnel
+
+class RuntimeAwgTunnel(
+    private val tunnelConf: TunnelConf,
+    private val stateChannel: Channel<Tunnel.State>,
+) : Tunnel {
+
+    override fun getName() = tunnelConf.tunName
+
+    override fun onStateChange(newState: Tunnel.State) {
+        stateChannel.trySend(newState)
+    }
+
+    override fun isIpv4ResolutionPreferred() = tunnelConf.isIpv4Preferred
+}

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

@@ -0,0 +1,19 @@
+package com.zaneschepke.wireguardautotunnel.core.tunnel
+
+import com.wireguard.android.backend.Tunnel
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import kotlinx.coroutines.channels.Channel
+
+class RuntimeWgTunnel(
+    private val config: TunnelConf,
+    private val stateChannel: Channel<Tunnel.State>,
+) : Tunnel {
+
+    override fun getName() = config.tunName
+
+    override fun onStateChange(newState: Tunnel.State) {
+        stateChannel.trySend(newState)
+    }
+
+    override fun isIpv4ResolutionPreferred() = config.isIpv4Preferred
+}

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

@@ -10,23 +10,21 @@ import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
 import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.LogHealthState
 import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
-import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 import kotlin.concurrent.atomics.AtomicBoolean
 import kotlin.concurrent.atomics.AtomicReference
 import kotlin.concurrent.atomics.ExperimentalAtomicApi
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.*
+import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.plus
 import org.amnezia.awg.crypto.Key
 import timber.log.Timber
 
-@OptIn(ExperimentalCoroutinesApi::class)
+@OptIn(ExperimentalCoroutinesApi::class, ExperimentalAtomicApi::class)
 class TunnelManager
 @Inject
 constructor(
@@ -39,7 +37,21 @@ constructor(
     @IoDispatcher ioDispatcher: CoroutineDispatcher,
 ) : TunnelProvider {
 
-    @OptIn(ExperimentalAtomicApi::class)
+    private data class SideEffectState(
+        val activeTuns: Map<Int, TunnelState>,
+        val tuns: List<TunnelConf>,
+        val settings: GeneralSettings,
+        val previouslyActive: Map<Int, TunnelState>,
+    )
+
+    private data class SideEffectWithCondition(
+        val effect: suspend (SideEffectState) -> Unit,
+        val condition: (SideEffectState) -> Boolean,
+    )
+
+    private val sideEffectChannelFlow =
+        MutableStateFlow<Channel<SideEffectState>>(Channel(Channel.CONFLATED))
+
     private val tunnelProviderFlow: StateFlow<TunnelProvider> = run {
         val currentBackend = AtomicReference(userspaceTunnel)
         val currentSettings = AtomicReference(GeneralSettings())
@@ -66,45 +78,14 @@ constructor(
             }
             .onEach { (settings, newBackend) ->
                 val isInitialEmit = initialEmit.exchange(false)
-                val oldBackend = currentBackend.exchange(newBackend)
-                val oldSettings = currentSettings.exchange(settings)
+                val previousBackend = currentBackend.exchange(newBackend)
+                val previousSettings = currentSettings.exchange(settings)
 
-                if ((oldSettings.appMode != settings.appMode) && !isInitialEmit) {
-                    oldBackend.stopTunnel()
-                    if (oldSettings.appMode == AppMode.LOCK_DOWN)
-                        proxyUserspaceTunnel.setBackendMode(BackendMode.Inactive)
+                if ((previousSettings.appMode != settings.appMode) && !isInitialEmit) {
+                    handleModeChangeCleanup(previousBackend, previousSettings.appMode)
                 }
                 if (settings.appMode == AppMode.LOCK_DOWN) {
-                    // kill switch will always catch all ipv6, just add ipv4 networks for allowsIps
-                    val allowedIps =
-                        if (settings.isLanOnKillSwitchEnabled) TunnelConf.IPV4_PUBLIC_NETWORKS
-                        else emptySet()
-                    try {
-                        // TODO handle situation where they don't have vpn permission, request it
-                        if (hasVpnPermission()) {
-                            proxyUserspaceTunnel.setBackendMode(BackendMode.KillSwitch(allowedIps))
-                        }
-                    } catch (e: BackendCoreException) {
-                        // TODO expose this error to user
-                        Timber.e(e)
-                    }
-                }
-                // restore state if configured
-                if (isInitialEmit && settings.isRestoreOnBootEnabled) {
-                    Timber.d("Restoring previous state")
-                    if (
-                        settings.isAutoTunnelEnabled &&
-                            serviceManager.autoTunnelService.value == null
-                    ) {
-                        serviceManager.startAutoTunnel()
-                    } else {
-                        val previouslyActiveTuns = appDataRepository.tunnels.getActive()
-                        val tunsToStart =
-                            previouslyActiveTuns.filterNot { tun ->
-                                activeTunnels.value.any { tun.id == it.key.id }
-                            }
-                        tunsToStart.forEach { startTunnel(it) }
-                    }
+                    handleLockDownModeInit(settings.isLanOnKillSwitchEnabled)
                 }
             }
             .map { (_, backend) -> backend }
@@ -115,17 +96,83 @@ constructor(
             )
     }
 
-    override val activeTunnels: StateFlow<Map<TunnelConf, TunnelState>> =
+    override val activeTunnels: StateFlow<Map<Int, TunnelState>> = run {
+        val activeTunsReference: AtomicReference<Map<Int, TunnelState>> =
+            AtomicReference(emptyMap())
         tunnelProviderFlow
-            .flatMapLatest { it.activeTunnels }
+            .flatMapLatest { backend ->
+                // Create a new channel for each backend to reset side-effect processing
+                val newChannel = Channel<SideEffectState>(Channel.CONFLATED)
+                sideEffectChannelFlow.value = newChannel
+
+                val sideEffects =
+                    listOf(
+                        SideEffectWithCondition(
+                            effect = { s ->
+                                handleTunnelServiceChange(s.settings.appMode, s.activeTuns)
+                            },
+                            condition = { s -> s.activeTuns.size != s.previouslyActive.size },
+                        ),
+                        SideEffectWithCondition(
+                            effect = { s ->
+                                handleActiveTunnelsChange(s.previouslyActive, s.activeTuns, s.tuns)
+                            },
+                            condition = { s -> s.activeTuns.size != s.previouslyActive.size },
+                        ),
+                        // TODO Not for kernel mode for now
+                        SideEffectWithCondition(
+                            effect = { s -> handleTunnelMonitoringChanges(s.activeTuns, s.tuns) },
+                            condition = { s ->
+                                s.tuns.any {
+                                    it.restartOnPingFailure && s.activeTuns.keys.contains(it.id)
+                                } && s.settings.appMode != AppMode.KERNEL
+                            },
+                        ),
+                    )
+
+                applicationScope.launch(ioDispatcher) {
+                    for (state in newChannel) {
+                        supervisorScope {
+                            sideEffects
+                                .filter { it.condition(state) }
+                                .forEach { sideEffect ->
+                                    launch {
+                                        try {
+                                            sideEffect.effect(state)
+                                        } catch (e: Exception) {
+                                            Timber.e(e, "Side effect failed")
+                                        }
+                                    }
+                                }
+                        }
+                    }
+                }
+
+                combine(
+                    backend.activeTunnels,
+                    appDataRepository.tunnels.flow,
+                    appDataRepository.settings.flow.filterNotNull(),
+                ) { activeTuns, tuns, settings ->
+                    Triple(activeTuns, tuns, settings)
+                }
+            }
+            .onStart { handleStateRestore() }
+            .onEach { (activeTuns, tuns, settings) ->
+                val previouslyActive = activeTunsReference.exchange(activeTuns)
+                sideEffectChannelFlow.value.trySend(
+                    SideEffectState(activeTuns, tuns, settings, previouslyActive)
+                )
+            }
+            .map { (activeTuns, _, _) -> activeTuns }
             .stateIn(
-                scope = applicationScope.plus(ioDispatcher),
+                scope = applicationScope,
                 started = SharingStarted.Eagerly,
                 initialValue = emptyMap(),
             )
+    }
 
     @OptIn(ExperimentalCoroutinesApi::class)
-    override val errorEvents: SharedFlow<Pair<TunnelConf, BackendCoreException>> =
+    override val errorEvents: SharedFlow<Pair<String, BackendCoreException>> =
         tunnelProviderFlow
             .flatMapLatest { it.errorEvents }
             .shareIn(
@@ -135,37 +182,36 @@ constructor(
             )
 
     @OptIn(ExperimentalCoroutinesApi::class)
-    override val messageEvents: SharedFlow<Pair<TunnelConf, BackendMessage>> =
+    override val messageEvents: SharedFlow<Pair<String, BackendMessage>> =
         tunnelProviderFlow
             .flatMapLatest { it.messageEvents }
-            .filterNotNull()
             .shareIn(
                 scope = applicationScope.plus(ioDispatcher),
                 started = SharingStarted.Eagerly,
                 replay = 0,
             )
 
-    override val bouncingTunnelIds: ConcurrentHashMap<Int, TunnelStatus.StopReason> =
-        tunnelProviderFlow.value.bouncingTunnelIds
-
     override fun hasVpnPermission(): Boolean {
         return userspaceTunnel.hasVpnPermission()
     }
 
-    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
-        return tunnelProviderFlow.value.getStatistics(tunnelConf)
+    override fun getStatistics(tunnelId: Int): TunnelStatistics? {
+        return tunnelProviderFlow.value.getStatistics(tunnelId)
     }
 
     override suspend fun startTunnel(tunnelConf: TunnelConf) {
+        // for VPN Mode, we need to stop active tunnels as we can only have one active at a time
+        if (activeTunnels.value.isNotEmpty() && tunnelProviderFlow.value == userspaceTunnel)
+            stopActiveTunnels()
         tunnelProviderFlow.value.startTunnel(tunnelConf)
     }
 
-    override suspend fun stopTunnel(tunnelConf: TunnelConf?, reason: TunnelStatus.StopReason) {
-        tunnelProviderFlow.value.stopTunnel(tunnelConf, reason)
+    override suspend fun stopTunnel(tunnelId: Int) {
+        tunnelProviderFlow.value.stopTunnel(tunnelId)
     }
 
-    override suspend fun bounceTunnel(tunnelConf: TunnelConf, reason: TunnelStatus.StopReason) {
-        tunnelProviderFlow.value.bounceTunnel(tunnelConf, reason)
+    override suspend fun stopActiveTunnels() {
+        tunnelProviderFlow.value.stopActiveTunnels()
     }
 
     override fun setBackendMode(backendMode: BackendMode) {
@@ -180,19 +226,141 @@ constructor(
         return tunnelProviderFlow.value.runningTunnelNames()
     }
 
+    override fun handleDnsReresolve(tunnelConf: TunnelConf): Boolean {
+        return tunnelProviderFlow.value.handleDnsReresolve(tunnelConf)
+    }
+
     override suspend fun updateTunnelStatus(
-        tunnelConf: TunnelConf,
+        tunnelId: Int,
         status: TunnelStatus?,
         stats: TunnelStatistics?,
         pingStates: Map<Key, PingState>?,
-        handshakeSuccessLogs: Boolean?,
+        logHealthState: LogHealthState?,
     ) {
         tunnelProviderFlow.value.updateTunnelStatus(
-            tunnelConf,
+            tunnelId,
             status,
             stats,
             pingStates,
-            handshakeSuccessLogs,
+            logHealthState,
         )
     }
+
+    private suspend fun handleTunnelServiceChange(
+        appMode: AppMode,
+        activeTuns: Map<Int, TunnelState>,
+    ) {
+        if (activeTuns.isEmpty()) serviceManager.stopTunnelService()
+        if (activeTuns.isNotEmpty() && serviceManager.tunnelService.value == null)
+            serviceManager.startTunnelService(appMode)
+    }
+
+    private fun handleLockDownModeInit(withLanBypass: Boolean) {
+        val allowedIps = if (withLanBypass) TunnelConf.IPV4_PUBLIC_NETWORKS else emptySet()
+        try {
+            // TODO handle situation where they don't have vpn permission, request it
+            if (hasVpnPermission()) {
+                proxyUserspaceTunnel.setBackendMode(BackendMode.KillSwitch(allowedIps))
+            }
+        } catch (e: BackendCoreException) {
+            // TODO expose this error to user
+            Timber.e(e)
+        }
+    }
+
+    private suspend fun handleModeChangeCleanup(
+        previousBackend: TunnelProvider,
+        previousAppMode: AppMode,
+    ) {
+        previousBackend.stopActiveTunnels()
+        // stop lockdown if we switch from that mode
+        if (previousAppMode == AppMode.LOCK_DOWN)
+            proxyUserspaceTunnel.setBackendMode(BackendMode.Inactive)
+    }
+
+    private suspend fun handleStateRestore() {
+        val settings = appDataRepository.settings.flow.first()
+        if (settings.isRestoreOnBootEnabled) {
+            // if auto tun enabled, reset active and restore auto tun, letting it start appropriate
+            // tuns
+            if (settings.isAutoTunnelEnabled) {
+                appDataRepository.tunnels.resetActiveTunnels()
+                return serviceManager.startAutoTunnel()
+            }
+            val tunnels = appDataRepository.tunnels.flow.first()
+            when (settings.appMode) {
+                // TODO eventually, lockdown/proxy can support multi
+                AppMode.VPN,
+                AppMode.LOCK_DOWN,
+                AppMode.PROXY ->
+                    tunnels
+                        .firstOrNull { it.isActive }
+                        ?.let {
+                            // clear any duplicates
+                            appDataRepository.tunnels.resetActiveTunnels()
+                            startTunnel(it)
+                        }
+                // kernel supports multi
+                AppMode.KERNEL ->
+                    tunnels.filter { it.isActive }.forEach { conf -> startTunnel(conf) }
+            }
+        }
+    }
+
+    private suspend fun handleTunnelMonitoringChanges(
+        activeTuns: Map<Int, TunnelState>,
+        configs: List<TunnelConf>,
+    ) {
+        configs
+            .filter { it.restartOnPingFailure && activeTuns.keys.contains(it.id) }
+            .forEach { conf ->
+                val tunState = activeTuns[conf.id] ?: return@forEach
+                if (tunState.health() == TunnelState.Health.UNHEALTHY) {
+                    runCatching {
+                            val updated = handleDnsReresolve(conf)
+                            // TODO user messages
+                            if (updated) {
+                                Timber.i("Successfully update the peer endpoint to new address.")
+                            } else {
+                                Timber.i("Current endpoint address is already up to date.")
+                            }
+                        }
+                        .onFailure {
+                            Timber.e(it, "Failed to handle dns re-resolution for ${conf.tunName}")
+                        }
+                    // TODO backoff
+                    delay(30_000L)
+                }
+            }
+    }
+
+    private suspend fun handleActiveTunnelsChange(
+        previousActiveTuns: Map<Int, TunnelState>,
+        activeTuns: Map<Int, TunnelState>,
+        tuns: List<TunnelConf>,
+    ) {
+        val relevantTunnels = previousActiveTuns.keys + activeTuns.keys
+
+        relevantTunnels.forEach { tunnelId ->
+            val wasActive = previousActiveTuns.containsKey(tunnelId)
+            val isActiveNow = activeTuns.containsKey(tunnelId)
+
+            when {
+                !wasActive && isActiveNow -> {
+                    tuns
+                        .find { it.id == tunnelId }
+                        ?.let { dbTunnelConf ->
+                            appDataRepository.tunnels.save(dbTunnelConf.copy(isActive = true))
+                        }
+                }
+                wasActive && !isActiveNow -> {
+                    tuns
+                        .find { it.id == tunnelId }
+                        ?.let { dbTunnelConf ->
+                            appDataRepository.tunnels.save(dbTunnelConf.copy(isActive = false))
+                        }
+                }
+            }
+        }
+    }
 }

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

@@ -2,10 +2,12 @@ package com.zaneschepke.wireguardautotunnel.core.tunnel
 
 import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.networkmonitor.NetworkMonitor
+import com.zaneschepke.wireguardautotunnel.data.model.AppMode
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.FailureReason
+import com.zaneschepke.wireguardautotunnel.domain.state.LogHealthState
 import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.util.extensions.toMillis
 import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
@@ -29,56 +31,43 @@ constructor(
 ) {
 
     @OptIn(FlowPreview::class)
-    suspend fun startMonitoring(tunnelConf: TunnelConf, withLogs: Boolean): Job = coroutineScope {
+    suspend fun startMonitoring(tunnelId: Int, withLogs: Boolean): Job = coroutineScope {
         launch {
-            launch { startTunnelConfChangesJob(tunnelConf) }
-            launch { startPingMonitor(tunnelConf) }
-            launch { startWgStatsPoll(tunnelConf) }
-            if (withLogs) launch { startLogsMonitor(tunnelConf) }
+            val config = appDataRepository.tunnels.getById(tunnelId) ?: return@launch
+            launch { startPingMonitor(config) }
+            launch { startWgStatsPoll(config.id) }
+            if (withLogs) launch { startLogsMonitor(config) }
         }
     }
 
-    private suspend fun startTunnelConfChangesJob(tunnelConf: TunnelConf) {
-        appDataRepository.tunnels.flow
-            .map { storedTunnels -> storedTunnels.firstOrNull { it.id == tunnelConf.id } }
-            .filterNotNull()
-            .distinctUntilChanged { old, new -> old == new }
-            .collect { storedTunnel ->
-                if (tunnelConf != storedTunnel) {
-                    Timber.d("Config changed for ${storedTunnel.tunName}, bouncing")
-                    withContext(NonCancellable) {
-                        tunnelManager.bounceTunnel(
-                            storedTunnel,
-                            TunnelStatus.StopReason.ConfigChanged,
-                        )
-                    }
-                }
-            }
-    }
-
     private suspend fun startLogsMonitor(tunnelConf: TunnelConf) {
-        logReader.liveLogs.collect { log ->
-            val healthLogs =
+        logReader.liveLogs
+            .filter { log -> log.tag.contains(tunnelConf.tunName) }
+            .mapNotNull { log ->
+                val now = System.currentTimeMillis()
+
                 when {
-                    log.message.contains(HANDSHAKE_RESPONSE_TEXT, true) ||
-                        log.message.contains(KEEPALIVE_RESPONSE_TEXT, true) -> true
-                    log.message.contains(HANDSHAKE_INIT_FAILED_TEXT, true) ||
-                        log.message.contains(HANDSHAKE_NOT_COMPLETED_TEXT) ||
-                        log.message.contains(DATA_PACKET_FAILED_TEXT) -> false
+                    successLogRegex.containsMatchIn(log.message) ->
+                        LogHealthState(isHealthy = true, timestamp = now)
+
+                    failureLogRegex.containsMatchIn(log.message) ->
+                        LogHealthState(isHealthy = false, timestamp = now)
 
                     else -> null
                 }
-            healthLogs?.let { healthy ->
-                tunnelManager.updateTunnelStatus(tunnelConf, null, null, null, healthy)
             }
-        }
+            .distinctUntilChangedBy { it.isHealthy } // Only emit when health changes
+            .collect { logHealthState ->
+                Timber.d("Tunnel log health updated for ${tunnelConf.tunName}: $logHealthState")
+                tunnelManager.updateTunnelStatus(tunnelConf.id, logHealthState = logHealthState)
+            }
     }
 
     private suspend fun startPingMonitor(tunnelConf: TunnelConf) = coroutineScope {
         val pingStatsFlow = MutableStateFlow<Map<Key, PingState>>(emptyMap())
 
         val tunStateFlow =
-            tunnelManager.activeTunnels.mapNotNull { it.getValueById(tunnelConf.id) }.stateIn(this)
+            tunnelManager.activeTunnels.mapNotNull { it[tunnelConf.id] }.stateIn(this)
 
         val connectivityStateFlow = networkMonitor.connectivityStateFlow.stateIn(this)
 
@@ -109,9 +98,13 @@ constructor(
                     old.tunnelPingIntervalSeconds == new.tunnelPingIntervalSeconds &&
                     old.tunnelPingAttempts == new.tunnelPingAttempts &&
                     old.tunnelPingTimeoutSeconds == new.tunnelPingTimeoutSeconds
+                old.appMode == new.appMode
             }
             .collectLatest { settings ->
                 if (!settings.isPingEnabled) return@collectLatest
+                // TODO for now until we get monitoring for these modes
+                if (settings.appMode == AppMode.LOCK_DOWN || settings.appMode == AppMode.PROXY)
+                    return@collectLatest
 
                 Timber.d("Starting pinger for ${tunnelConf.tunName} with settings")
 
@@ -210,7 +203,7 @@ constructor(
 
                     if (updates.isNotEmpty()) {
                         pingStatsFlow.update { updates }
-                        tunnelManager.updateTunnelStatus(tunnelConf, null, null, updates)
+                        tunnelManager.updateTunnelStatus(tunnelConf.id, null, null, updates)
                     }
                 }
 
@@ -234,7 +227,7 @@ constructor(
                             }
                         }
                         tunnelManager.updateTunnelStatus(
-                            tunnelConf,
+                            tunnelConf.id,
                             null,
                             null,
                             pingStatsFlow.value,
@@ -245,15 +238,27 @@ constructor(
             }
     }
 
-    private suspend fun startWgStatsPoll(tunnelConf: TunnelConf) = coroutineScope {
+    private suspend fun startWgStatsPoll(tunnelId: Int) = coroutineScope {
         while (isActive) {
-            val stats = tunnelManager.getStatistics(tunnelConf)
-            tunnelManager.updateTunnelStatus(tunnelConf, null, stats, null)
+            val stats = tunnelManager.getStatistics(tunnelId)
+            tunnelManager.updateTunnelStatus(tunnelId, null, stats, null)
             delay(STATS_DELAY)
         }
     }
 
     companion object {
+
+        private val successLogRegex =
+            Regex("Received handshake response|Receiving keepalive packet", RegexOption.IGNORE_CASE)
+
+        private val failureLogRegex =
+            Regex(
+                "Failed to send handshake initiation: write udp|" +
+                    "Handshake did not complete after 5 seconds, retrying|" +
+                    "Failed to send data packets",
+                RegexOption.IGNORE_CASE,
+            )
+
         const val CLOUDFLARE_IPV6_IP = "2606:4700:4700::1111"
         const val CLOUDFLARE_IPV4_IP = "1.1.1.1"
 

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

@@ -5,10 +5,10 @@ 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.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.state.LogHealthState
 import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
-import java.util.concurrent.ConcurrentHashMap
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.StateFlow
 import org.amnezia.awg.crypto.Key
@@ -18,28 +18,14 @@ interface TunnelProvider {
     suspend fun startTunnel(tunnelConf: TunnelConf)
 
     /**
-     * Stops the specified tunnel, or all tunnels if none is provided.
+     * Stops the specified tunnel.
      *
-     * @param tunnelConf The tunnel to stop, or null to stop all active tunnels.
-     * @param reason The reason for stopping, defaults to USER for manual stops. Callers should
-     *   override with specific reasons (e.g., PING, CONFIG_CHANGED) when applicable.
+     * @param tunnelId The tunnelConf to stop.
      */
-    suspend fun stopTunnel(
-        tunnelConf: TunnelConf? = null,
-        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.User,
-    )
+    suspend fun stopTunnel(tunnelId: Int)
 
-    /**
-     * Bounces (stops and restarts) the specified tunnel.
-     *
-     * @param tunnelConf The tunnel to bounce.
-     * @param reason The reason for bouncing, defaults to User for manual actions. Callers should
-     *   override with specific reasons (e.g., Ping, ConfigChanged) when applicable.
-     */
-    suspend fun bounceTunnel(
-        tunnelConf: TunnelConf,
-        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.User,
-    )
+    /** Stops all active tunnels. */
+    suspend fun stopActiveTunnels()
 
     fun setBackendMode(backendMode: BackendMode)
 
@@ -47,23 +33,23 @@ interface TunnelProvider {
 
     suspend fun runningTunnelNames(): Set<String>
 
-    fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics?
+    fun handleDnsReresolve(tunnelConf: TunnelConf): Boolean
 
-    val activeTunnels: StateFlow<Map<TunnelConf, TunnelState>>
+    fun getStatistics(tunnelId: Int): TunnelStatistics?
 
-    val errorEvents: SharedFlow<Pair<TunnelConf, BackendCoreException>>
+    val activeTunnels: StateFlow<Map<Int, TunnelState>>
 
-    val messageEvents: SharedFlow<Pair<TunnelConf, BackendMessage>>
+    val errorEvents: SharedFlow<Pair<String, BackendCoreException>>
 
-    val bouncingTunnelIds: ConcurrentHashMap<Int, TunnelStatus.StopReason>
+    val messageEvents: SharedFlow<Pair<String, BackendMessage>>
 
     fun hasVpnPermission(): Boolean
 
     suspend fun updateTunnelStatus(
-        tunnelConf: TunnelConf,
+        tunnelId: Int,
         status: TunnelStatus? = null,
         stats: TunnelStatistics? = null,
         pingStates: Map<Key, PingState>? = null,
-        handshakeSuccessLogs: Boolean? = null,
+        logHealthState: LogHealthState? = null,
     )
 }

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

@@ -2,6 +2,7 @@ package com.zaneschepke.wireguardautotunnel.core.tunnel
 
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.data.model.DnsProtocol
+import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendMode
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
 import com.zaneschepke.wireguardautotunnel.domain.events.BackendCoreException
@@ -12,15 +13,23 @@ import com.zaneschepke.wireguardautotunnel.domain.state.AmneziaStatistics
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.util.extensions.asAmBackendMode
 import com.zaneschepke.wireguardautotunnel.util.extensions.asBackendMode
+import com.zaneschepke.wireguardautotunnel.util.extensions.asTunnelState
 import com.zaneschepke.wireguardautotunnel.util.extensions.toBackendCoreException
 import java.io.IOException
 import java.util.*
+import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.consumeAsFlow
+import kotlinx.coroutines.launch
 import org.amnezia.awg.backend.Backend
 import org.amnezia.awg.backend.BackendException
 import org.amnezia.awg.backend.ProxyGoBackend
-import org.amnezia.awg.backend.Tunnel
+import org.amnezia.awg.backend.Tunnel as AwgTunnel
 import org.amnezia.awg.config.Config
 import org.amnezia.awg.config.DnsSettings
 import org.amnezia.awg.config.proxy.HttpProxy
@@ -31,15 +40,26 @@ import timber.log.Timber
 class UserspaceTunnel
 @Inject
 constructor(
-    applicationScope: CoroutineScope,
-    val serviceManager: ServiceManager,
-    val appDataRepository: AppDataRepository,
+    @ApplicationScope applicationScope: CoroutineScope,
+    serviceManager: ServiceManager,
+    appDataRepository: AppDataRepository,
     private val backend: Backend,
 ) : BaseTunnel(applicationScope, appDataRepository, serviceManager) {
 
-    override suspend fun startBackend(tunnel: TunnelConf) {
+    private val runtimeTunnels = ConcurrentHashMap<Int, AwgTunnel>()
+
+    override fun tunnelStateFlow(tunnelConf: TunnelConf): Flow<TunnelStatus> = callbackFlow {
+        val stateChannel = Channel<AwgTunnel.State>()
+
+        val runtimeTunnel = RuntimeAwgTunnel(tunnelConf, stateChannel)
+        runtimeTunnels[tunnelConf.id] = runtimeTunnel
+
+        val consumerJob = launch {
+            stateChannel.consumeAsFlow().collect { awgState -> trySend(awgState.asTunnelState()) }
+        }
+
         try {
-            updateTunnelStatus(tunnel, TunnelStatus.Starting)
+            updateTunnelStatus(tunnelConf.id, TunnelStatus.Starting)
 
             val proxies: List<Proxy> =
                 when (backend) {
@@ -72,7 +92,7 @@ constructor(
                     else -> emptyList()
                 }
             val setting = appDataRepository.settings.get()
-            val config = tunnel.toAmConfig()
+            val config = tunnelConf.toAmConfig()
             val updatedConfig =
                 Config.Builder()
                     .apply {
@@ -87,23 +107,28 @@ constructor(
                         )
                     }
                     .build()
-            backend.setState(tunnel, Tunnel.State.UP, updatedConfig)
+            backend.setState(runtimeTunnel, AwgTunnel.State.UP, updatedConfig)
         } catch (e: BackendException) {
-            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
-            throw e.toBackendCoreException()
+            close(e.toBackendCoreException())
         } catch (e: IllegalArgumentException) {
-            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
-            throw BackendCoreException.Config
+            close(BackendCoreException.Config)
+        } catch (e: Exception) {
+            Timber.e(e, "Error while setting tunnel state")
+            close(BackendCoreException.Unknown)
         }
-    }
 
-    override fun stopBackend(tunnel: TunnelConf) {
-        Timber.i("Stopping tunnel ${tunnel.name} userspace")
-        try {
-            backend.setState(tunnel, Tunnel.State.DOWN, tunnel.toAmConfig())
-        } catch (e: BackendException) {
-            Timber.e(e, "Failed to stop tunnel ${tunnel.id}")
-            throw e.toBackendCoreException()
+        awaitClose {
+            try {
+                backend.setState(runtimeTunnel, AwgTunnel.State.DOWN, null)
+            } catch (e: BackendException) {
+                errors.tryEmit(tunnelConf.tunName to e.toBackendCoreException())
+            } finally {
+                consumerJob.cancel()
+                stateChannel.close()
+                runtimeTunnels.remove(tunnelConf.id)
+                trySend(TunnelStatus.Down)
+                close()
+            }
         }
     }
 
@@ -123,15 +148,22 @@ constructor(
         return backend.backendMode.asBackendMode()
     }
 
+    override fun handleDnsReresolve(tunnelConf: TunnelConf): Boolean {
+        val tunnel =
+            runtimeTunnels.get(tunnelConf.id) ?: throw BackendCoreException.ServiceNotRunning
+        return backend.resolveDDNS(tunnelConf.toAmConfig(), tunnel.isIpv4ResolutionPreferred)
+    }
+
     override suspend fun runningTunnelNames(): Set<String> {
         return backend.runningTunnelNames
     }
 
-    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
+    override fun getStatistics(tunnelId: Int): TunnelStatistics? {
         return try {
-            AmneziaStatistics(backend.getStatistics(tunnelConf))
+            val runtimeTunnel = runtimeTunnels[tunnelId] ?: return null
+            AmneziaStatistics(backend.getStatistics(runtimeTunnel))
         } catch (e: Exception) {
-            Timber.e(e, "Failed to get stats for ${tunnelConf.tunName}")
+            Timber.e(e, "Failed to get stats for $tunnelId")
             null
         }
     }

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

@@ -13,6 +13,9 @@ interface TunnelConfigDao {
 
     @Query("SELECT * FROM TunnelConfig WHERE id=:id") suspend fun getById(id: Long): TunnelConfig?
 
+    @Query("UPDATE TunnelConfig SET is_Active = 0 WHERE is_Active = 1")
+    suspend fun resetActiveTunnels()
+
     @Query("SELECT * FROM TunnelConfig WHERE name=:name")
     suspend fun getByName(name: String): TunnelConfig?
 

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

@@ -46,6 +46,10 @@ class RoomTunnelRepository(
         }
     }
 
+    override suspend fun resetActiveTunnels() {
+        withContext(ioDispatcher) { tunnelConfigDao.resetActiveTunnels() }
+    }
+
     override suspend fun updateMobileDataTunnel(tunnelConf: TunnelConf?) {
         withContext(ioDispatcher) {
             tunnelConfigDao.resetMobileDataTunnel()

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

@@ -2,14 +2,14 @@ package com.zaneschepke.wireguardautotunnel.di
 
 import javax.inject.Qualifier
 
-@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class DefaultDispatcher
+@Retention(AnnotationRetention.BINARY) @Qualifier annotation class DefaultDispatcher
 
-@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class IoDispatcher
+@Retention(AnnotationRetention.BINARY) @Qualifier annotation class IoDispatcher
 
-@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class MainDispatcher
+@Retention(AnnotationRetention.BINARY) @Qualifier annotation class MainDispatcher
 
 @Retention(AnnotationRetention.BINARY) @Qualifier annotation class MainImmediateDispatcher
 
-@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class ApplicationScope
+@Retention(AnnotationRetention.BINARY) @Qualifier annotation class ApplicationScope
 
-@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class ServiceScope
+@Retention(AnnotationRetention.BINARY) @Qualifier annotation class ServiceScope

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/enums/TunnelStatus.kt

@@ -6,18 +6,10 @@ sealed class TunnelStatus {
 
     data object Down : TunnelStatus()
 
-    data class Stopping(val reason: StopReason) : TunnelStatus()
+    data object Stopping : TunnelStatus()
 
     data object Starting : TunnelStatus()
 
-    sealed class StopReason {
-        data object User : StopReason()
-
-        data class Ping(val previouslyResolvedEndpoints: Map<String, String?>) : StopReason()
-
-        data object ConfigChanged : StopReason()
-    }
-
     fun isDown(): Boolean {
         return this == Down
     }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/events/AutoTunnelEvent.kt

@@ -5,9 +5,6 @@ import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 sealed class AutoTunnelEvent {
     data class Start(val tunnelConf: TunnelConf? = null) : AutoTunnelEvent()
 
-    data class Bounce(val configsPeerKeyResolvedMap: List<Pair<TunnelConf, Map<String, String?>>>) :
-        AutoTunnelEvent()
-
     data object Stop : AutoTunnelEvent()
 
     data object DoNothing : AutoTunnelEvent()

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/events/BackendCoreException.kt

@@ -20,6 +20,8 @@ sealed class BackendCoreException : Exception() {
 
     data object TunnelNameTooLong : BackendCoreException()
 
+    data object UapiUpdateFailed : BackendCoreException()
+
     data class BounceFailed(val error: BackendCoreException) : BackendCoreException()
 
     fun toStringRes() =
@@ -33,6 +35,7 @@ sealed class BackendCoreException : Exception() {
             Unknown -> R.string.unknown_error
             TunnelNameTooLong -> R.string.error_tunnel_name
             is BounceFailed -> R.string.bounce_failed_template
+            UapiUpdateFailed -> R.string.active_tunnel_update_failed
         }
 
     fun toStringValue(): StringValue {

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

@@ -1,14 +1,12 @@
 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 com.zaneschepke.wireguardautotunnel.util.extensions.defaultName
+import com.zaneschepke.wireguardautotunnel.util.extensions.isValidIpv4orIpv6Address
+import com.zaneschepke.wireguardautotunnel.util.extensions.toWgQuickString
 import java.io.InputStream
 import java.nio.charset.StandardCharsets
-import kotlinx.parcelize.Parcelize
 
-@Parcelize
 data class TunnelConf(
     val id: Int = 0,
     val tunName: String,
@@ -23,14 +21,9 @@ data class TunnelConf(
     val isEthernetTunnel: Boolean = false,
     val isIpv4Preferred: Boolean = true,
     val position: Int = 0,
-    @Transient private var stateChangeCallback: ((Any) -> Unit)? = null,
-) : Tunnel, org.amnezia.awg.backend.Tunnel, Parcelable {
+) {
 
-    val isNameKernelCompatible: Boolean = (name.length <= 15)
-
-    fun setStateChangeCallback(callback: (Any) -> Unit) {
-        stateChangeCallback = callback
-    }
+    val isNameKernelCompatible: Boolean = (tunName.length <= 15)
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -60,38 +53,6 @@ data class TunnelConf(
         return toAmConfig().peers.all { it.endpoint.get().host.isValidIpv4orIpv6Address() }
     }
 
-    fun copyWithCallback(
-        id: Int = this.id,
-        tunName: String = this.tunName,
-        wgQuick: String = this.wgQuick,
-        tunnelNetworks: Set<String> = this.tunnelNetworks,
-        isMobileDataTunnel: Boolean = this.isMobileDataTunnel,
-        isPrimaryTunnel: Boolean = this.isPrimaryTunnel,
-        amQuick: String = this.amQuick,
-        isActive: Boolean = this.isActive,
-        restartOnPingFailure: Boolean = this.restartOnPingFailure,
-        pingIp: String? = this.pingTarget,
-        isEthernetTunnel: Boolean = this.isEthernetTunnel,
-        isIpv4Preferred: Boolean = this.isIpv4Preferred,
-    ): TunnelConf {
-        return TunnelConf(
-                id,
-                tunName,
-                wgQuick,
-                tunnelNetworks,
-                isMobileDataTunnel,
-                isPrimaryTunnel,
-                amQuick,
-                isActive,
-                pingIp,
-                restartOnPingFailure,
-                isEthernetTunnel,
-                isIpv4Preferred,
-                position,
-            )
-            .apply { stateChangeCallback = this@TunnelConf.stateChangeCallback }
-    }
-
     fun toAmConfig(): org.amnezia.awg.config.Config {
         return configFromAmQuick(amQuick.ifBlank { wgQuick })
     }
@@ -100,36 +61,6 @@ data class TunnelConf(
         return configFromWgQuick(wgQuick)
     }
 
-    override fun getName(): String = tunName
-
-    override fun onStateChange(newState: org.amnezia.awg.backend.Tunnel.State) {
-        stateChangeCallback?.invoke(newState)
-    }
-
-    override fun onStateChange(newState: Tunnel.State) {
-        stateChangeCallback?.invoke(newState)
-    }
-
-    override fun isIpv4ResolutionPreferred(): Boolean {
-        return true
-    }
-
-    fun generateUniqueName(tunnelNames: List<String>): String {
-        var tunnelName = this.tunName
-        var num = 1
-        while (tunnelNames.any { it == tunnelName }) {
-            tunnelName =
-                if (!tunnelName.hasNumberInParentheses()) {
-                    "$name($num)"
-                } else {
-                    val pair = tunnelName.extractNameAndNumber()
-                    "${pair?.first}($num)"
-                }
-            num++
-        }
-        return tunnelName
-    }
-
     companion object {
         fun configFromWgQuick(wgQuick: String): Config {
             val inputStream: InputStream = wgQuick.byteInputStream()

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

@@ -15,6 +15,8 @@ interface TunnelRepository {
 
     suspend fun updatePrimaryTunnel(tunnelConf: TunnelConf?)
 
+    suspend fun resetActiveTunnels()
+
     suspend fun updateMobileDataTunnel(tunnelConf: TunnelConf?)
 
     suspend fun updateEthernetTunnel(tunnelConf: TunnelConf?)

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

@@ -2,20 +2,21 @@ 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.events.AutoTunnelEvent.DoNothing
+import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent.Start
 import com.zaneschepke.wireguardautotunnel.domain.model.GeneralSettings
 import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.util.extensions.isMatchingToWildcardList
 
 data class AutoTunnelState(
-    val activeTunnels: Map<TunnelConf, TunnelState> = emptyMap(),
+    val activeTunnels: Map<Int, TunnelState> = emptyMap(),
     val networkState: NetworkState = NetworkState(),
     val settings: GeneralSettings = GeneralSettings(),
     val tunnels: List<TunnelConf> = emptyList(),
 ) {
 
     fun determineAutoTunnelEvent(stateChange: StateChange): AutoTunnelEvent {
-        when (val change = stateChange) {
+        when (stateChange) {
             is StateChange.NetworkChange,
             is StateChange.SettingsChange -> {
                 // Compute desired tunnel based on network conditions
@@ -40,7 +41,7 @@ data class AutoTunnelState(
 
                 // Handle tunnel start/stop/change
                 if (desiredTunnel != null) {
-                    if (currentTunnel != desiredTunnel) {
+                    if (currentTunnel != desiredTunnel.id) {
                         // Start or switch to the desired tunnel (overrides any kill switch)
                         return Start(desiredTunnel)
                     }
@@ -54,12 +55,6 @@ data class AutoTunnelState(
                     }
                 }
             }
-            is StateChange.MonitoringChange -> {
-                val bounceTunnels = bounceOnPingFailed()
-                if (bounceTunnels.isNotEmpty()) {
-                    return Bounce(bounceTunnels)
-                }
-            }
 
             is StateChange.ActiveTunnelsChange -> Unit
         }
@@ -96,41 +91,12 @@ data class AutoTunnelState(
         return !networkState.isEthernetConnected && networkState.isWifiConnected
     }
 
-    private fun stopKillSwitchOnTrusted(): Boolean {
-        return networkState.isWifiConnected &&
-            settings.isVpnKillSwitchEnabled &&
-            settings.isDisableKillSwitchOnTrustedEnabled &&
-            isCurrentSSIDTrusted()
-    }
-
-    private fun startKillSwitch(): Boolean {
-        return settings.isVpnKillSwitchEnabled &&
-            (!settings.isDisableKillSwitchOnTrustedEnabled || !isCurrentSSIDTrusted())
-    }
-
     private fun isNoConnectivity(): Boolean {
         return !networkState.isEthernetConnected &&
             !networkState.isWifiConnected &&
             !networkState.isMobileDataConnected
     }
 
-    private fun bounceOnPingFailed(): List<Pair<TunnelConf, Map<String, String?>>> {
-        return activeTunnels.entries
-            .filter { (tunnel, state) ->
-                tunnel.restartOnPingFailure &&
-                    (state.pingStates?.any { (key, pingState) ->
-                        pingState.failureReason == FailureReason.PingFailed
-                    } ?: false)
-            }
-            .map { (tunnel, state) ->
-                val peerMap =
-                    (state.statistics?.getPeers()?.associate { peerKey ->
-                        peerKey.toBase64() to state.statistics.peerStats(peerKey)?.resolvedEndpoint
-                    } ?: emptyMap())
-                Pair(tunnel, peerMap)
-            }
-    }
-
     private fun isCurrentSSIDTrusted(): Boolean {
         return networkState.wifiName?.let { hasTrustedWifiName(it) } == true
     }

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

@@ -0,0 +1,3 @@
+package com.zaneschepke.wireguardautotunnel.domain.state
+
+data class LogHealthState(val isHealthy: Boolean, val timestamp: Long = System.currentTimeMillis())

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

@@ -9,5 +9,51 @@ data class TunnelState(
     val backendState: BackendMode = BackendMode.Inactive,
     val statistics: TunnelStatistics? = null,
     val pingStates: Map<Key, PingState>? = null,
-    val handshakeSuccessLogs: Boolean? = null,
-)
+    val logHealthState: LogHealthState? = null,
+) {
+
+    fun health(): Health {
+        val now = System.currentTimeMillis()
+
+        if (pingStates == null && logHealthState == null && statistics == null)
+            return Health.UNKNOWN
+
+        if (logHealthState?.isHealthy == false) return Health.UNHEALTHY
+
+        val healthLogs =
+            logHealthState?.isHealthy == true &&
+                (now - logHealthState.timestamp) <= LOG_HEALTH_SUCCESS_TIMEOUT_MS
+
+        if (pingStates?.any { !it.value.isReachable } == true) return Health.UNHEALTHY
+
+        if (statistics != null) {
+            if (statistics.isTunnelStale()) {
+                return Health.STALE
+            }
+            if ((logHealthState == null || !healthLogs) && pingStates == null) {
+                return Health.HEALTHY
+            }
+        } else {
+            if (!healthLogs) {
+                return Health.UNKNOWN
+            }
+        }
+
+        if (healthLogs) {
+            return Health.HEALTHY
+        }
+
+        return Health.UNKNOWN
+    }
+
+    enum class Health {
+        UNKNOWN,
+        UNHEALTHY,
+        HEALTHY,
+        STALE,
+    }
+
+    companion object {
+        const val LOG_HEALTH_SUCCESS_TIMEOUT_MS = 2 * 60 * 1000L // 2 minutes
+    }
+}

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

@@ -0,0 +1,19 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.button
+
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.Launch
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+
+@Composable
+fun LaunchButton(modifier: Modifier = Modifier.focusable(), onClick: () -> Unit) {
+    IconButton(modifier = modifier, onClick = onClick) {
+        val icon = Icons.AutoMirrored.Outlined.Launch
+        Icon(icon, icon.name, Modifier.size(iconSize))
+    }
+}

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

@@ -3,6 +3,7 @@ package com.zaneschepke.wireguardautotunnel.ui.common.button.surface
 import androidx.compose.foundation.layout.height
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 
 data class SelectionItem(
@@ -11,5 +12,9 @@ data class SelectionItem(
     val title: (@Composable () -> Unit),
     val description: (@Composable () -> Unit)? = null,
     val onClick: (() -> Unit)? = null,
-    val modifier: Modifier = Modifier.height(64.dp),
+    val isEnabled: Boolean = true,
+    val disabledReason: String? = null,
+    val modifier: Modifier = Modifier.height(48.dp),
+    val padding: Dp = if (description == null && disabledReason == null) 16.dp else 6.dp,
+    val onLongPress: (() -> Unit)? = null,
 )

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

@@ -1,65 +1,113 @@
 package com.zaneschepke.wireguardautotunnel.ui.common.button.surface
 
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 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.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.stateDescription
 import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
 
 @Composable
 fun SurfaceSelectionGroupButton(items: List<SelectionItem>, modifier: Modifier = Modifier) {
-
+    if (items.isEmpty()) return
+    val context = LocalContext.current
     Card(
         modifier = modifier.fillMaxWidth(),
         shape = RoundedCornerShape(8.dp),
         colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
     ) {
-        items.map { item ->
-            Box(
-                contentAlignment = Alignment.Center,
-                modifier =
-                    modifier
-                        .fillMaxWidth()
-                        .clip(RoundedCornerShape(8.dp))
-                        .then(item.onClick?.let { modifier.clickable { it() } } ?: modifier),
-            ) {
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp),
+        Column(
+            verticalArrangement = Arrangement.spacedBy(0.dp),
+            modifier = Modifier.fillMaxWidth(),
+        ) {
+            items.forEach { item ->
+                Box(
+                    contentAlignment = Alignment.Center,
+                    modifier =
+                        Modifier.fillMaxWidth()
+                            .clip(RoundedCornerShape(8.dp))
+                            .alpha(if (item.isEnabled) 1f else 0.6f)
+                            .semantics {
+                                if (!item.isEnabled) {
+                                    stateDescription =
+                                        item.disabledReason ?: context.getString(R.string.disabled)
+                                }
+                            }
+                            .combinedClickable(
+                                onClick = { item.onClick?.invoke() },
+                                onLongClick = { item.onLongPress?.invoke() },
+                                enabled = true,
+                            ),
                 ) {
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier.weight(4f, false).fillMaxWidth(),
+                        modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp),
                     ) {
-                        item.leading?.invoke()
-                        Column(
-                            horizontalAlignment = Alignment.Start,
-                            verticalArrangement =
-                                Arrangement.spacedBy(2.dp, Alignment.CenterVertically),
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
                             modifier =
-                                Modifier.fillMaxWidth()
-                                    .padding(start = if (item.leading != null) 16.dp else 0.dp)
-                                    .weight(1f)
-                                    .padding(
-                                        vertical = if (item.description == null) 16.dp else 6.dp
-                                    ),
+                                Modifier.weight(4f, false)
+                                    .fillMaxWidth()
+                                    .padding(vertical = item.padding),
                         ) {
-                            item.title()
-                            item.description?.let { it() }
+                            item.leading?.let {
+                                Box(modifier = Modifier.alpha(if (item.isEnabled) 1f else 0.6f)) {
+                                    it()
+                                }
+                            }
+                            Column(
+                                horizontalAlignment = Alignment.Start,
+                                verticalArrangement =
+                                    Arrangement.spacedBy(2.dp, Alignment.CenterVertically),
+                                modifier =
+                                    Modifier.fillMaxWidth()
+                                        .padding(start = if (item.leading != null) 16.dp else 0.dp)
+                                        .weight(1f),
+                            ) {
+                                Box(modifier = Modifier.alpha(if (item.isEnabled) 1f else 0.6f)) {
+                                    item.title()
+                                }
+                                item.description?.invoke()
+                                if (!item.isEnabled && item.disabledReason != null) {
+                                    Text(
+                                        text = item.disabledReason,
+                                        style = MaterialTheme.typography.bodySmall,
+                                        color =
+                                            MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f),
+                                    )
+                                }
+                            }
                         }
-                    }
-                    item.trailing?.let {
-                        Box(
-                            contentAlignment = Alignment.CenterEnd,
-                            modifier = Modifier.padding(start = 16.dp),
-                        ) {
-                            it()
+                        item.trailing?.let {
+                            Box(
+                                contentAlignment = Alignment.CenterEnd,
+                                modifier =
+                                    Modifier.padding(start = 16.dp)
+                                        .alpha(if (item.isEnabled) 1f else 0.6f)
+                                        .run {
+                                            if (!item.isEnabled) {
+                                                semantics {
+                                                    stateDescription =
+                                                        context.getString(R.string.disabled)
+                                                }
+                                            } else {
+                                                this
+                                            }
+                                        },
+                            ) {
+                                it()
+                            }
                         }
                     }
                 }

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

@@ -1,78 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common.prompt
-
-import androidx.biometric.BiometricManager
-import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_WEAK
-import androidx.biometric.BiometricManager.Authenticators.DEVICE_CREDENTIAL
-import androidx.biometric.BiometricPrompt
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.platform.LocalContext
-import androidx.core.content.ContextCompat
-import androidx.fragment.app.FragmentActivity
-import com.zaneschepke.wireguardautotunnel.R
-
-@Composable
-fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (String) -> Unit) {
-    val context = LocalContext.current
-    val biometricManager = BiometricManager.from(context)
-    val bio = biometricManager.canAuthenticate(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
-    val isBiometricAvailable = remember {
-        when (bio) {
-            BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> {
-                onError(context.getString(R.string.bio_not_created))
-                false
-            }
-
-            BiometricManager.BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED -> {
-                onError(context.getString(R.string.bio_update_required))
-                false
-            }
-
-            BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED,
-            BiometricManager.BIOMETRIC_STATUS_UNKNOWN,
-            BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE,
-            BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
-                onError(context.getString(R.string.bio_not_supported))
-                false
-            }
-
-            BiometricManager.BIOMETRIC_SUCCESS -> true
-            else -> false
-        }
-    }
-    if (isBiometricAvailable) {
-        val executor = remember { ContextCompat.getMainExecutor(context) }
-
-        val promptInfo =
-            BiometricPrompt.PromptInfo.Builder()
-                .setAllowedAuthenticators(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
-                .setTitle(context.getString(R.string.bio_auth_title))
-                .setSubtitle(context.getString(R.string.bio_subtitle))
-                .build()
-
-        val biometricPrompt =
-            BiometricPrompt(
-                context as FragmentActivity,
-                executor,
-                object : BiometricPrompt.AuthenticationCallback() {
-                    override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
-                        super.onAuthenticationError(errorCode, errString)
-                        onFailure()
-                    }
-
-                    override fun onAuthenticationSucceeded(
-                        result: BiometricPrompt.AuthenticationResult
-                    ) {
-                        super.onAuthenticationSucceeded(result)
-                        onSuccess()
-                    }
-
-                    override fun onAuthenticationFailed() {
-                        super.onAuthenticationFailed()
-                        onFailure()
-                    }
-                },
-            )
-        biometricPrompt.authenticate(promptInfo)
-    }
-}

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

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

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

@@ -17,7 +17,6 @@ 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
@@ -25,7 +24,6 @@ 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.theme.SilverTree
-import com.zaneschepke.wireguardautotunnel.util.extensions.debounce
 
 @Composable
 fun NavHostController.getCurrentGraph(): State<Route?> {
@@ -54,44 +52,32 @@ fun BottomNavbar(
 ) {
 
     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
-                }
-            }
-        }
 
     val items =
         listOf(
             BottomNavItem(
                 name = stringResource(R.string.tunnels),
                 icon = Icons.Rounded.Home,
-                onClick = { navigateToDebounced(Route.TunnelsGraph) },
+                onClick = { navController.navigate(Route.TunnelsGraph) },
                 route = Route.TunnelsGraph,
             ),
             BottomNavItem(
                 name = stringResource(R.string.auto_tunnel),
                 icon = Icons.Rounded.Bolt,
-                onClick = { navigateToDebounced(Route.AutoTunnelGraph) },
+                onClick = { navController.navigate(Route.AutoTunnelGraph) },
                 route = Route.AutoTunnelGraph,
                 active = isAutoTunnelActive,
             ),
             BottomNavItem(
                 name = stringResource(R.string.settings),
                 icon = Icons.Rounded.Settings,
-                onClick = { navigateToDebounced(Route.SettingsGraph) },
+                onClick = { navController.navigate(Route.SettingsGraph) },
                 route = Route.SettingsGraph,
             ),
             BottomNavItem(
                 name = stringResource(R.string.support),
                 icon = Icons.Rounded.QuestionMark,
-                onClick = { navigateToDebounced(Route.SupportGraph) },
+                onClick = { navController.navigate(Route.SupportGraph) },
                 route = Route.SupportGraph,
             ),
         )

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

@@ -0,0 +1,334 @@
+package com.zaneschepke.wireguardautotunnel.ui.navigation.components
+
+import android.os.Build
+import androidx.compose.foundation.layout.Row
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.rounded.Sort
+import androidx.compose.material.icons.rounded.*
+import androidx.compose.material3.Text
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.currentBackStackEntryAsState
+import androidx.navigation.toRoute
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
+import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.navigation.Route.Config
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
+import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.viewmodel.SharedAppViewModel
+
+@Composable
+fun NavHostController.currentBackStackEntryAsNavbarState(
+    sharedViewModel: SharedAppViewModel,
+    navController: NavHostController,
+): State<NavbarState> {
+    val sharedState by sharedViewModel.container.stateFlow.collectAsStateWithLifecycle()
+    val backStackEntry by currentBackStackEntryAsState()
+    val keyboardController = LocalSoftwareKeyboardController.current
+    val route =
+        remember(backStackEntry) {
+            backStackEntry?.destination?.route?.let {
+                when (it.substringBefore("?").substringBefore("/").substringAfterLast(".")) {
+                    Route.Support::class.simpleName -> backStackEntry?.toRoute<Route.Support>()
+                    Route.Lock::class.simpleName -> backStackEntry?.toRoute<Route.Lock>()
+                    Route.License::class.simpleName -> backStackEntry?.toRoute<Route.License>()
+                    Route.Logs::class.simpleName -> backStackEntry?.toRoute<Route.Logs>()
+                    Route.Appearance::class.simpleName ->
+                        backStackEntry?.toRoute<Route.Appearance>()
+                    Route.Language::class.simpleName -> backStackEntry?.toRoute<Route.Language>()
+                    Route.Display::class.simpleName -> backStackEntry?.toRoute<Route.Display>()
+                    Route.Tunnels::class.simpleName -> backStackEntry?.toRoute<Route.Tunnels>()
+                    Route.TunnelOptions::class.simpleName ->
+                        backStackEntry?.toRoute<Route.TunnelOptions>()
+                    Route.Config::class.simpleName -> backStackEntry?.toRoute<Route.Config>()
+                    Route.SplitTunnel::class.simpleName ->
+                        backStackEntry?.toRoute<Route.SplitTunnel>()
+                    Route.TunnelAutoTunnel::class.simpleName ->
+                        backStackEntry?.toRoute<Route.TunnelAutoTunnel>()
+                    Route.Sort::class.simpleName -> backStackEntry?.toRoute<Route.Sort>()
+                    Route.Settings::class.simpleName -> backStackEntry?.toRoute<Route.Settings>()
+                    Route.TunnelMonitoring::class.simpleName ->
+                        backStackEntry?.toRoute<Route.TunnelMonitoring>()
+                    Route.SystemFeatures::class.simpleName ->
+                        backStackEntry?.toRoute<Route.SystemFeatures>()
+                    Route.Dns::class.simpleName -> backStackEntry?.toRoute<Route.Dns>()
+                    Route.ProxySettings::class.simpleName ->
+                        backStackEntry?.toRoute<Route.ProxySettings>()
+                    Route.AutoTunnel::class.simpleName ->
+                        backStackEntry?.toRoute<Route.AutoTunnel>()
+                    Route.AdvancedAutoTunnel::class.simpleName ->
+                        backStackEntry?.toRoute<Route.AdvancedAutoTunnel>()
+                    Route.WifiDetectionMethod::class.simpleName ->
+                        backStackEntry?.toRoute<Route.WifiDetectionMethod>()
+                    Route.LocationDisclosure::class.simpleName ->
+                        backStackEntry?.toRoute<Route.LocationDisclosure>()
+                    Route.Donate::class.simpleName -> backStackEntry?.toRoute<Route.Donate>()
+                    Route.Addresses::class.simpleName -> backStackEntry?.toRoute<Route.Addresses>()
+                    else -> null
+                }
+            }
+        }
+
+    val disableDelete by
+        rememberSaveable(sharedState.selectedTunnels, sharedState.tunnels) {
+            mutableStateOf(
+                sharedState.tunnels.any { tunnel ->
+                    tunnel.isActive &&
+                        sharedState.tunnels.any { selected -> selected.id == tunnel.id }
+                }
+            )
+        }
+    val selectedCount by
+        rememberSaveable(sharedState.selectedTunnels) {
+            mutableStateOf(sharedState.selectedTunnels.size)
+        }
+
+    return produceState(initialValue = NavbarState(), route, selectedCount, disableDelete) {
+        value =
+            when (route) {
+                Route.AdvancedAutoTunnel ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.advanced_settings)) },
+                    )
+                Route.Appearance ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.appearance)) },
+                    )
+                Route.AutoTunnel ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.auto_tunnel)) },
+                    )
+                is Route.Config -> {
+                    val tunnel = sharedState.tunnels.find { it.id == route.id }
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = {
+                            val title = tunnel?.tunName ?: stringResource(R.string.new_tunnel)
+                            Text(title)
+                        },
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                keyboardController?.hide()
+                                sharedViewModel.postSideEffect(LocalSideEffect.SaveChanges)
+                            }
+                        },
+                    )
+                }
+                Route.Display ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.display_theme)) },
+                    )
+                Route.Dns ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.dns_settings)) },
+                    )
+                Route.Language ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.language)) },
+                    )
+                Route.License ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.licenses)) },
+                    )
+                Route.LocationDisclosure -> NavbarState(showBottomItems = true)
+                Route.Lock -> NavbarState(showBottomItems = false)
+                Route.Logs ->
+                    NavbarState(
+                        showBottomItems = false,
+                        removeBottom = true,
+                        topTitle = { Text(stringResource(R.string.logs)) },
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Menu, R.string.quick_actions) {
+                                sharedViewModel.postSideEffect(LocalSideEffect.Sheet.LoggerActions)
+                            }
+                        },
+                    )
+                Route.ProxySettings ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.proxy_settings)) },
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                keyboardController?.hide()
+                                sharedViewModel.postSideEffect(LocalSideEffect.SaveChanges)
+                            }
+                        },
+                    )
+                Route.Settings ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.settings)) },
+                        topTrailing = {
+                            ActionIconButton(
+                                Icons.Rounded.SettingsBackupRestore,
+                                R.string.quick_actions,
+                            ) {
+                                sharedViewModel.postSideEffect(LocalSideEffect.Sheet.BackupApp)
+                            }
+                        },
+                    )
+                Route.Sort ->
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(stringResource(R.string.sort)) },
+                        topTrailing = {
+                            Row {
+                                ActionIconButton(Icons.Rounded.SortByAlpha, R.string.sort) {
+                                    sharedViewModel.postSideEffect(LocalSideEffect.Sort)
+                                }
+                                ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                    sharedViewModel.postSideEffect(LocalSideEffect.SaveChanges)
+                                }
+                            }
+                        },
+                    )
+                is Route.SplitTunnel -> {
+                    val tunnel = sharedState.tunnels.find { it.id == route.id }
+                    NavbarState(
+                        topTitle = { Text(tunnel?.tunName ?: "") },
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                sharedViewModel.postSideEffect(LocalSideEffect.SaveChanges)
+                            }
+                        },
+                        showBottomItems = true,
+                    )
+                }
+                Route.Support ->
+                    NavbarState(
+                        topTitle = { Text(stringResource(R.string.support)) },
+                        showBottomItems = true,
+                    )
+                Route.SystemFeatures ->
+                    NavbarState(
+                        topTitle = { Text(stringResource(R.string.android_integrations)) },
+                        showBottomItems = true,
+                    )
+                is Route.TunnelAutoTunnel -> {
+                    val tunnel = sharedState.tunnels.find { it.id == route.id }
+                    NavbarState(showBottomItems = true, topTitle = { Text(tunnel?.tunName ?: "") })
+                }
+                Route.TunnelMonitoring ->
+                    NavbarState(
+                        topTitle = { Text(stringResource(R.string.tunnel_monitoring)) },
+                        showBottomItems = true,
+                    )
+                is Route.TunnelOptions -> {
+                    val tunnel = sharedState.tunnels.find { it.id == route.id }
+                    NavbarState(
+                        showBottomItems = true,
+                        topTitle = { Text(tunnel?.tunName ?: "") },
+                        topTrailing = {
+                            Row {
+                                ActionIconButton(Icons.Rounded.QrCode2, R.string.show_qr) {
+                                    sharedViewModel.postSideEffect(LocalSideEffect.Modal.QR)
+                                }
+                                ActionIconButton(Icons.Rounded.Edit, R.string.edit_tunnel) {
+                                    navigate(Config(route.id))
+                                }
+                            }
+                        },
+                    )
+                }
+                Route.Tunnels -> {
+                    NavbarState(
+                        topTitle = { Text(stringResource(R.string.tunnels)) },
+                        topTrailing = {
+                            when (selectedCount) {
+                                0 -> DefaultTunnelsActions(navController, sharedViewModel)
+                                else ->
+                                    Row {
+                                        ActionIconButton(
+                                            Icons.Rounded.SelectAll,
+                                            R.string.select_all,
+                                        ) {
+                                            sharedViewModel.toggleSelectAllTunnels()
+                                        }
+                                        // due to permissions, and SAF issues on TV, not support
+                                        // less than Android
+                                        // 10
+                                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                                            ActionIconButton(
+                                                Icons.Rounded.Download,
+                                                R.string.download,
+                                            ) {
+                                                sharedViewModel.postSideEffect(
+                                                    LocalSideEffect.Sheet.ExportTunnels
+                                                )
+                                            }
+                                        }
+
+                                        if (selectedCount == 1) {
+                                            ActionIconButton(Icons.Rounded.CopyAll, R.string.copy) {
+                                                sharedViewModel.copySelectedTunnel()
+                                            }
+                                        }
+
+                                        if (!disableDelete) {
+                                            ActionIconButton(
+                                                Icons.Rounded.Delete,
+                                                R.string.delete_tunnel,
+                                            ) {
+                                                sharedViewModel.postSideEffect(
+                                                    LocalSideEffect.Modal.DeleteTunnels
+                                                )
+                                            }
+                                        }
+                                    }
+                            }
+                        },
+                        showBottomItems = true,
+                    )
+                }
+                Route.WifiDetectionMethod ->
+                    NavbarState(
+                        topTitle = { Text(stringResource(R.string.wifi_detection_method)) },
+                        showBottomItems = true,
+                    )
+                Route.Donate -> {
+                    NavbarState(
+                        topTitle = { Text(stringResource(R.string.donate_title)) },
+                        showBottomItems = true,
+                    )
+                }
+                Route.Addresses -> {
+                    NavbarState(
+                        topTitle = { Text(stringResource(R.string.addresses)) },
+                        showBottomItems = true,
+                    )
+                }
+                Route.TunnelsGraph,
+                Route.SettingsGraph,
+                Route.AutoTunnelGraph,
+                Route.SupportGraph,
+                null -> NavbarState()
+            }
+    }
+}
+
+@Composable
+private fun DefaultTunnelsActions(
+    navController: NavHostController,
+    sharedViewModel: SharedAppViewModel,
+) {
+    Row {
+        ActionIconButton(Icons.AutoMirrored.Rounded.Sort, R.string.sort) {
+            navController.navigate(Route.Sort)
+        }
+        ActionIconButton(Icons.Rounded.Add, R.string.add_tunnel) {
+            sharedViewModel.postSideEffect(LocalSideEffect.Sheet.ImportTunnels)
+        }
+    }
+}

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

@@ -22,7 +22,6 @@ 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.common.SectionDivider
 import com.zaneschepke.wireguardautotunnel.ui.common.banner.WarningBanner
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
@@ -32,7 +31,6 @@ import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
 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.util.extensions.launchAppSettings
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchLocationServicesSettings
 import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
@@ -41,21 +39,10 @@ import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
 @Composable
 fun AutoTunnelScreen(viewModel: AutoTunnelViewModel = hiltViewModel()) {
     val context = LocalContext.current
-    val sharedViewModel = LocalSharedVm.current
     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)) },
-            )
-        )
-    }
-
     var showLocationDialog by remember { mutableStateOf(false) }
 
     val showLocationServicesWarning by

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

@@ -12,7 +12,6 @@ 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
@@ -20,25 +19,12 @@ 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
 
 @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)) },
-            )
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),

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

@@ -36,7 +36,6 @@ fun networkTunnelingItems(
             },
             trailing = {
                 ScaledSwitch(
-                    enabled = !autoTunnelState.generalSettings.isAlwaysOnVpnEnabled,
                     checked = autoTunnelState.generalSettings.isTunnelOnMobileDataEnabled,
                     onClick = { viewModel.setTunnelOnCellular(it) },
                 )
@@ -77,7 +76,6 @@ fun networkTunnelingItems(
             },
             trailing = {
                 ScaledSwitch(
-                    enabled = !autoTunnelState.generalSettings.isAlwaysOnVpnEnabled,
                     checked = autoTunnelState.generalSettings.isTunnelOnEthernetEnabled,
                     onClick = { viewModel.setTunnelOnEthernet(it) },
                 )

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

@@ -60,7 +60,6 @@ fun wifiTunnelingItems(
                 },
                 trailing = {
                     ScaledSwitch(
-                        enabled = !autoTunnelState.generalSettings.isAlwaysOnVpnEnabled,
                         checked = autoTunnelState.generalSettings.isTunnelOnWifiEnabled,
                         onClick = { viewModel.setAutoTunnelOnWifiEnabled(it) },
                     )

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

@@ -4,21 +4,16 @@ 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.wireguardautotunnel.ui.common.button.IconSurfaceButton
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.util.extensions.asDescriptionString
 import com.zaneschepke.wireguardautotunnel.util.extensions.asTitleString
 import com.zaneschepke.wireguardautotunnel.viewmodel.AutoTunnelViewModel
@@ -30,15 +25,6 @@ fun WifiDetectionMethodScreen(viewModel: AutoTunnelViewModel) {
 
     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),

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

@@ -10,20 +10,15 @@ 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
 
 @Composable
 fun LocationDisclosureScreen(viewModel: AutoTunnelViewModel) {
     val navController = LocalNavController.current
-    val sharedViewModel = LocalSharedVm.current
-
-    LaunchedEffect(Unit) { sharedViewModel.updateNavbarState(NavbarState(showBottomItems = true)) }
 
     LaunchedEffect(Unit) { viewModel.setLocationDisclosureShown() }
 

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

@@ -3,14 +3,16 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.pin
 import androidx.activity.compose.BackHandler
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
-import androidx.compose.runtime.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.util.StringValue
 import xyz.teamgravity.pin_lock_compose.PinLock
 import xyz.teamgravity.pin_lock_compose.PinManager
@@ -22,8 +24,6 @@ fun PinLockScreen() {
     val pinAlreadyExists by rememberSaveable { mutableStateOf(PinManager.pinExists()) }
     var pinCreated by rememberSaveable { mutableStateOf(false) }
 
-    LaunchedEffect(Unit) { sharedViewModel.updateNavbarState(NavbarState(showBottomItems = false)) }
-
     PinLock(
         title = {
             Text(

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

@@ -8,16 +8,12 @@ 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.material.icons.Icons
-import androidx.compose.material.icons.rounded.SettingsBackupRestore
-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.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -27,13 +23,15 @@ import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
 import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.*
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.proxy.compoents.AppModeBottomSheet
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.util.extensions.asString
 import com.zaneschepke.wireguardautotunnel.viewmodel.SettingsViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 import xyz.teamgravity.pin_lock_compose.PinManager
 
 @Composable
@@ -47,11 +45,23 @@ fun SettingsScreen(viewModel: SettingsViewModel = hiltViewModel()) {
 
     val settingsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
-    if (!settingsState.stateInitialized) return
-
     var showBackupSheet by rememberSaveable { mutableStateOf(false) }
     var showAppModeSheet by rememberSaveable { mutableStateOf(false) }
 
+    val appMode by
+        rememberSaveable(settingsState.settings.appMode) {
+            mutableStateOf(settingsState.settings.appMode)
+        }
+
+    if (!settingsState.stateInitialized) return
+
+    sharedViewModel.collectSideEffect { sideEffect ->
+        when (sideEffect) {
+            LocalSideEffect.Sheet.BackupApp -> showBackupSheet = true
+            else -> Unit
+        }
+    }
+
     val showProxySettings by
         remember(settingsState.settings.appMode) {
             derivedStateOf {
@@ -62,20 +72,6 @@ fun SettingsScreen(viewModel: SettingsViewModel = hiltViewModel()) {
             }
         }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.settings)) },
-                topTrailing = {
-                    ActionIconButton(Icons.Rounded.SettingsBackupRestore, R.string.quick_actions) {
-                        showBackupSheet = true
-                    }
-                },
-            )
-        )
-    }
-
     if (showBackupSheet) BackupBottomSheet() { showBackupSheet = false }
     if (showAppModeSheet)
         AppModeBottomSheet(sharedViewModel::setAppMode, settingsState.settings.appMode) {
@@ -103,40 +99,62 @@ fun SettingsScreen(viewModel: SettingsViewModel = hiltViewModel()) {
                 ),
     ) {
         SurfaceSelectionGroupButton(
-            buildList {
-                add(backendModeItem(settingsState.settings.appMode) { showAppModeSheet = true })
-            }
+            listOf(appModeItem(settingsState.settings.appMode) { showAppModeSheet = true })
         )
         SectionDivider()
         SurfaceSelectionGroupButton(
             items =
                 buildList {
-                    if (settingsState.settings.appMode == AppMode.LOCK_DOWN) {
+                    if (appMode == AppMode.LOCK_DOWN) {
                         add(
                             lanTrafficItem(settingsState.settings.isLanOnKillSwitchEnabled) {
                                 viewModel.setLanKillSwitchEnabled(it)
                             }
                         )
                     }
-                    add(tunnelMonitoringItem(navController))
-                    add(dnsSettingsItem(navController))
-                    // TODO changing these settings won't work in certain app states
-                    if (showProxySettings) add(proxYSettingsItem(navController))
+                    add(
+                        tunnelMonitoringItem(
+                            appMode,
+                            onClick = { navController.navigate(Route.TunnelMonitoring) },
+                        ) {
+                            sharedViewModel.showSnackMessage(
+                                StringValue.StringResource(
+                                    R.string.mode_disabled_template,
+                                    appMode.asString(context),
+                                )
+                            )
+                        }
+                    )
+                    add(
+                        dnsSettingsItem(appMode, onClick = { navController.navigate(Route.Dns) }) {
+                            sharedViewModel.showSnackMessage(
+                                StringValue.StringResource(
+                                    R.string.mode_disabled_template,
+                                    appMode.asString(context),
+                                )
+                            )
+                        }
+                    )
+                    if (showProxySettings)
+                        add(proxYSettingsItem() { navController.navigate(Route.ProxySettings) })
                 }
         )
         SectionDivider()
-        SurfaceSelectionGroupButton(listOf(systemFeaturesItem(navController)))
+        SurfaceSelectionGroupButton(
+            listOf(systemFeaturesItem() { navController.navigate(Route.SystemFeatures) })
+        )
         SectionDivider()
         SurfaceSelectionGroupButton(
             items =
                 buildList {
-                    add(appearanceItem(navController))
+                    add(appearanceItem() { navController.navigate(Route.Appearance) })
                     add(
                         localLoggingItem(settingsState.isLocalLoggingEnabled) {
                             viewModel.setLocalLogging(it)
                         }
                     )
-                    if (settingsState.isLocalLoggingEnabled) add(readLogsItem(navController))
+                    if (settingsState.isLocalLoggingEnabled)
+                        add(readLogsItem() { navController.navigate(Route.Logs) })
                     add(
                         pinLockItem(settingsState.isPinLockEnabled) { enabled ->
                             if (enabled) {

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/appearance/AppearanceScreen.kt

@@ -4,36 +4,20 @@ 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.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.LocalNavController
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.components.DisplayThemeItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.components.LanguageItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.components.NotificationsItem
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 
 @Composable
 fun AppearanceScreen() {
-    val sharedViewModel = LocalSharedVm.current
     val navController = LocalNavController.current
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.appearance)) },
-            )
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/appearance/components/NotificationItem.kt

@@ -9,7 +9,7 @@ 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.LaunchButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchNotificationSettings
 
@@ -25,7 +25,7 @@ fun NotificationsItem(): SelectionItem {
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        trailing = { ForwardButton { context.launchNotificationSettings() } },
+        trailing = { LaunchButton { context.launchNotificationSettings() } },
         onClick = { context.launchNotificationSettings() },
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/appearance/display/DisplayScreen.kt

@@ -4,9 +4,7 @@ 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
@@ -16,7 +14,6 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.button.IconSurfaceButton
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
 
 @Composable
@@ -26,15 +23,6 @@ fun DisplayScreen() {
 
     val appState by sharedViewModel.container.stateFlow.collectAsStateWithLifecycle()
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.display_theme)) },
-            )
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(24.dp, Alignment.Top),

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/appearance/language/LanguageScreen.kt

@@ -5,7 +5,6 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -18,7 +17,6 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.button.IconSurfaceButton
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
 import java.text.Collator
 import java.util.*
@@ -29,15 +27,6 @@ fun LanguageScreen() {
     val sharedViewModel = LocalSharedVm.current
     val appState by sharedViewModel.container.stateFlow.collectAsStateWithLifecycle()
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.language)) },
-            )
-        )
-    }
-
     val collator = Collator.getInstance(Locale.getDefault())
     val locales =
         LocaleUtil.supportedLocales.map {

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

@@ -1,27 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.settings.components
-
-import androidx.compose.runtime.Composable
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
-import com.zaneschepke.wireguardautotunnel.ui.common.prompt.AuthorizationPrompt
-import com.zaneschepke.wireguardautotunnel.util.StringValue
-
-@Composable
-fun AuthorizationPromptWrapper(onSuccess: () -> Unit, onDismiss: () -> Unit) {
-    val sharedViewModel = LocalSharedVm.current
-    AuthorizationPrompt(
-        onSuccess = { onSuccess() },
-        onError = { _ ->
-            onDismiss()
-            sharedViewModel.showSnackMessage(
-                StringValue.StringResource(R.string.error_authentication_failed)
-            )
-        },
-        onFailure = {
-            onDismiss()
-            sharedViewModel.showSnackMessage(
-                StringValue.StringResource(R.string.error_authorization_failed)
-            )
-        },
-    )
-}

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

@@ -1,9 +1,12 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.settings.components
 
+import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.ExpandMore
 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.platform.LocalContext
 import androidx.compose.ui.res.stringResource
@@ -13,15 +16,22 @@ import com.zaneschepke.wireguardautotunnel.data.model.AppMode
 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.theme.iconSize
 import com.zaneschepke.wireguardautotunnel.util.extensions.asTitleString
 
 @Composable
-fun backendModeItem(appMode: AppMode, onClick: () -> Unit): SelectionItem {
+fun appModeItem(appMode: AppMode, onClick: () -> Unit): SelectionItem {
     val context = LocalContext.current
     return SelectionItem(
         leading = { Icon(ImageVector.vectorResource(R.drawable.sdk), contentDescription = null) },
         trailing = {
-            Icon(Icons.Outlined.ExpandMore, contentDescription = stringResource(R.string.select))
+            IconButton(onClick = onClick) {
+                Icon(
+                    Icons.Outlined.ExpandMore,
+                    contentDescription = stringResource(R.string.select),
+                    modifier = Modifier.size(iconSize),
+                )
+            }
         },
         title = {
             SelectionItemLabel(stringResource(R.string.backend_mode), SelectionLabelType.TITLE)

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

@@ -7,14 +7,12 @@ 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.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
 
 @Composable
-fun appearanceItem(navController: NavController): SelectionItem {
+fun appearanceItem(onClick: () -> Unit): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.AutoMirrored.Outlined.ViewQuilt, contentDescription = null) },
         title = {
@@ -24,7 +22,7 @@ fun appearanceItem(navController: NavController): SelectionItem {
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        trailing = { ForwardButton { navController.navigate(Route.Appearance) } },
-        onClick = { navController.navigate(Route.Appearance) },
+        trailing = { ForwardButton { onClick() } },
+        onClick = onClick,
     )
 }

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

@@ -6,18 +6,29 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
-import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.model.AppMode
 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.util.extensions.asString
 
 @Composable
-fun dnsSettingsItem(navController: NavController): SelectionItem {
+fun dnsSettingsItem(
+    appMode: AppMode,
+    onClick: () -> Unit,
+    onDisabledClick: () -> Unit,
+): SelectionItem {
+    val context = LocalContext.current
+    val enabled by rememberSaveable(appMode) { mutableStateOf(appMode != AppMode.KERNEL) }
+    val click = if (enabled) onClick else onDisabledClick
     return SelectionItem(
         leading = { Icon(Icons.Outlined.Dns, null) },
-        trailing = { ForwardButton { navController.navigate(Route.Dns) } },
+        trailing = { ForwardButton { click() } },
         title = {
             Text(
                 text = stringResource(R.string.dns_settings),
@@ -25,6 +36,8 @@ fun dnsSettingsItem(navController: NavController): SelectionItem {
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        onClick = { navController.navigate(Route.Dns) },
+        onClick = click,
+        disabledReason =
+            context.getString(R.string.mode_disabled_template, appMode.asString(context)),
     )
 }

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

@@ -7,17 +7,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.res.vectorResource
-import androidx.navigation.NavController
 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.navigation.Route
 
 @Composable
-fun proxYSettingsItem(navController: NavController): SelectionItem {
+fun proxYSettingsItem(onClick: () -> Unit): SelectionItem {
     return SelectionItem(
         leading = { Icon(ImageVector.vectorResource(R.drawable.proxy), null) },
-        trailing = { ForwardButton { navController.navigate(Route.ProxySettings) } },
+        trailing = { ForwardButton { onClick() } },
         title = {
             Text(
                 text = stringResource(R.string.proxy_settings),
@@ -25,6 +23,6 @@ fun proxYSettingsItem(navController: NavController): SelectionItem {
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        onClick = { navController.navigate(Route.ProxySettings) },
+        onClick = onClick,
     )
 }

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

@@ -5,22 +5,20 @@ import androidx.compose.material.icons.filled.ViewTimeline
 import androidx.compose.material3.Icon
 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.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
 
 @Composable
-fun readLogsItem(navController: NavController): SelectionItem {
+fun readLogsItem(onClick: () -> Unit): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.Filled.ViewTimeline, contentDescription = null) },
         title = {
             SelectionItemLabel(stringResource(R.string.read_logs), SelectionLabelType.TITLE)
         },
-        trailing = { ForwardButton { navController.navigate(Route.Logs) } },
-        onClick = { navController.navigate(Route.Logs) },
+        trailing = { ForwardButton { onClick() } },
+        onClick = onClick,
     )
 }

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

@@ -7,17 +7,15 @@ 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.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
 
 @Composable
-fun systemFeaturesItem(navController: NavController): SelectionItem {
+fun systemFeaturesItem(onClick: () -> Unit): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.Outlined.Android, null) },
-        trailing = { ForwardButton { navController.navigate(Route.SystemFeatures) } },
+        trailing = { ForwardButton { onClick.invoke() } },
         title = {
             Text(
                 text = stringResource(R.string.system_features),
@@ -25,6 +23,6 @@ fun systemFeaturesItem(navController: NavController): SelectionItem {
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        onClick = { navController.navigate(Route.SystemFeatures) },
+        onClick = onClick,
     )
 }

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

@@ -6,18 +6,32 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
-import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.model.AppMode
 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.util.extensions.asString
 
 @Composable
-fun tunnelMonitoringItem(navController: NavController): SelectionItem {
+fun tunnelMonitoringItem(
+    appMode: AppMode,
+    onClick: () -> Unit,
+    onDisabledClick: () -> Unit,
+): SelectionItem {
+    val context = LocalContext.current
+    val enabled by
+        rememberSaveable(appMode) {
+            mutableStateOf(appMode == AppMode.VPN || appMode == AppMode.KERNEL)
+        }
+    val click = if (enabled) onClick else onDisabledClick
     return SelectionItem(
         leading = { Icon(Icons.Outlined.MonitorHeart, null) },
-        trailing = { ForwardButton { navController.navigate(Route.TunnelMonitoring) } },
+        trailing = { ForwardButton { click() } },
         title = {
             Text(
                 text = stringResource(R.string.tunnel_monitoring),
@@ -25,6 +39,9 @@ fun tunnelMonitoringItem(navController: NavController): SelectionItem {
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        onClick = { navController.navigate(Route.TunnelMonitoring) },
+        isEnabled = enabled,
+        onClick = click,
+        disabledReason =
+            context.getString(R.string.mode_disabled_template, appMode.asString(context)),
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/dns/DnsSettingsScreen.kt

@@ -14,7 +14,6 @@ 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
@@ -25,26 +24,14 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.data.model.DnsProtocol
 import com.zaneschepke.wireguardautotunnel.data.model.DnsProvider
-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.SettingsViewModel
 
 @Composable
 fun DnsSettingsScreen(viewModel: SettingsViewModel) {
     val context = LocalContext.current
-    val sharedViewModel = LocalSharedVm.current
     val settingsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.dns_settings)) },
-            )
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/logs/LogsScreen.kt

@@ -4,8 +4,6 @@ import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Menu
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.*
@@ -19,15 +17,15 @@ import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.logs.components.LogList
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.logs.components.LogsBottomSheet
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
 import com.zaneschepke.wireguardautotunnel.viewmodel.LoggerViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 
 @Composable
 fun LogsScreen(viewModel: LoggerViewModel = hiltViewModel()) {
-    val sharedViewModel = LocalSharedVm.current
+    val sharedAppViewModel = LocalSharedVm.current
     val loggerState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
     val lazyColumnListState = rememberLazyListState()
@@ -35,19 +33,8 @@ fun LogsScreen(viewModel: LoggerViewModel = hiltViewModel()) {
     var lastScrollPosition by rememberSaveable() { mutableIntStateOf(0) }
     var showLogsSheet by rememberSaveable { mutableStateOf(false) }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = false,
-                removeBottom = true,
-                topTitle = { Text(stringResource(R.string.logs)) },
-                topTrailing = {
-                    ActionIconButton(Icons.Rounded.Menu, R.string.quick_actions) {
-                        showLogsSheet = true
-                    }
-                },
-            )
-        )
+    sharedAppViewModel.collectSideEffect { sideEffect ->
+        if (sideEffect is LocalSideEffect.Sheet.LoggerActions) showLogsSheet = true
     }
 
     LaunchedEffect(isAutoScrolling) {

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/monitoring/TunnelMonitoringScreen.kt

@@ -14,7 +14,6 @@ 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
@@ -22,28 +21,16 @@ 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.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.common.dropdown.LabelledDropdown
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.monitoring.components.detailedPingStatsItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.monitoring.components.enablePingMonitoringItem
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.viewmodel.SettingsViewModel
 
 @Composable
 fun TunnelMonitoringScreen(viewModel: SettingsViewModel) {
-    val sharedViewModel = LocalSharedVm.current
     val settingsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                topTitle = { Text(stringResource(R.string.tunnel_monitoring)) },
-                showBottomItems = true,
-            )
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/proxy/ProxySettingsScreen.kt

@@ -1,14 +1,15 @@
-import androidx.compose.foundation.layout.*
+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.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Forward5
 import androidx.compose.material.icons.outlined.Http
 import androidx.compose.material.icons.outlined.RemoveRedEye
-import androidx.compose.material.icons.rounded.Save
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -24,7 +25,6 @@ import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.domain.model.AppProxySettings
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.SecureScreenFromRecording
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ScaledSwitch
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItemLabel
@@ -32,53 +32,68 @@ import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionLab
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.common.label.GroupLabel
 import com.zaneschepke.wireguardautotunnel.ui.common.textbox.ConfigurationTextBox
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
 import com.zaneschepke.wireguardautotunnel.viewmodel.ProxySettingsViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 
 @Composable
 fun ProxySettingsScreen(viewModel: ProxySettingsViewModel = hiltViewModel()) {
-
     val sharedViewModel = LocalSharedVm.current
-
     val proxySettingsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
-    val proxySettings by remember { derivedStateOf { proxySettingsState.proxySettings } }
+    if (!proxySettingsState.stateInitialized) return
 
-    var socksBindAddress by remember { mutableStateOf(proxySettings.socks5ProxyBindAddress ?: "") }
-    var httpBindAddress by remember { mutableStateOf(proxySettings.httpProxyBindAddress ?: "") }
-    var proxyUsername by remember { mutableStateOf(proxySettings.proxyUsername ?: "") }
-    var proxyPassword by remember { mutableStateOf(proxySettings.proxyPassword ?: "") }
-    var passwordVisible by remember { mutableStateOf(proxySettingsState.passwordVisible) }
+    val proxySettings by
+        remember(proxySettingsState) { mutableStateOf(proxySettingsState.proxySettings) }
+
+    var socks5Enabled by
+        remember(proxySettings) {
+            mutableStateOf(proxySettingsState.proxySettings.socks5ProxyEnabled)
+        }
+    var httpEnabled by
+        remember(proxySettings) {
+            mutableStateOf(proxySettingsState.proxySettings.httpProxyEnabled)
+        }
+    var socksBindAddress by
+        remember(proxySettings) {
+            mutableStateOf(proxySettingsState.proxySettings.socks5ProxyBindAddress ?: "")
+        }
+    var httpBindAddress by
+        remember(proxySettings) {
+            mutableStateOf(proxySettingsState.proxySettings.httpProxyBindAddress ?: "")
+        }
+    var proxyUsername by
+        remember(proxySettings) {
+            mutableStateOf(proxySettingsState.proxySettings.proxyUsername ?: "")
+        }
+    var proxyPassword by
+        remember(proxySettings) {
+            mutableStateOf(proxySettingsState.proxySettings.proxyPassword ?: "")
+        }
+    var passwordVisible by
+        remember(proxySettings) { mutableStateOf(proxySettingsState.passwordVisible) }
 
     val keyboardController = LocalSoftwareKeyboardController.current
 
     val keyboardActions = KeyboardActions(onDone = { keyboardController?.hide() })
     val keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done)
 
-    if (!proxySettingsState.stateInitialized) return
-
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.proxy_settings)) },
-                topTrailing = {
-                    ActionIconButton(Icons.Rounded.Save, R.string.save) {
-                        keyboardController?.hide()
-                        viewModel.save(
-                            AppProxySettings(
-                                socks5ProxyEnabled = proxySettings.socks5ProxyEnabled,
-                                socks5ProxyBindAddress = socksBindAddress,
-                                httpProxyEnabled = proxySettings.httpProxyEnabled,
-                                httpProxyBindAddress = httpBindAddress,
-                                proxyUsername = proxyUsername,
-                                proxyPassword = proxyPassword,
-                            )
-                        )
-                    }
-                },
-            )
-        )
+    sharedViewModel.collectSideEffect { sideEffect ->
+        when (sideEffect) {
+            LocalSideEffect.SaveChanges -> {
+                viewModel.save(
+                    AppProxySettings(
+                        socks5ProxyEnabled = socks5Enabled,
+                        socks5ProxyBindAddress = socksBindAddress,
+                        httpProxyEnabled = httpEnabled,
+                        httpProxyBindAddress = httpBindAddress,
+                        proxyUsername = proxyUsername,
+                        proxyPassword = proxyPassword,
+                    )
+                )
+            }
+            else -> Unit
+        }
     }
 
     SecureScreenFromRecording()
@@ -99,17 +114,15 @@ fun ProxySettingsScreen(viewModel: ProxySettingsViewModel = hiltViewModel()) {
                         )
                     },
                     trailing = {
-                        ScaledSwitch(
-                            checked = proxySettings.socks5ProxyEnabled,
-                            onClick = { viewModel.setEnableSocks5(it) },
-                        )
+                        ScaledSwitch(checked = socks5Enabled, onClick = { socks5Enabled = it })
                     },
-                    onClick = { viewModel.setEnableSocks5(!proxySettings.socks5ProxyEnabled) },
+                    onClick = { socks5Enabled = !socks5Enabled },
                 )
             )
         )
-        if (proxySettings.socks5ProxyEnabled) {
+        if (socks5Enabled) {
             ConfigurationTextBox(
+                modifier = Modifier.padding(horizontal = 12.dp),
                 hint =
                     stringResource(
                         R.string.defaults_to_template,
@@ -118,7 +131,11 @@ fun ProxySettingsScreen(viewModel: ProxySettingsViewModel = hiltViewModel()) {
                 label = stringResource(R.string.socks_5_bind_address),
                 value = socksBindAddress,
                 isError = proxySettingsState.isSocks5BindAddressError,
-                onValueChange = { socksBindAddress = it },
+                onValueChange = {
+                    if (proxySettingsState.isSocks5BindAddressError)
+                        viewModel.clearSocks5BindError()
+                    socksBindAddress = it
+                },
             )
         }
         SurfaceSelectionGroupButton(
@@ -132,16 +149,13 @@ fun ProxySettingsScreen(viewModel: ProxySettingsViewModel = hiltViewModel()) {
                         )
                     },
                     trailing = {
-                        ScaledSwitch(
-                            checked = proxySettings.httpProxyEnabled,
-                            onClick = { viewModel.setEnableHttp(it) },
-                        )
+                        ScaledSwitch(checked = httpEnabled, onClick = { httpEnabled = it })
                     },
-                    onClick = { viewModel.setEnableHttp(!proxySettings.httpProxyEnabled) },
+                    onClick = { httpEnabled = !httpEnabled },
                 )
             )
         )
-        if (proxySettings.httpProxyEnabled) {
+        if (httpEnabled) {
             ConfigurationTextBox(
                 hint =
                     stringResource(
@@ -151,14 +165,17 @@ fun ProxySettingsScreen(viewModel: ProxySettingsViewModel = hiltViewModel()) {
                 label = stringResource(R.string.http_bind_address),
                 value = httpBindAddress,
                 isError = proxySettingsState.isHttpBindAddressError,
-                onValueChange = { httpBindAddress = it },
+                onValueChange = {
+                    if (proxySettingsState.isSocks5BindAddressError) viewModel.clearHttpBindError()
+                    httpBindAddress = it
+                },
+                modifier = Modifier.padding(horizontal = 12.dp),
             )
         }
-        if (proxySettings.httpProxyEnabled || proxySettings.socks5ProxyEnabled) {
+        if (socks5Enabled || httpEnabled) {
             Column(
                 horizontalAlignment = Alignment.Start,
                 verticalArrangement = Arrangement.spacedBy(24.dp, Alignment.Top),
-                modifier = Modifier.padding(horizontal = 12.dp),
             ) {
                 GroupLabel(
                     stringResource(
@@ -168,23 +185,29 @@ fun ProxySettingsScreen(viewModel: ProxySettingsViewModel = hiltViewModel()) {
                 )
                 ConfigurationTextBox(
                     value = proxyUsername,
-                    onValueChange = { proxyUsername = it },
+                    onValueChange = {
+                        if (proxySettingsState.isUserNameError) viewModel.clearUsernameError()
+                        proxyUsername = it
+                    },
                     label = stringResource(R.string.username),
                     isError = proxySettingsState.isUserNameError,
                     hint = "",
                     keyboardActions = keyboardActions,
                     keyboardOptions = keyboardOptions,
-                    modifier = Modifier.fillMaxWidth(),
+                    modifier = Modifier.padding(horizontal = 12.dp),
                 )
                 ConfigurationTextBox(
                     value = proxyPassword,
-                    onValueChange = { proxyPassword = it },
+                    onValueChange = {
+                        if (proxySettingsState.isUserNameError) viewModel.clearPasswordError()
+                        proxyPassword = it
+                    },
                     label = stringResource(R.string.password),
                     isError = proxySettingsState.isPasswordError,
                     hint = "",
                     keyboardActions = keyboardActions,
                     keyboardOptions = keyboardOptions,
-                    modifier = Modifier.fillMaxWidth(),
+                    modifier = Modifier.padding(horizontal = 12.dp),
                     trailing = {
                         IconButton(onClick = { passwordVisible = !passwordVisible }) {
                             Icon(

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/system/SystemFeaturesScreen.kt

@@ -6,41 +6,25 @@ 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.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.LocalIsAndroidTV
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
 import com.zaneschepke.wireguardautotunnel.ui.common.SecureScreenFromRecording
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.system.components.*
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.viewmodel.SettingsViewModel
 
 @Composable
 fun SystemFeaturesScreen(viewModel: SettingsViewModel) {
-    val sharedViewModel = LocalSharedVm.current
     val settingsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
     val isTv = LocalIsAndroidTV.current
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                topTitle = { Text(stringResource(R.string.android_integrations)) },
-                showBottomItems = true,
-            )
-        )
-    }
-
     SecureScreenFromRecording()
 
     Column(

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/settings/system/components/nativeKillSwitchItem.kt

@@ -9,7 +9,7 @@ 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.LaunchButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchVpnSettings
 
@@ -25,7 +25,7 @@ fun nativeKillSwitchItem(): SelectionItem {
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        trailing = { ForwardButton { context.launchVpnSettings() } },
+        trailing = { LaunchButton { context.launchVpnSettings() } },
         onClick = { context.launchVpnSettings() },
     )
 }

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

@@ -6,8 +6,11 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
-import androidx.compose.runtime.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.StrokeCap
@@ -20,14 +23,14 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.BuildConfig
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
 import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
 import com.zaneschepke.wireguardautotunnel.ui.common.label.GroupLabel
+import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.components.ContactSupportOptions
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.components.DonateSection
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.components.GeneralSupportOptions
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.components.UpdateSection
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.extensions.canInstallPackages
 import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
@@ -37,21 +40,11 @@ import com.zaneschepke.wireguardautotunnel.viewmodel.SupportViewModel
 @Composable
 fun SupportScreen(viewModel: SupportViewModel) {
     val context = LocalContext.current
-    val sharedViewModel = LocalSharedVm.current
     val navController = LocalNavController.current
     val supportState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
     var showPermissionDialog by rememberSaveable { mutableStateOf(false) }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                topTitle = { Text(stringResource(R.string.support)) },
-                showBottomItems = true,
-            )
-        )
-    }
-
     if (supportState.appUpdate != null) {
         InfoDialog(
             onDismiss = { viewModel.dismissUpdate() },
@@ -143,7 +136,9 @@ fun SupportScreen(viewModel: SupportViewModel) {
             stringResource(R.string.thank_you),
             modifier = Modifier.padding(horizontal = 12.dp).padding(bottom = 12.dp),
         )
-        UpdateSection(onUpdateCheck = { viewModel.checkForUpdate() })
+        UpdateSection { viewModel.checkForUpdate() }
+        SectionDivider()
+        DonateSection { navController.navigate(Route.Donate) }
         SectionDivider()
         GeneralSupportOptions(navController)
         SectionDivider()

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

@@ -2,7 +2,6 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.support.components
 
 import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Favorite
 import androidx.compose.material.icons.outlined.Mail
 import androidx.compose.material3.Icon
 import androidx.compose.runtime.Composable
@@ -10,15 +9,13 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.res.vectorResource
-import com.zaneschepke.wireguardautotunnel.BuildConfig
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
+import com.zaneschepke.wireguardautotunnel.ui.common.button.LaunchButton
 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.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
-import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchSupportEmail
 import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
 
@@ -26,106 +23,77 @@ import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
 fun ContactSupportOptions(context: android.content.Context) {
     SurfaceSelectionGroupButton(
         items =
-            buildList {
-                addAll(
-                    listOf(
-                        SelectionItem(
-                            leading = {
-                                Icon(
-                                    ImageVector.vectorResource(R.drawable.matrix),
-                                    contentDescription = null,
-                                    Modifier.size(iconSize),
-                                )
-                            },
-                            title = {
-                                SelectionItemLabel(
-                                    stringResource(R.string.join_matrix),
-                                    SelectionLabelType.TITLE,
-                                )
-                            },
-                            trailing = {
-                                ForwardButton {
-                                    context.openWebUrl(context.getString(R.string.matrix_url))
-                                }
-                            },
-                            onClick = { context.openWebUrl(context.getString(R.string.matrix_url)) },
-                        ),
-                        SelectionItem(
-                            leading = {
-                                Icon(
-                                    ImageVector.vectorResource(R.drawable.telegram),
-                                    contentDescription = null,
-                                    Modifier.size(iconSize),
-                                )
-                            },
-                            title = {
-                                SelectionItemLabel(
-                                    stringResource(R.string.join_telegram),
-                                    SelectionLabelType.TITLE,
-                                )
-                            },
-                            trailing = {
-                                ForwardButton {
-                                    context.openWebUrl(context.getString(R.string.telegram_url))
-                                }
-                            },
-                            onClick = {
-                                context.openWebUrl(context.getString(R.string.telegram_url))
-                            },
-                        ),
-                        SelectionItem(
-                            leading = {
-                                Icon(
-                                    ImageVector.vectorResource(R.drawable.github),
-                                    contentDescription = null,
-                                    Modifier.size(iconSize),
-                                )
-                            },
-                            title = {
-                                SelectionItemLabel(
-                                    stringResource(R.string.open_issue),
-                                    SelectionLabelType.TITLE,
-                                )
-                            },
-                            trailing = {
-                                ForwardButton {
-                                    context.openWebUrl(context.getString(R.string.github_url))
-                                }
-                            },
-                            onClick = { context.openWebUrl(context.getString(R.string.github_url)) },
-                        ),
-                        SelectionItem(
-                            leading = { Icon(Icons.Outlined.Mail, contentDescription = null) },
-                            title = {
-                                SelectionItemLabel(
-                                    stringResource(R.string.email_description),
-                                    SelectionLabelType.TITLE,
-                                )
-                            },
-                            trailing = { ForwardButton { context.launchSupportEmail() } },
-                            onClick = { context.launchSupportEmail() },
-                        ),
-                    )
-                )
-                if (BuildConfig.FLAVOR != Constants.GOOGLE_PLAY_FLAVOR) {
-                    add(
-                        SelectionItem(
-                            leading = { Icon(Icons.Outlined.Favorite, contentDescription = null) },
-                            title = {
-                                SelectionItemLabel(
-                                    stringResource(R.string.donate),
-                                    SelectionLabelType.TITLE,
-                                )
-                            },
-                            trailing = {
-                                ForwardButton {
-                                    context.openWebUrl(context.getString(R.string.donate_url))
-                                }
-                            },
-                            onClick = { context.openWebUrl(context.getString(R.string.donate_url)) },
+            listOf(
+                SelectionItem(
+                    leading = {
+                        Icon(
+                            ImageVector.vectorResource(R.drawable.matrix),
+                            contentDescription = null,
+                            Modifier.size(iconSize),
                         )
-                    )
-                }
-            }
+                    },
+                    title = {
+                        SelectionItemLabel(
+                            stringResource(R.string.join_matrix),
+                            SelectionLabelType.TITLE,
+                        )
+                    },
+                    trailing = {
+                        LaunchButton { context.openWebUrl(context.getString(R.string.matrix_url)) }
+                    },
+                    onClick = { context.openWebUrl(context.getString(R.string.matrix_url)) },
+                ),
+                SelectionItem(
+                    leading = {
+                        Icon(
+                            ImageVector.vectorResource(R.drawable.telegram),
+                            contentDescription = null,
+                            Modifier.size(iconSize),
+                        )
+                    },
+                    title = {
+                        SelectionItemLabel(
+                            stringResource(R.string.join_telegram),
+                            SelectionLabelType.TITLE,
+                        )
+                    },
+                    trailing = {
+                        LaunchButton {
+                            context.openWebUrl(context.getString(R.string.telegram_url))
+                        }
+                    },
+                    onClick = { context.openWebUrl(context.getString(R.string.telegram_url)) },
+                ),
+                SelectionItem(
+                    leading = {
+                        Icon(
+                            ImageVector.vectorResource(R.drawable.github),
+                            contentDescription = null,
+                            Modifier.size(iconSize),
+                        )
+                    },
+                    title = {
+                        SelectionItemLabel(
+                            stringResource(R.string.open_issue),
+                            SelectionLabelType.TITLE,
+                        )
+                    },
+                    trailing = {
+                        LaunchButton { context.openWebUrl(context.getString(R.string.github_url)) }
+                    },
+                    onClick = { context.openWebUrl(context.getString(R.string.github_url)) },
+                ),
+                SelectionItem(
+                    leading = { Icon(Icons.Outlined.Mail, contentDescription = null) },
+                    title = {
+                        SelectionItemLabel(
+                            stringResource(R.string.email_description),
+                            SelectionLabelType.TITLE,
+                        )
+                    },
+                    trailing = { LaunchButton { context.launchSupportEmail() } },
+                    onClick = { context.launchSupportEmail() },
+                ),
+            )
     )
 }

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

@@ -0,0 +1,29 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.components
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Favorite
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+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.ui.common.button.surface.SurfaceSelectionGroupButton
+
+@Composable
+fun DonateSection(onClick: () -> Unit) {
+    SurfaceSelectionGroupButton(
+        listOf(
+            SelectionItem(
+                leading = { Icon(Icons.Outlined.Favorite, contentDescription = null) },
+                title = {
+                    SelectionItemLabel(stringResource(R.string.donate), SelectionLabelType.TITLE)
+                },
+                trailing = { ForwardButton { onClick() } },
+                onClick = onClick,
+            )
+        )
+    )
+}

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

@@ -11,6 +11,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
+import com.zaneschepke.wireguardautotunnel.ui.common.button.LaunchButton
 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
@@ -34,7 +35,7 @@ fun GeneralSupportOptions(navController: NavController) {
                             )
                         },
                         trailing = {
-                            ForwardButton {
+                            LaunchButton {
                                 context.openWebUrl(context.getString(R.string.docs_url))
                             }
                         },
@@ -51,7 +52,7 @@ fun GeneralSupportOptions(navController: NavController) {
                             )
                         },
                         trailing = {
-                            ForwardButton {
+                            LaunchButton {
                                 context.openWebUrl(context.getString(R.string.privacy_policy_url))
                             }
                         },

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

@@ -5,6 +5,7 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.CloudDownload
 import androidx.compose.material3.Icon
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
 import androidx.compose.ui.res.stringResource
 import com.zaneschepke.wireguardautotunnel.BuildConfig
 import com.zaneschepke.wireguardautotunnel.R
@@ -12,9 +13,15 @@ import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionIte
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItemLabel
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionLabelType
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
+import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberClipboardHelper
 
 @Composable
-fun UpdateSection(onUpdateCheck: () -> Unit = {}) {
+fun UpdateSection(onUpdateCheck: () -> Unit) {
+    val clipboardManager = rememberClipboardHelper()
+    val version = remember {
+        "v${BuildConfig.VERSION_NAME +
+            if(BuildConfig.DEBUG) "-debug" else "" }"
+    }
     SurfaceSelectionGroupButton(
         listOf(
             SelectionItem(
@@ -28,11 +35,7 @@ fun UpdateSection(onUpdateCheck: () -> Unit = {}) {
                 description = {
                     Column {
                         SelectionItemLabel(
-                            stringResource(
-                                R.string.version_template,
-                                "v${BuildConfig.VERSION_NAME + 
-                                    if(BuildConfig.DEBUG) "-debug" else "" }",
-                            ),
+                            stringResource(R.string.version_template, version),
                             SelectionLabelType.DESCRIPTION,
                         )
                         SelectionItemLabel(
@@ -42,6 +45,7 @@ fun UpdateSection(onUpdateCheck: () -> Unit = {}) {
                     }
                 },
                 onClick = onUpdateCheck,
+                onLongPress = { clipboardManager.copy(version) },
             )
         )
     )

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/donate/DonateScreen.kt

@@ -0,0 +1,41 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.donate
+
+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.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.navigation.NavController
+import com.zaneschepke.wireguardautotunnel.BuildConfig
+import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
+import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.components.DonationHeroSection
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.components.DonationOptions
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.components.GoogleDonationMessage
+import com.zaneschepke.wireguardautotunnel.util.Constants
+
+@Composable
+fun DonateScreen(navController: NavController) {
+    Column(
+        horizontalAlignment = Alignment.Start,
+        verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),
+        modifier =
+            Modifier.fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(vertical = 24.dp)
+                .padding(horizontal = 12.dp),
+    ) {
+        DonationHeroSection()
+        SectionDivider()
+        if (BuildConfig.FLAVOR != Constants.GOOGLE_PLAY_FLAVOR) {
+            DonationOptions { navController.navigate(Route.Addresses) }
+        } else {
+            GoogleDonationMessage()
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/donate/components/DonationHeroSection.kt

@@ -0,0 +1,80 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+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.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
+
+@Composable
+fun DonationHeroSection() {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(12.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+    ) {
+        Column(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            Text(
+                text = stringResource(R.string.donation_thanks_intro),
+                style =
+                    MaterialTheme.typography.bodySmall.copy(
+                        color = MaterialTheme.colorScheme.onSurface
+                    ),
+                textAlign = TextAlign.Start,
+            )
+
+            Text(
+                text = stringResource(R.string.donation_dev_message),
+                style =
+                    MaterialTheme.typography.bodySmall.copy(
+                        color = MaterialTheme.colorScheme.onSurface
+                    ),
+                textAlign = TextAlign.Start,
+            )
+
+            Text(
+                text = stringResource(R.string.donation_closing),
+                style =
+                    MaterialTheme.typography.bodySmall.copy(
+                        color = MaterialTheme.colorScheme.onSurface
+                    ),
+                textAlign = TextAlign.Start,
+            )
+
+            Text(
+                text = stringResource(R.string.donation_signoff),
+                style =
+                    MaterialTheme.typography.bodySmall.copy(
+                        color = MaterialTheme.colorScheme.onSurface
+                    ),
+                fontWeight = FontWeight.Bold,
+                textAlign = TextAlign.Start,
+            )
+            Text(
+                text = stringResource(R.string.dev_name),
+                style =
+                    MaterialTheme.typography.bodySmall.copy(
+                        color = MaterialTheme.colorScheme.onSurface
+                    ),
+                fontWeight = FontWeight.Bold,
+                textAlign = TextAlign.Start,
+            )
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/donate/components/DonationOptions.kt

@@ -0,0 +1,97 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.components
+
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CurrencyBitcoin
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+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.compose.ui.res.vectorResource
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
+import com.zaneschepke.wireguardautotunnel.ui.common.button.LaunchButton
+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.common.button.surface.SurfaceSelectionGroupButton
+import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
+
+@Composable
+fun DonationOptions(onAddressesClick: () -> Unit) {
+    val context = LocalContext.current
+    SurfaceSelectionGroupButton(
+        listOf(
+            SelectionItem(
+                leading = {
+                    Icon(
+                        Icons.Outlined.CurrencyBitcoin,
+                        contentDescription = null,
+                        modifier = Modifier.size(iconSize),
+                    )
+                },
+                title = {
+                    SelectionItemLabel(stringResource(R.string.crypto), SelectionLabelType.TITLE)
+                },
+                trailing = { ForwardButton { onAddressesClick() } },
+                onClick = onAddressesClick,
+            ),
+            SelectionItem(
+                leading = {
+                    Icon(
+                        ImageVector.vectorResource(R.drawable.github),
+                        contentDescription = null,
+                        modifier = Modifier.size(iconSize),
+                    )
+                },
+                title = {
+                    SelectionItemLabel(
+                        stringResource(R.string.github_sponsors),
+                        SelectionLabelType.TITLE,
+                    )
+                },
+                trailing = {
+                    LaunchButton {
+                        context.openWebUrl(context.getString(R.string.github_sponsors_url))
+                    }
+                },
+                onClick = { context.openWebUrl(context.getString(R.string.github_sponsors_url)) },
+            ),
+            SelectionItem(
+                leading = {
+                    Icon(
+                        ImageVector.vectorResource(R.drawable.liberapay),
+                        contentDescription = null,
+                        modifier = Modifier.size(iconSize),
+                    )
+                },
+                title = {
+                    SelectionItemLabel(stringResource(R.string.liberapay), SelectionLabelType.TITLE)
+                },
+                trailing = {
+                    LaunchButton { context.openWebUrl(context.getString(R.string.liberapay_url)) }
+                },
+                onClick = { context.openWebUrl(context.getString(R.string.liberapay_url)) },
+            ),
+            SelectionItem(
+                leading = {
+                    Icon(
+                        ImageVector.vectorResource(R.drawable.kofi),
+                        contentDescription = null,
+                        modifier = Modifier.size(iconSize),
+                    )
+                },
+                title = {
+                    SelectionItemLabel(stringResource(R.string.kofi), SelectionLabelType.TITLE)
+                },
+                trailing = {
+                    LaunchButton { context.openWebUrl(context.getString(R.string.kofi_url)) }
+                },
+                onClick = { context.openWebUrl(context.getString(R.string.kofi_url)) },
+            ),
+        )
+    )
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/donate/components/GoogleDonationMessage.kt

@@ -0,0 +1,42 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+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.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
+
+@Composable
+fun GoogleDonationMessage() {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(12.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+    ) {
+        Column(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            Text(
+                text = stringResource(R.string.google_donation_message),
+                style =
+                    MaterialTheme.typography.bodyMedium.copy(
+                        color = MaterialTheme.colorScheme.onSurface
+                    ),
+                textAlign = TextAlign.Start,
+            )
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/donate/crypto/Address.kt

@@ -0,0 +1,107 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.crypto
+
+import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
+import com.zaneschepke.wireguardautotunnel.R
+
+data class Address(
+    @StringRes val name: Int,
+    @StringRes val address: Int,
+    @DrawableRes val icon: Int,
+) {
+    companion object {
+        val allAddresses =
+            listOf(
+                Address(
+                    name = R.string.bitcoin,
+                    address = R.string.bitcoin_address,
+                    icon = R.drawable.btc,
+                ),
+                Address(
+                    name = R.string.monero,
+                    address = R.string.monero_address,
+                    icon = R.drawable.xmr,
+                ),
+                Address(
+                    name = R.string.ethereum,
+                    address = R.string.ethereum_address,
+                    icon = R.drawable.eth,
+                ),
+                Address(
+                    name = R.string.zcash,
+                    address = R.string.zcash_address,
+                    icon = R.drawable.zcash,
+                ),
+                Address(
+                    name = R.string.litecoin_mweb,
+                    address = R.string.litecoin_mweb_address,
+                    icon = R.drawable.ltc,
+                ),
+                Address(
+                    name = R.string.litecoin,
+                    address = R.string.litecoin_address,
+                    icon = R.drawable.ltc,
+                ),
+                Address(
+                    name = R.string.polygon,
+                    address = R.string.polygon_address,
+                    icon = R.drawable.polygon,
+                ),
+                Address(
+                    name = R.string.avalanche,
+                    address = R.string.avalanche_address,
+                    icon = R.drawable.avalanche,
+                ),
+                Address(
+                    name = R.string.solana,
+                    address = R.string.solana_address,
+                    icon = R.drawable.solana,
+                ),
+                Address(
+                    name = R.string.stellar,
+                    address = R.string.stellar_address,
+                    icon = R.drawable.stellar,
+                ),
+                Address(
+                    name = R.string.tron,
+                    address = R.string.tron_address,
+                    icon = R.drawable.tron,
+                ),
+                Address(
+                    name = R.string.bitcoin_cash,
+                    address = R.string.bitcoin_cash_address,
+                    icon = R.drawable.bitcoin_cash,
+                ),
+                Address(
+                    name = R.string.ecash,
+                    address = R.string.ecash_address,
+                    icon = R.drawable.ecash,
+                ),
+                Address(
+                    name = R.string.nano,
+                    address = R.string.nano_address,
+                    icon = R.drawable.nano,
+                ),
+                Address(
+                    name = R.string.zano,
+                    address = R.string.zano_address,
+                    icon = R.drawable.zano,
+                ),
+                Address(
+                    name = R.string.decred,
+                    address = R.string.decred_address,
+                    icon = R.drawable.decred,
+                ),
+                Address(
+                    name = R.string.wownero,
+                    address = R.string.wownero_address,
+                    icon = R.drawable.wownero,
+                ),
+                Address(
+                    name = R.string.doge,
+                    address = R.string.doge_address,
+                    icon = R.drawable.doge,
+                ),
+            )
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/donate/crypto/AddressesScreen.kt

@@ -0,0 +1,33 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.crypto
+
+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.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.SurfaceSelectionGroupButton
+import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberClipboardHelper
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.crypto.components.addressItem
+
+@Composable
+fun AddressesScreen() {
+    Column(
+        horizontalAlignment = Alignment.Start,
+        verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),
+        modifier =
+            Modifier.fillMaxSize()
+                .verticalScroll(rememberScrollState())
+                .padding(vertical = 24.dp)
+                .padding(horizontal = 12.dp),
+    ) {
+        val clipboard = rememberClipboardHelper()
+        SurfaceSelectionGroupButton(
+            Address.allAddresses.map { addressItem(it) { address -> clipboard.copy(address) } }
+        )
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/donate/crypto/components/addressItem.kt

@@ -0,0 +1,61 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.donate.crypto.components
+
+import androidx.compose.animation.animateContentSize
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CopyAll
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+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.screens.support.donate.crypto.Address
+import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+
+@Composable
+fun addressItem(address: Address, onClick: (address: String) -> Unit): SelectionItem {
+    val context = LocalContext.current
+    val walletAddress = context.getString(address.address)
+    var expand by rememberSaveable { mutableStateOf(false) }
+    return SelectionItem(
+        leading = {
+            Image(
+                painter = painterResource(id = address.icon),
+                contentDescription = null,
+                modifier = Modifier.size(iconSize),
+            )
+        },
+        trailing = {
+            IconButton(onClick = { onClick(walletAddress) }) {
+                Icon(Icons.Outlined.CopyAll, contentDescription = null)
+            }
+        },
+        title = { SelectionItemLabel(stringResource(address.name), SelectionLabelType.TITLE) },
+        description = {
+            Text(
+                text = walletAddress,
+                style =
+                    MaterialTheme.typography.bodySmall.copy(
+                        color = MaterialTheme.colorScheme.outline
+                    ),
+                maxLines = if (expand) Int.MAX_VALUE else 1,
+                overflow = if (expand) TextOverflow.Clip else TextOverflow.Ellipsis,
+                modifier = Modifier.animateContentSize(),
+            )
+        },
+        onClick = { expand = !expand },
+    )
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/support/license/LicenseScreen.kt

@@ -5,16 +5,11 @@ import android.content.Context
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.Text
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.license.components.LicenseList
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.json.Json
@@ -22,18 +17,8 @@ import kotlinx.serialization.json.Json
 @Composable
 fun LicenseScreen() {
     val context = LocalContext.current
-    val sharedViewModel = LocalSharedVm.current
     var licenses by remember { mutableStateOf<List<LicenseFileEntry>>(emptyList()) }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(stringResource(R.string.licenses)) },
-            )
-        )
-    }
-
     LaunchedEffect(Unit) { licenses = loadLicenseeJson(context) }
 
     if (licenses.isEmpty()) {

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

@@ -1,17 +1,15 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels
 
-import android.os.Build
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.rounded.Sort
-import androidx.compose.material.icons.rounded.*
 import androidx.compose.material3.Text
-import androidx.compose.runtime.*
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -21,7 +19,6 @@ import com.journeyapps.barcodescanner.ScanOptions
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
 import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberClipboardHelper
 import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberFileImportLauncherForResult
@@ -30,10 +27,11 @@ import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components.ExportT
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components.TunnelImportSheet
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components.TunnelList
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components.UrlImportDialog
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
 import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.StringValue
 import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 
 @Composable
 fun TunnelsScreen(viewModel: TunnelsViewModel) {
@@ -41,6 +39,7 @@ fun TunnelsScreen(viewModel: TunnelsViewModel) {
     val navController = LocalNavController.current
     val clipboard = rememberClipboardHelper()
 
+    val sharedState by sharedViewModel.container.stateFlow.collectAsStateWithLifecycle()
     val tunnelsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
     var showExportSheet by rememberSaveable { mutableStateOf(false) }
@@ -48,70 +47,16 @@ fun TunnelsScreen(viewModel: TunnelsViewModel) {
     var showDeleteModal by rememberSaveable { mutableStateOf(false) }
     var showUrlDialog by rememberSaveable { mutableStateOf(false) }
 
-    if (!tunnelsState.stateInitialized) return
-
-    @Composable
-    fun TunnelActionBar() {
-        val selectedCount by
-            remember(tunnelsState.selectedTunnels) {
-                derivedStateOf { tunnelsState.selectedTunnels.size }
-            }
-        val disableDelete by
-            remember(tunnelsState.activeTunnels, tunnelsState.selectedTunnels) {
-                derivedStateOf {
-                    tunnelsState.activeTunnels.any { active ->
-                        tunnelsState.selectedTunnels.any { it.id == active.key.id }
-                    }
-                }
-            }
-
-        Row {
-            if (selectedCount == 0) {
-                val showSort by
-                    remember(tunnelsState.tunnels) {
-                        derivedStateOf { tunnelsState.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) { showImportSheet = true }
-                return@Row
-            }
-            ActionIconButton(Icons.Rounded.SelectAll, R.string.select_all) {
-                viewModel.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) {
-                    showExportSheet = true
-                }
-            }
-
-            if (selectedCount == 1) {
-                ActionIconButton(Icons.Rounded.CopyAll, R.string.copy) {
-                    viewModel.copySelectedTunnel()
-                }
-            }
-
-            if (!disableDelete) {
-                ActionIconButton(Icons.Rounded.Delete, R.string.delete_tunnel) {
-                    showDeleteModal = true
-                }
-            }
+    sharedViewModel.collectSideEffect { sideEffect ->
+        when (sideEffect) {
+            LocalSideEffect.Sheet.ImportTunnels -> showImportSheet = true
+            LocalSideEffect.Modal.DeleteTunnels -> showDeleteModal = true
+            LocalSideEffect.Sheet.ExportTunnels -> showExportSheet = true
+            else -> Unit
         }
     }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                topTitle = { Text(stringResource(R.string.tunnels)) },
-                topTrailing = { TunnelActionBar() },
-                showBottomItems = true,
-            )
-        )
-    }
+    if (!tunnelsState.stateInitialized) return
 
     val tunnelFileImportResultLauncher =
         rememberFileImportLauncherForResult(
@@ -150,7 +95,7 @@ fun TunnelsScreen(viewModel: TunnelsViewModel) {
         InfoDialog(
             onDismiss = { showDeleteModal = false },
             onAttest = {
-                viewModel.deleteSelectedTunnels()
+                sharedViewModel.deleteSelectedTunnels()
                 showDeleteModal = false
             },
             title = { Text(text = stringResource(R.string.delete_tunnel)) },
@@ -161,10 +106,10 @@ fun TunnelsScreen(viewModel: TunnelsViewModel) {
 
     if (showExportSheet) {
         ExportTunnelsBottomSheet({ type, uri ->
-            viewModel.exportSelectedTunnels(type, uri, tunnelsState.selectedTunnels)
+            sharedViewModel.exportSelectedTunnels(type, uri)
         }) {
             showExportSheet = false
-            viewModel.clearSelectedTunnels()
+            sharedViewModel.clearSelectedTunnels()
         }
     }
 
@@ -197,8 +142,8 @@ fun TunnelsScreen(viewModel: TunnelsViewModel) {
 
     TunnelList(
         tunnelsState,
+        sharedState,
         modifier = Modifier.fillMaxSize().padding(vertical = 24.dp).padding(horizontal = 12.dp),
-        viewModel,
         sharedViewModel,
         navController,
     )

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

@@ -6,24 +6,23 @@ 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.material3.Text
-import androidx.compose.runtime.*
+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.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components.MobileDataTunnelItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components.PingRestartItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components.WifiTunnelItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.autotunnel.components.ethernetTunnelItem
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
 
 @Composable
 fun TunnelAutoTunnelScreen(tunnelId: Int, viewModel: TunnelsViewModel) {
-    val sharedViewModel = LocalSharedVm.current
     val tunnelsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
     val tunnelConf by
@@ -31,12 +30,6 @@ fun TunnelAutoTunnelScreen(tunnelId: Int, viewModel: TunnelsViewModel) {
             derivedStateOf { tunnelsState.tunnels.find { it.id == tunnelId }!! }
         }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(showBottomItems = true, topTitle = { Text(tunnelConf.name) })
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(12.dp, Alignment.Top),

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

@@ -3,35 +3,26 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.components
 import android.net.Uri
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.FolderZip
-import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.runtime.*
 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.screens.settings.components.AuthorizationPromptWrapper
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.extensions.hasSAFSupport
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ExportTunnelsBottomSheet(
     onExport: (configType: ConfigType, uri: Uri?) -> Unit,
     onDismiss: () -> Unit,
 ) {
     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) }
-    var isAuthorized by remember { mutableStateOf(false) }
     var shouldExport by remember { mutableStateOf(false) }
 
     val selectedTunnelsExportLauncher =
@@ -59,17 +50,6 @@ fun ExportTunnelsBottomSheet(
         }
     }
 
-    if (showAuthPrompt) {
-        AuthorizationPromptWrapper(
-            onDismiss = { showAuthPrompt = false },
-            onSuccess = {
-                showAuthPrompt = false
-                isAuthorized = true
-                shouldExport = true
-            },
-        )
-    }
-
     CustomBottomSheet(
         listOf(
             SheetOption(
@@ -77,11 +57,7 @@ fun ExportTunnelsBottomSheet(
                 stringResource(R.string.export_tunnels_amnezia),
                 onClick = {
                     exportConfigType = ConfigType.AM
-                    if (!isAuthorized && !isTv) {
-                        showAuthPrompt = true
-                    } else {
-                        shouldExport = true
-                    }
+                    shouldExport = true
                 },
             ),
             SheetOption(
@@ -89,11 +65,7 @@ fun ExportTunnelsBottomSheet(
                 stringResource(R.string.export_tunnels_wireguard),
                 onClick = {
                     exportConfigType = ConfigType.WG
-                    if (!isAuthorized && !isTv) {
-                        showAuthPrompt = true
-                    } else {
-                        shouldExport = true
-                    }
+                    shouldExport = true
                 },
             ),
         )

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

@@ -18,21 +18,20 @@ 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.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
 import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
+import com.zaneschepke.wireguardautotunnel.ui.state.SharedAppUiState
 import com.zaneschepke.wireguardautotunnel.ui.state.TunnelsUiState
 import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
 import com.zaneschepke.wireguardautotunnel.viewmodel.SharedAppViewModel
-import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
 
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
 fun TunnelList(
     tunnelsState: TunnelsUiState,
+    sharedState: SharedAppUiState,
     modifier: Modifier = Modifier,
-    viewModel: TunnelsViewModel,
     sharedViewModel: SharedAppViewModel,
     navController: NavController,
 ) {
@@ -48,7 +47,7 @@ fun TunnelList(
             modifier
                 .pointerInput(Unit) {
                     if (tunnelsState.tunnels.isEmpty()) return@pointerInput
-                    viewModel.clearSelectedTunnels()
+                    sharedViewModel.clearSelectedTunnels()
                 }
                 .overscroll(rememberOverscrollEffect()),
         state = lazyListState,
@@ -62,11 +61,11 @@ fun TunnelList(
         items(tunnelsState.tunnels, key = { it.id }) { tunnel ->
             val tunnelState =
                 remember(tunnelsState.activeTunnels) {
-                    tunnelsState.activeTunnels.getValueById(tunnel.id) ?: TunnelState()
+                    tunnelsState.activeTunnels[tunnel.id] ?: TunnelState()
                 }
             val selected =
-                remember(tunnelsState.selectedTunnels) {
-                    tunnelsState.selectedTunnels.any { it.id == tunnel.id }
+                remember(sharedState.selectedTunnels) {
+                    sharedState.selectedTunnels.any { it.id == tunnel.id }
                 }
             TunnelRowItem(
                 state = tunnelState,
@@ -74,7 +73,9 @@ fun TunnelList(
                 tunnel = tunnel,
                 tunnelState = tunnelState,
                 onTvClick = { navController.navigate(Route.TunnelOptions(tunnel.id)) },
-                onToggleSelectedTunnel = { tunnel -> viewModel.toggleSelectedTunnel(tunnel.id) },
+                onToggleSelectedTunnel = { tunnel ->
+                    sharedViewModel.toggleSelectedTunnel(tunnel.id)
+                },
                 onSwitchClick = { checked ->
                     if (checked) sharedViewModel.startTunnel(tunnel)
                     else sharedViewModel.stopTunnel(tunnel)
@@ -86,14 +87,14 @@ fun TunnelList(
                     if (!isTv)
                         Modifier.combinedClickable(
                             onClick = {
-                                if (tunnelsState.selectedTunnels.isNotEmpty()) {
-                                    viewModel.toggleSelectedTunnel(tunnel.id)
+                                if (sharedState.selectedTunnels.isNotEmpty()) {
+                                    sharedViewModel.toggleSelectedTunnel(tunnel.id)
                                 } else {
                                     navController.navigate(Route.TunnelOptions(tunnel.id))
-                                    viewModel.clearSelectedTunnels()
+                                    sharedViewModel.clearSelectedTunnels()
                                 }
                             },
-                            onLongClick = { viewModel.toggleSelectedTunnel(tunnel.id) },
+                            onLongClick = { sharedViewModel.toggleSelectedTunnel(tunnel.id) },
                             interactionSource = remember { MutableInteractionSource() },
                             indication = null,
                         )

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

@@ -9,11 +9,9 @@ import androidx.compose.material3.Checkbox
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.minimumInteractiveComponentSize
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.semantics
@@ -41,10 +39,7 @@ fun TunnelRowItem(
     modifier: Modifier = Modifier,
 ) {
     val context = LocalContext.current
-    val leadingIconColor =
-        remember(state) {
-            if (state.status.isUp()) tunnelState.statistics.asColor() else Color.Gray
-        }
+    var leadingIconColor by remember(state) { mutableStateOf(state.health().asColor()) }
 
     val (leadingIcon, size, typeDescription) =
         remember(tunnel) {
@@ -55,7 +50,7 @@ fun TunnelRowItem(
                     Triple(
                         Icons.Rounded.Smartphone,
                         16.dp,
-                        context.getString(R.string.mobile_data_tunnel),
+                        context.getString(R.string.mobile_tunnel),
                     )
                 tunnel.isEthernetTunnel ->
                     Triple(

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

@@ -6,37 +6,26 @@ 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.material.icons.Icons
-import androidx.compose.material.icons.rounded.Save
-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.platform.LocalSoftwareKeyboardController
-import androidx.compose.ui.res.stringResource
 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.LocalIsAndroidTV
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.SecureScreenFromRecording
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.AuthorizationPromptWrapper
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components.AddPeerButton
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components.InterfaceSection
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components.PeersSection
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
 import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
 import com.zaneschepke.wireguardautotunnel.ui.state.PeerProxy
 import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 
 @Composable
 fun ConfigScreen(tunnelId: Int? = null, viewModel: TunnelsViewModel = hiltViewModel()) {
     val sharedViewModel = LocalSharedVm.current
-    val isTv = LocalIsAndroidTV.current
-    val keyboardController = LocalSoftwareKeyboardController.current
 
     val tunnelsState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
@@ -49,45 +38,22 @@ fun ConfigScreen(tunnelId: Int? = null, viewModel: TunnelsViewModel = hiltViewMo
         mutableStateOf(tunnelConf?.let { ConfigProxy.from(it.toAmConfig()) } ?: ConfigProxy())
     }
 
-    var tunnelName by remember { mutableStateOf(tunnelConf?.name ?: "") }
-
-    LaunchedEffect(key1 = Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(tunnelConf?.name ?: stringResource(R.string.new_tunnel)) },
-                topTrailing = {
-                    ActionIconButton(Icons.Rounded.Save, R.string.save) {
-                        keyboardController?.hide()
-                        viewModel.saveConfigProxy(tunnelId, configProxy, tunnelName)
-                    }
-                },
-            )
-        )
-    }
+    var tunnelName by remember { mutableStateOf(tunnelConf?.tunName ?: "") }
 
     val isTunnelNameTaken by
         remember(tunnelName, tunnelsState.tunnels) {
             derivedStateOf {
-                tunnelsState.tunnels.any { it.name == tunnelName && it.id != tunnelConf?.id }
+                tunnelsState.tunnels.any { it.tunName == tunnelName && it.id != tunnelConf?.id }
             }
         }
 
-    var showAuthPrompt by rememberSaveable { mutableStateOf(false) }
-    var isAuthorized by rememberSaveable { mutableStateOf(isTv) }
+    sharedViewModel.collectSideEffect { sideEffect ->
+        if (sideEffect is LocalSideEffect.SaveChanges)
+            viewModel.saveConfigProxy(tunnelId, configProxy, tunnelName)
+    }
 
     SecureScreenFromRecording()
 
-    if (showAuthPrompt) {
-        AuthorizationPromptWrapper(
-            onDismiss = { showAuthPrompt = false },
-            onSuccess = {
-                showAuthPrompt = false
-                isAuthorized = true
-            },
-        )
-    }
-
     Column(
         horizontalAlignment = Alignment.Start,
         verticalArrangement = Arrangement.spacedBy(24.dp, Alignment.Top),
@@ -101,8 +67,6 @@ fun ConfigScreen(tunnelId: Int? = null, viewModel: TunnelsViewModel = hiltViewMo
             configProxy = configProxy,
             tunnelName,
             isTunnelNameTaken,
-            isAuthorized,
-            toggleAuthPrompt = { showAuthPrompt = !showAuthPrompt },
             onInterfaceChange = { configProxy = configProxy.copy(`interface` = it) },
             onTunnelNameChange = { tunnelName = it },
             onMimicQuic = {
@@ -117,7 +81,6 @@ fun ConfigScreen(tunnelId: Int? = null, viewModel: TunnelsViewModel = hiltViewMo
         )
         PeersSection(
             configProxy,
-            isAuthorized,
             onRemove = {
                 configProxy =
                     configProxy.copy(
@@ -143,7 +106,6 @@ fun ConfigScreen(tunnelId: Int? = null, viewModel: TunnelsViewModel = hiltViewMo
                         peers = configProxy.peers.toMutableList().apply { set(index, peer) }
                     )
             },
-            showAuth = { showAuthPrompt = true },
         )
         AddPeerButton() { configProxy = configProxy.copy(peers = configProxy.peers + PeerProxy()) }
     }

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

@@ -1,19 +1,15 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components
 
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.RemoveRedEye
 import androidx.compose.material.icons.rounded.ContentCopy
 import androidx.compose.material.icons.rounded.Refresh
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.runtime.Composable
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.res.stringResource
@@ -29,11 +25,10 @@ import com.zaneschepke.wireguardautotunnel.ui.common.textbox.ConfigurationTextBo
 import com.zaneschepke.wireguardautotunnel.ui.state.InterfaceProxy
 import java.util.*
 
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun InterfaceFields(
     interfaceState: InterfaceProxy,
-    showAuthPrompt: () -> Unit,
-    isAuthorized: Boolean,
     showScripts: Boolean,
     showAmneziaValues: Boolean,
     onInterfaceChange: (InterfaceProxy) -> Unit,
@@ -43,6 +38,7 @@ fun InterfaceFields(
     val keyboardActions = KeyboardActions(onDone = { keyboardController?.hide() })
     val keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done)
     val locale = Locale.getDefault()
+    var showPrivateKey by rememberSaveable { mutableStateOf(false) }
 
     Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
         ConfigurationTextBox(
@@ -52,33 +48,40 @@ 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(),
             visualTransformation =
-                if (isAuthorized) VisualTransformation.None else PasswordVisualTransformation(),
+                if (showPrivateKey) VisualTransformation.None else PasswordVisualTransformation(),
             trailing = {
-                IconButton(
-                    enabled = true,
-                    onClick = {
-                        if (!isAuthorized) return@IconButton showAuthPrompt()
-                        val keypair = KeyPair()
-                        onInterfaceChange(
-                            interfaceState.copy(
-                                privateKey = keypair.privateKey.toBase64(),
-                                publicKey = keypair.publicKey.toBase64(),
+                CompositionLocalProvider(LocalMinimumInteractiveComponentSize provides 4.dp) {
+                    Row(modifier = Modifier.padding(end = 4.dp)) {
+                        IconButton(onClick = { showPrivateKey = !showPrivateKey }) {
+                            Icon(
+                                Icons.Outlined.RemoveRedEye,
+                                stringResource(R.string.show_password),
                             )
-                        )
-                    },
-                ) {
-                    Icon(
-                        Icons.Rounded.Refresh,
-                        stringResource(R.string.rotate_keys),
-                        tint =
-                            if (isAuthorized) MaterialTheme.colorScheme.onSurface
-                            else MaterialTheme.colorScheme.outline,
-                    )
+                        }
+                        IconButton(
+                            enabled = true,
+                            onClick = {
+                                val keypair = KeyPair()
+                                onInterfaceChange(
+                                    interfaceState.copy(
+                                        privateKey = keypair.privateKey.toBase64(),
+                                        publicKey = keypair.publicKey.toBase64(),
+                                    )
+                                )
+                            },
+                        ) {
+                            Icon(
+                                Icons.Rounded.Refresh,
+                                stringResource(R.string.rotate_keys),
+                                tint = MaterialTheme.colorScheme.onSurface,
+                            )
+                        }
+                    }
                 }
             },
-            enabled = isAuthorized,
+            enabled = true,
             singleLine = true,
             keyboardOptions = keyboardOptions,
             keyboardActions = keyboardActions,

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

@@ -23,8 +23,6 @@ fun InterfaceSection(
     configProxy: ConfigProxy,
     tunnelName: String,
     isTunnelNameTaken: Boolean,
-    isAuthorized: Boolean,
-    toggleAuthPrompt: () -> Unit,
     onInterfaceChange: (InterfaceProxy) -> Unit,
     onTunnelNameChange: (String) -> Unit,
     onMimicQuic: () -> Unit,
@@ -96,11 +94,9 @@ fun InterfaceSection(
             )
             InterfaceFields(
                 interfaceState = configProxy.`interface`,
-                showAuthPrompt = toggleAuthPrompt,
                 showScripts = showScripts,
                 showAmneziaValues = showAmneziaValues,
                 onInterfaceChange = onInterfaceChange,
-                isAuthorized = isAuthorized,
             )
         }
     }

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

@@ -1,13 +1,20 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.config.components
 
-import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.RemoveRedEye
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.res.stringResource
@@ -21,15 +28,11 @@ import com.zaneschepke.wireguardautotunnel.ui.state.PeerProxy
 import java.util.*
 
 @Composable
-fun PeerFields(
-    peer: PeerProxy,
-    onPeerChange: (PeerProxy) -> Unit,
-    showAuthPrompt: () -> Unit,
-    isAuthenticated: Boolean,
-) {
+fun PeerFields(peer: PeerProxy, onPeerChange: (PeerProxy) -> Unit) {
     val keyboardController = LocalSoftwareKeyboardController.current
     val keyboardActions = KeyboardActions(onDone = { keyboardController?.hide() })
     val keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done)
+    var showPresharedKey by rememberSaveable { mutableStateOf(false) }
 
     ConfigurationTextBox(
         value = peer.publicKey,
@@ -42,16 +45,21 @@ fun PeerFields(
     )
     ConfigurationTextBox(
         visualTransformation =
-            if (isAuthenticated) VisualTransformation.None else PasswordVisualTransformation(),
+            if (showPresharedKey) VisualTransformation.None else PasswordVisualTransformation(),
         value = peer.preSharedKey,
-        enabled = isAuthenticated,
+        enabled = true,
         hint = stringResource(R.string.optional),
         onValueChange = { onPeerChange(peer.copy(preSharedKey = it)) },
         label = stringResource(R.string.preshared_key),
-        modifier = Modifier.fillMaxWidth().clickable { if (!isAuthenticated) showAuthPrompt() },
+        modifier = Modifier.fillMaxWidth(),
         keyboardOptions = keyboardOptions,
         keyboardActions = keyboardActions,
         singleLine = true,
+        trailing = {
+            IconButton(onClick = { showPresharedKey = !showPresharedKey }) {
+                Icon(Icons.Outlined.RemoveRedEye, stringResource(R.string.show_password))
+            }
+        },
     )
     ConfigurationTextBox(
         value = peer.persistentKeepalive,

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

@@ -23,11 +23,9 @@ 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 ->
         var isDropDownExpanded by remember { mutableStateOf(false) }
@@ -90,12 +88,7 @@ fun PeersSection(
                         }
                     }
                 }
-                PeerFields(
-                    peer = peer,
-                    onPeerChange = { onUpdatePeer(it, index) },
-                    showAuthPrompt = showAuth,
-                    isAuthenticated = isAuthorized,
-                )
+                PeerFields(peer = peer, onPeerChange = { onUpdatePeer(it, index) })
             }
         }
     }

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

@@ -11,13 +11,13 @@ 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.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
@@ -30,10 +30,10 @@ 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.sideeffect.LocalSideEffect
 import com.zaneschepke.wireguardautotunnel.util.extensions.isSortedBy
 import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 import sh.calvin.reorderable.DragGestureDetector
 import sh.calvin.reorderable.ReorderableItem
 import sh.calvin.reorderable.rememberReorderableLazyListState
@@ -48,34 +48,27 @@ fun SortScreen(viewModel: TunnelsViewModel) {
     var sortAscending by rememberSaveable { mutableStateOf<Boolean?>(null) }
     var editableTunnels by rememberSaveable { mutableStateOf(tunnelsState.tunnels) }
 
-    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
-                                }
-                        }
-                        ActionIconButton(Icons.Rounded.Save, R.string.save) {
-                            viewModel.saveSortChanges(editableTunnels)
-                        }
+    sharedViewModel.collectSideEffect { sideEffect ->
+        when (sideEffect) {
+            LocalSideEffect.SaveChanges -> {
+                viewModel.saveSortChanges(editableTunnels)
+            }
+            LocalSideEffect.Sort -> {
+                sortAscending =
+                    when (sortAscending) {
+                        null -> !editableTunnels.isSortedBy { it.tunName }
+                        true -> false
+                        false -> null
                     }
-                },
-            )
-        )
+                editableTunnels =
+                    when (sortAscending) {
+                        true -> editableTunnels.sortedBy { it.tunName }
+                        false -> editableTunnels.sortedByDescending { it.tunName }
+                        null -> tunnelsState.tunnels
+                    }
+            }
+            else -> Unit
+        }
     }
 
     val lazyListState = rememberLazyListState()
@@ -106,7 +99,7 @@ fun SortScreen(viewModel: TunnelsViewModel) {
             ReorderableItem(reorderableLazyListState, tunnel.id) { isDragging ->
                 ExpandingRowListItem(
                     leading = {},
-                    text = tunnel.name,
+                    text = tunnel.tunName,
                     trailing = {
                         if (!isTv)
                             Icon(

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

@@ -3,28 +3,24 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.size
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Save
 import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.Text
 import androidx.compose.runtime.*
 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.LocalSharedVm
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.components.SplitTunnelContent
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.splittunnel.state.SplitOption
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
 import com.zaneschepke.wireguardautotunnel.viewmodel.SplitTunnelViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 
 @Composable
 fun SplitTunnelScreen(tunnelId: Int, viewModel: SplitTunnelViewModel = hiltViewModel()) {
-    val splitTunnelState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
     val sharedViewModel = LocalSharedVm.current
+    val splitTunnelState by viewModel.container.stateFlow.collectAsStateWithLifecycle()
 
     if (!splitTunnelState.stateInitialized) {
         Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
@@ -51,18 +47,9 @@ fun SplitTunnelScreen(tunnelId: Int, viewModel: SplitTunnelViewModel = hiltViewM
         )
     }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                topTitle = { Text(tunnelConf.name) },
-                topTrailing = {
-                    ActionIconButton(Icons.Rounded.Save, R.string.save) {
-                        viewModel.saveSplitTunnelSelection(tunnelId, splitConfig)
-                    }
-                },
-                showBottomItems = true,
-            )
-        )
+    sharedViewModel.collectSideEffect { sideEffect ->
+        if (sideEffect is LocalSideEffect.SaveChanges)
+            viewModel.saveSplitTunnelSelection(tunnelId, splitConfig)
     }
 
     SplitTunnelContent(

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

@@ -1,34 +1,29 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.tunneloptions
 
-import androidx.compose.foundation.layout.*
+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.material.icons.Icons
-import androidx.compose.material.icons.rounded.Edit
-import androidx.compose.material.icons.rounded.QrCode2
-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.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.data.model.AppMode
 import com.zaneschepke.wireguardautotunnel.ui.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.LocalSharedVm
 import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
-import com.zaneschepke.wireguardautotunnel.ui.common.button.ActionIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
-import com.zaneschepke.wireguardautotunnel.ui.navigation.Route.Config
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.AuthorizationPromptWrapper
 import com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.tunneloptions.components.*
-import com.zaneschepke.wireguardautotunnel.ui.state.NavbarState
+import com.zaneschepke.wireguardautotunnel.ui.sideeffect.LocalSideEffect
 import com.zaneschepke.wireguardautotunnel.viewmodel.TunnelsViewModel
+import org.orbitmvi.orbit.compose.collectSideEffect
 
 @Composable
 fun TunnelOptionsScreen(tunnelId: Int, viewModel: TunnelsViewModel) {
-    val isTv = LocalIsAndroidTV.current
     val navController = LocalNavController.current
     val sharedViewModel = LocalSharedVm.current
 
@@ -39,50 +34,17 @@ fun TunnelOptionsScreen(tunnelId: Int, viewModel: TunnelsViewModel) {
             derivedStateOf { tunnelsState.tunnels.find { it.id == tunnelId }!! }
         }
 
-    var showAuthPrompt by rememberSaveable { mutableStateOf(!isTv) }
-    var isAuthorized by rememberSaveable { mutableStateOf(isTv) }
+    val ipv6Preferred by
+        remember(tunnelConf.isIpv4Preferred) { mutableStateOf(!tunnelConf.isIpv4Preferred) }
+
     var showQrModal by rememberSaveable { mutableStateOf(false) }
 
-    LaunchedEffect(Unit) {
-        sharedViewModel.updateNavbarState(
-            NavbarState(
-                showBottomItems = true,
-                topTitle = { Text(tunnelConf.name) },
-                topTrailing = {
-                    Row {
-                        ActionIconButton(
-                            Icons.Rounded.QrCode2,
-                            com.zaneschepke.wireguardautotunnel.R.string.show_qr,
-                        ) {
-                            showQrModal = true
-                        }
-                        ActionIconButton(Icons.Rounded.Edit, R.string.edit_tunnel) {
-                            navController.navigate(Config(tunnelId))
-                        }
-                    }
-                },
-            )
-        )
+    sharedViewModel.collectSideEffect { sideEffect ->
+        if (sideEffect is LocalSideEffect.Modal.QR) showQrModal = true
     }
 
     if (showQrModal) {
-
-        // Show authorization prompt if needed
-        if (showAuthPrompt) {
-            AuthorizationPromptWrapper(
-                onDismiss = {
-                    showAuthPrompt = false
-                    showQrModal = false
-                },
-                onSuccess = {
-                    showAuthPrompt = false
-                    isAuthorized = true
-                },
-            )
-        }
-        if (isAuthorized) {
-            QrCodeDialog(tunnelConf = tunnelConf, onDismiss = { showQrModal = false })
-        }
+        QrCodeDialog(tunnelConf = tunnelConf, onDismiss = { showQrModal = false })
     }
 
     Column(
@@ -96,12 +58,28 @@ fun TunnelOptionsScreen(tunnelId: Int, viewModel: TunnelsViewModel) {
     ) {
         SurfaceSelectionGroupButton(
             items =
-                listOf(
-                    PrimaryTunnelItem(tunnelConf) { viewModel.togglePrimaryTunnel(tunnelId) },
-                    AutoTunnelingItem(tunnelConf, navController),
-                    serverIpv4Item(tunnelConf) { viewModel.toggleIpv4Preferred(tunnelId) },
-                    SplitTunnelingItem(tunnelConf, navController),
-                )
+                buildList {
+                    add(primaryTunnelItem(tunnelConf) { viewModel.togglePrimaryTunnel(tunnelId) })
+                    add(autoTunnelingItem(tunnelConf, navController))
+                    add(splitTunnelingItem(tunnelConf, navController))
+                }
+        )
+        SectionDivider()
+        SurfaceSelectionGroupButton(
+            items =
+                buildList {
+                    add(
+                        dynamicDnsItem(tunnelConf.restartOnPingFailure) {
+                            viewModel.setRestartOnPing(tunnelId, it)
+                        }
+                    )
+                    if (tunnelsState.appMode != AppMode.KERNEL)
+                        add(
+                            preferIpv6Item(ipv6Preferred) {
+                                viewModel.toggleIpv4Preferred(tunnelId)
+                            }
+                        )
+                }
         )
         if (tunnelsState.isPingEnabled) {
             SectionDivider()

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

@@ -51,7 +51,7 @@ private fun QrCodeAlertDialog(tunnelConf: TunnelConf, onDismiss: () -> Unit) {
             },
             title = {
                 Text(
-                    text = tunnelConf.name,
+                    text = tunnelConf.tunName,
                     color = Color.Black,
                     style = MaterialTheme.typography.titleLarge,
                 )

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

@@ -15,7 +15,7 @@ import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionIte
 import com.zaneschepke.wireguardautotunnel.ui.navigation.Route
 
 @Composable
-fun AutoTunnelingItem(tunnelConf: TunnelConf, navController: NavController): SelectionItem {
+fun autoTunnelingItem(tunnelConf: TunnelConf, navController: NavController): SelectionItem {
     return SelectionItem(
         leading = { Icon(Icons.Outlined.Bolt, contentDescription = null) },
         title = {

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

@@ -0,0 +1,33 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.tunneloptions.components
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Dns
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+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.common.button.surface.SelectionItemLabel
+import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionLabelType
+
+@Composable
+fun dynamicDnsItem(enabled: Boolean, onClick: (checked: Boolean) -> Unit): SelectionItem {
+    return SelectionItem(
+        leading = { Icon(Icons.Outlined.Dns, contentDescription = null) },
+        title = {
+            SelectionItemLabel(
+                stringResource(R.string.ddns_auto_update),
+                labelType = SelectionLabelType.TITLE,
+            )
+        },
+        description = {
+            SelectionItemLabel(
+                stringResource(R.string.ddns_auto_update_description),
+                labelType = SelectionLabelType.DESCRIPTION,
+            )
+        },
+        trailing = { ScaledSwitch(checked = enabled, onClick = onClick) },
+        onClick = { onClick(!enabled) },
+    )
+}

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

@@ -1,35 +1,28 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.tunnels.tunneloptions.components
 
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Dns
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.res.vectorResource
 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
 
 @Composable
-fun serverIpv4Item(tunnelConf: TunnelConf, onClick: () -> Unit): SelectionItem {
+fun preferIpv6Item(checked: Boolean, onClick: () -> Unit): SelectionItem {
     return SelectionItem(
-        leading = { Icon(Icons.Outlined.Dns, contentDescription = null) },
+        leading = { Icon(ImageVector.vectorResource(R.drawable.host), contentDescription = null) },
         title = {
             Text(
-                text = stringResource(R.string.server_ipv4),
+                text = stringResource(R.string.prefer_ipv6_resolution),
                 style =
                     MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
             )
         },
-        description = {
-            Text(
-                text = stringResource(R.string.prefer_ipv4),
-                style = MaterialTheme.typography.bodySmall.copy(MaterialTheme.colorScheme.outline),
-            )
-        },
-        trailing = { ScaledSwitch(checked = tunnelConf.isIpv4Preferred, onClick = { onClick() }) },
+        trailing = { ScaledSwitch(checked = checked, onClick = { onClick() }) },
         onClick = onClick,
     )
 }