build(deps): bump androidGradlePlugin from 8.7.2 to 8.7.3

Bumps `androidGradlePlugin` from 8.7.2 to 8.7.3. Updates `com.android.application` from 8.7.2 to 8.7.3 Updates `com.android.library` from 8.7.2 to 8.7.3 --- updated-dependencies: - dependency-name: com.android.application dependency-type: direct:production update-type: version-update:semver-patch - dependency-name: com.android.library dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>
2026-07-03 14:07:49 +02:00 · 2024-12-03 13:55:51 +00:00
64 changed files with 764 additions and 1376 deletions
@@ -1,267 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 13,
-    "identityHash": "ff209157b98a641c424f5086818ec585",
-    "entities": [
-      {
-        "tableName": "Settings",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_enabled` INTEGER NOT NULL DEFAULT false, `is_restore_on_boot_enabled` INTEGER NOT NULL DEFAULT false, `is_multi_tunnel_enabled` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false, `is_amnezia_enabled` INTEGER NOT NULL DEFAULT false, `is_wildcards_enabled` INTEGER NOT NULL DEFAULT false, `is_wifi_by_shell_enabled` INTEGER NOT NULL DEFAULT false, `is_stop_on_no_internet_enabled` INTEGER NOT NULL DEFAULT false, `is_vpn_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_lan_on_kill_switch_enabled` INTEGER NOT NULL DEFAULT false)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "isAutoTunnelEnabled",
-            "columnName": "is_tunnel_enabled",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "isTunnelOnMobileDataEnabled",
-            "columnName": "is_tunnel_on_mobile_data_enabled",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "trustedNetworkSSIDs",
-            "columnName": "trusted_network_ssids",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "isAlwaysOnVpnEnabled",
-            "columnName": "is_always_on_vpn_enabled",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "isTunnelOnEthernetEnabled",
-            "columnName": "is_tunnel_on_ethernet_enabled",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "isShortcutsEnabled",
-            "columnName": "is_shortcuts_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isTunnelOnWifiEnabled",
-            "columnName": "is_tunnel_on_wifi_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isKernelEnabled",
-            "columnName": "is_kernel_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isRestoreOnBootEnabled",
-            "columnName": "is_restore_on_boot_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isMultiTunnelEnabled",
-            "columnName": "is_multi_tunnel_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isPingEnabled",
-            "columnName": "is_ping_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isAmneziaEnabled",
-            "columnName": "is_amnezia_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isWildcardsEnabled",
-            "columnName": "is_wildcards_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isWifiNameByShellEnabled",
-            "columnName": "is_wifi_by_shell_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isStopOnNoInternetEnabled",
-            "columnName": "is_stop_on_no_internet_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isVpnKillSwitchEnabled",
-            "columnName": "is_vpn_kill_switch_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isKernelKillSwitchEnabled",
-            "columnName": "is_kernel_kill_switch_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isLanOnKillSwitchEnabled",
-            "columnName": "is_lan_on_kill_switch_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "TunnelConfig",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false, `ping_interval` INTEGER DEFAULT null, `ping_cooldown` INTEGER DEFAULT null, `ping_ip` TEXT DEFAULT null, `is_ethernet_tunnel` INTEGER NOT NULL DEFAULT false)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "name",
-            "columnName": "name",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "wgQuick",
-            "columnName": "wg_quick",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tunnelNetworks",
-            "columnName": "tunnel_networks",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "isMobileDataTunnel",
-            "columnName": "is_mobile_data_tunnel",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isPrimaryTunnel",
-            "columnName": "is_primary_tunnel",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "amQuick",
-            "columnName": "am_quick",
-            "affinity": "TEXT",
-            "notNull": true,
-            "defaultValue": "''"
-          },
-          {
-            "fieldPath": "isActive",
-            "columnName": "is_Active",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "isPingEnabled",
-            "columnName": "is_ping_enabled",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          },
-          {
-            "fieldPath": "pingInterval",
-            "columnName": "ping_interval",
-            "affinity": "INTEGER",
-            "notNull": false,
-            "defaultValue": "null"
-          },
-          {
-            "fieldPath": "pingCooldown",
-            "columnName": "ping_cooldown",
-            "affinity": "INTEGER",
-            "notNull": false,
-            "defaultValue": "null"
-          },
-          {
-            "fieldPath": "pingIp",
-            "columnName": "ping_ip",
-            "affinity": "TEXT",
-            "notNull": false,
-            "defaultValue": "null"
-          },
-          {
-            "fieldPath": "isEthernetTunnel",
-            "columnName": "is_ethernet_tunnel",
-            "affinity": "INTEGER",
-            "notNull": true,
-            "defaultValue": "false"
-          }
-        ],
-        "primaryKey": {
-          "autoGenerate": true,
-          "columnNames": [
-            "id"
-          ]
-        },
-        "indices": [
-          {
-            "name": "index_TunnelConfig_name",
-            "unique": true,
-            "columnNames": [
-              "name"
-            ],
-            "orders": [],
-            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
-          }
-        ],
-        "foreignKeys": []
-      }
-    ],
-    "views": [],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'ff209157b98a641c424f5086818ec585')"
-    ]
-  }
-}
@@ -204,10 +204,5 @@
 				<action android:name="com.wireguard.android.action.REFRESH_TUNNEL_STATES" />
 			</intent-filter>
 		</receiver>
-		<receiver
-			android:name=".receiver.NotificationActionReceiver"
-			android:exported="false"
-			android:permission="${applicationId}.permission.CONTROL_TUNNELS">
-		</receiver>
    </application>
 </manifest>
@@ -3,14 +3,12 @@ package com.zaneschepke.wireguardautotunnel
 import android.app.Application
 import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.core.os.LocaleListCompat
 import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.module.MainDispatcher
-import com.zaneschepke.wireguardautotunnel.service.tunnel.BackendState
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
 import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
 import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
@@ -18,7 +16,6 @@ import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import timber.log.Timber
 import javax.inject.Inject

@@ -35,20 +32,10 @@ class WireGuardAutoTunnel : Application() {
 	@Inject
 	lateinit var appStateRepository: AppStateRepository

-	@Inject
-	lateinit var settingsRepository: SettingsRepository
-
-	@Inject
-	lateinit var tunnelService: TunnelService
-
 	@Inject
 	@IoDispatcher
 	lateinit var ioDispatcher: CoroutineDispatcher

-	@Inject
-	@MainDispatcher
-	lateinit var mainDispatcher: CoroutineDispatcher
-
 	override fun onCreate() {
 		super.onCreate()
 		instance = this
@@ -65,26 +52,21 @@ class WireGuardAutoTunnel : Application() {
 		} else {
 			Timber.plant(ReleaseTree())
 		}
-
 		applicationScope.launch {
-			withContext(mainDispatcher) {
-				if (appStateRepository.isLocalLogsEnabled() && !isRunningOnTv()) logReader.initialize()
-			}
-			if (!settingsRepository.getSettings().isKernelEnabled) {
-				tunnelService.setBackendState(BackendState.SERVICE_ACTIVE, emptyList())
-			}
-
 			appStateRepository.getLocale()?.let {
-				LocaleUtil.changeLocale(it)
+				val locale = LocaleUtil.getLocaleFromPrefCode(it)
+				val appLocale: LocaleListCompat = LocaleListCompat.forLanguageTags(locale)
+				AppCompatDelegate.setApplicationLocales(appLocale)
 			}
 		}
-	}
-
-	override fun onTerminate() {
-		applicationScope.launch {
-			tunnelService.setBackendState(BackendState.INACTIVE, emptyList())
+		if (!isRunningOnTv()) {
+			applicationScope.launch(ioDispatcher) {
+				if (appStateRepository.isLocalLogsEnabled()) {
+					Timber.d("Starting logger")
+					logReader.start()
+				}
+			}
 		}
-		super.onTerminate()
 	}

 	companion object {
@@ -11,7 +11,7 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig

@Database(
 	entities = [Settings::class, TunnelConfig::class],
-	version = 13,
+	version = 12,
 	autoMigrations =
 	[
 		AutoMigration(from = 1, to = 2),
@@ -45,10 +45,6 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 			from = 11,
 			to = 12,
 		),
-		AutoMigration(
-			from = 12,
-			to = 13,
-		),
 	],
 	exportSchema = true,
 )
@@ -16,7 +16,7 @@ object Queries {
 		        VALUES
 		        ('false',
 		        'false',
-		        '',
+		        'sampleSSID1,sampleSSID2',
 		        'false',
 		        'false',
 		        'false',
@@ -65,19 +65,4 @@ data class Settings(
 		defaultValue = "false",
 	)
 	val isStopOnNoInternetEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_vpn_kill_switch_enabled",
-		defaultValue = "false",
-	)
-	val isVpnKillSwitchEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_kernel_kill_switch_enabled",
-		defaultValue = "false",
-	)
-	val isKernelKillSwitchEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_lan_on_kill_switch_enabled",
-		defaultValue = "false",
-	)
-	val isLanOnKillSwitchEnabled: Boolean = false,
 )
@@ -92,14 +92,5 @@ data class TunnelConfig(
 		}

 		const val AM_QUICK_DEFAULT = ""
-
-		val IPV4_PUBLIC_NETWORKS = setOf(
-			"0.0.0.0/5", "8.0.0.0/7", "11.0.0.0/8", "12.0.0.0/6", "16.0.0.0/4", "32.0.0.0/3",
-			"64.0.0.0/2", "128.0.0.0/3", "160.0.0.0/5", "168.0.0.0/6", "172.0.0.0/12",
-			"172.32.0.0/11", "172.64.0.0/10", "172.128.0.0/9", "173.0.0.0/8", "174.0.0.0/7",
-			"176.0.0.0/4", "192.0.0.0/9", "192.128.0.0/11", "192.160.0.0/13", "192.169.0.0/16",
-			"192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10",
-			"193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6", "200.0.0.0/5", "208.0.0.0/4",
-		)
 	}
 }
@@ -17,6 +17,10 @@ interface AppStateRepository {

 	suspend fun setBatteryOptimizationDisableShown(shown: Boolean)

+	suspend fun getCurrentSsid(): String?
+
+	suspend fun setCurrentSsid(ssid: String)
+
 	suspend fun isTunnelStatsExpanded(): Boolean

 	suspend fun setTunnelStatsExpanded(expanded: Boolean)
@@ -38,6 +38,14 @@ class DataStoreAppStateRepository(
 		dataStoreManager.saveToDataStore(DataStoreManager.batteryDisableShown, shown)
 	}

+	override suspend fun getCurrentSsid(): String? {
+		return dataStoreManager.getFromStore(DataStoreManager.currentSSID)
+	}
+
+	override suspend fun setCurrentSsid(ssid: String) {
+		dataStoreManager.saveToDataStore(DataStoreManager.currentSSID, ssid)
+	}
+
 	override suspend fun isTunnelStatsExpanded(): Boolean {
 		return dataStoreManager.getFromStore(DataStoreManager.tunnelStatsExpanded)
 			?: GeneralState.IS_TUNNEL_STATS_EXPANDED
@@ -2,9 +2,7 @@ package com.zaneschepke.wireguardautotunnel.module

 import android.content.Context
 import com.zaneschepke.logcatter.LogReader
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.notification.WireGuardNotification
-import com.zaneschepke.logcatter.LogcatReader
+import com.zaneschepke.logcatter.LogcatCollector
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -27,12 +25,6 @@ class AppModule {
 	@Singleton
 	@Provides
 	fun provideLogCollect(@ApplicationContext context: Context): LogReader {
-		return LogcatReader.init(storageDir = context.filesDir.absolutePath)
-	}
-
-	@Singleton
-	@Provides
-	fun provideNotificationService(@ApplicationContext context: Context): NotificationService {
-		return WireGuardNotification(context)
+		return LogcatCollector.init(context = context)
 	}
 }
@@ -4,6 +4,8 @@ import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
 import com.zaneschepke.wireguardautotunnel.service.network.WifiService
+import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
+import com.zaneschepke.wireguardautotunnel.service.notification.WireGuardNotification
 import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
@@ -13,6 +15,10 @@ import dagger.hilt.android.scopes.ServiceScoped
@Module
@InstallIn(ServiceComponent::class)
 abstract class ServiceModule {
+	@Binds
+	@ServiceScoped
+	abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification): NotificationService
+
 	@Binds
 	@ServiceScoped
 	abstract fun provideWifiService(wifiService: WifiService): NetworkService<WifiService>
@@ -10,7 +10,6 @@ import com.wireguard.android.util.ToolsInstaller
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
@@ -77,7 +76,6 @@ class TunnelModule {
 		@ApplicationScope applicationScope: CoroutineScope,
 		@IoDispatcher ioDispatcher: CoroutineDispatcher,
 		serviceManager: ServiceManager,
-		notificationService: NotificationService,
 	): TunnelService {
 		return WireGuardTunnel(
 			amneziaBackend,
@@ -87,17 +85,12 @@ class TunnelModule {
 			applicationScope,
 			ioDispatcher,
 			serviceManager,
-			notificationService,
 		)
 	}

 	@Singleton
 	@Provides
-	fun provideServiceManager(
-		@ApplicationContext context: Context,
-		@IoDispatcher ioDispatcher: CoroutineDispatcher,
-		appDataRepository: AppDataRepository,
-	): ServiceManager {
-		return ServiceManager(context, ioDispatcher, appDataRepository)
+	fun provideServiceManager(@ApplicationContext context: Context): ServiceManager {
+		return ServiceManager.getInstance(context)
 	}
 }
@@ -5,8 +5,8 @@ import android.content.Context
 import android.content.Intent
 import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
@@ -26,9 +26,6 @@ class KernelReceiver : BroadcastReceiver() {
 	@Inject
 	lateinit var tunnelConfigRepository: TunnelConfigRepository

-	@Inject
-	lateinit var serviceManager: ServiceManager
-
 	override fun onReceive(context: Context, intent: Intent) {
 		val action = intent.action ?: return
 		applicationScope.launch {
@@ -40,7 +37,7 @@ class KernelReceiver : BroadcastReceiver() {
 						tunnelConfigRepository.save(it.copy(isActive = true))
 					}
 				}
-				serviceManager.updateTunnelTile()
+				context.requestTunnelTileServiceStateUpdate()
 			}
 		}
 	}
@@ -1,36 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.receiver
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationAction
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class NotificationActionReceiver : BroadcastReceiver() {
-
-	@Inject
-	lateinit var serviceManager: ServiceManager
-
-	@Inject
-	lateinit var tunnelService: TunnelService
-
-	@Inject
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
-
-	override fun onReceive(context: Context, intent: Intent) {
-		applicationScope.launch {
-			when (intent.action) {
-				NotificationAction.AUTO_TUNNEL_OFF.name -> serviceManager.stopAutoTunnel()
-				NotificationAction.TUNNEL_OFF.name -> tunnelService.stopTunnel()
-			}
-		}
-	}
-}
@@ -3,25 +3,20 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 import android.app.Service
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel.AutoTunnelService
-import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
-import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
-import com.zaneschepke.wireguardautotunnel.util.extensions.requestAutoTunnelTileServiceUpdate
+import com.zaneschepke.wireguardautotunnel.util.SingletonHolder
 import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
 import jakarta.inject.Inject
 import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.withContext
 import timber.log.Timber

@OptIn(ExperimentalCoroutinesApi::class)
 class ServiceManager
-@Inject constructor(private val context: Context, private val ioDispatcher: CoroutineDispatcher, private val appDataRepository: AppDataRepository) {
+@Inject constructor(private val context: Context) {

 	private val _autoTunnelActive = MutableStateFlow(false)

@@ -29,8 +24,8 @@ class ServiceManager

 	var autoTunnelService = CompletableDeferred<AutoTunnelService>()
 	var backgroundService = CompletableDeferred<TunnelBackgroundService>()
-	var autoTunnelTile = CompletableDeferred<AutoTunnelControlTile>()
-	var tunnelControlTile = CompletableDeferred<TunnelControlTile>()
+
+	companion object : SingletonHolder<ServiceManager, Context>(::ServiceManager)

 	private fun <T : Service> startService(cls: Class<T>, background: Boolean) {
 		runCatching {
@@ -44,15 +39,12 @@ class ServiceManager
 	}

 	suspend fun startAutoTunnel(background: Boolean) {
-		val settings = appDataRepository.settings.getSettings()
-		appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = true))
 		if (autoTunnelService.isCompleted) return _autoTunnelActive.update { true }
 		kotlin.runCatching {
 			startService(AutoTunnelService::class.java, background)
 			autoTunnelService.await()
 			autoTunnelService.getCompleted().start()
 			_autoTunnelActive.update { true }
-			updateAutoTunnelTile()
 		}.onFailure {
 			Timber.e(it)
 		}
@@ -78,41 +70,17 @@ class ServiceManager
 		}
 	}

-	suspend fun toggleAutoTunnel(background: Boolean) {
-		withContext(ioDispatcher) {
-			if (_autoTunnelActive.value) return@withContext stopAutoTunnel()
-			startAutoTunnel(background)
+	fun stopAutoTunnel() {
+		if (!autoTunnelService.isCompleted) return
+		runCatching {
+			autoTunnelService.getCompleted().stop()
+			_autoTunnelActive.update { false }
+		}.onFailure {
+			Timber.e(it)
 		}
 	}

-	fun updateAutoTunnelTile() {
-		if (autoTunnelTile.isCompleted) {
-			autoTunnelTile.getCompleted().updateTileState()
-		} else {
-			context.requestAutoTunnelTileServiceUpdate()
-		}
-	}
-
-	fun updateTunnelTile() {
-		if (tunnelControlTile.isCompleted) {
-			tunnelControlTile.getCompleted().updateTileState()
-		} else {
-			context.requestTunnelTileServiceStateUpdate()
-		}
-	}
-
-	suspend fun stopAutoTunnel() {
-		withContext(ioDispatcher) {
-			val settings = appDataRepository.settings.getSettings()
-			appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = false))
-			if (!autoTunnelService.isCompleted) return@withContext
-			runCatching {
-				autoTunnelService.getCompleted().stop()
-				_autoTunnelActive.update { false }
-				updateAutoTunnelTile()
-			}.onFailure {
-				Timber.e(it)
-			}
-		}
+	fun requestTunnelTileUpdate() {
+		context.requestTunnelTileServiceStateUpdate()
 	}
 }
@@ -7,7 +7,6 @@ import androidx.core.app.ServiceCompat
 import androidx.lifecycle.LifecycleService
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CompletableDeferred
@@ -22,6 +21,8 @@ class TunnelBackgroundService : LifecycleService() {
 	@Inject
 	lateinit var serviceManager: ServiceManager

+	private val foregroundId = 123
+
 	override fun onCreate() {
 		super.onCreate()
 		start()
@@ -41,7 +42,7 @@ class TunnelBackgroundService : LifecycleService() {
 	fun start() {
 		ServiceCompat.startForeground(
 			this,
-			NotificationService.KERNEL_SERVICE_NOTIFICATION_ID,
+			foregroundId,
 			createNotification(),
 			Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
 		)
@@ -59,7 +60,8 @@ class TunnelBackgroundService : LifecycleService() {

 	private fun createNotification(): Notification {
 		return notificationService.createNotification(
-			WireGuardNotification.NotificationChannels.VPN,
+			getString(R.string.vpn_channel_id),
+			getString(R.string.vpn_channel_name),
 			getString(R.string.tunnel_running),
 			description = "",
 		)
@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel.model
+package com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel

 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig

@@ -9,27 +9,20 @@ import androidx.lifecycle.LifecycleService
 import androidx.lifecycle.lifecycleScope
 import com.wireguard.android.util.RootShell
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.AppShell
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel.model.AutoTunnelEvent
-import com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel.model.AutoTunnelState
-import com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel.model.NetworkState
 import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.service.network.WifiService
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationAction
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 import com.zaneschepke.wireguardautotunnel.util.extensions.cancelWithMessage
 import com.zaneschepke.wireguardautotunnel.util.extensions.getCurrentWifiName
 import com.zaneschepke.wireguardautotunnel.util.extensions.isReachable
@@ -39,11 +32,10 @@ import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filterNot
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -55,6 +47,7 @@ import javax.inject.Provider

@AndroidEntryPoint
 class AutoTunnelService : LifecycleService() {
+	private val foregroundId = 122

 	@Inject
 	@AppShell
@@ -70,7 +63,7 @@ class AutoTunnelService : LifecycleService() {
 	lateinit var ethernetService: NetworkService<EthernetService>

 	@Inject
-	lateinit var appDataRepository: Provider<AppDataRepository>
+	lateinit var appDataRepository: AppDataRepository

 	@Inject
 	lateinit var notificationService: NotificationService
@@ -99,7 +92,6 @@ class AutoTunnelService : LifecycleService() {

 	override fun onCreate() {
 		super.onCreate()
-		serviceManager.autoTunnelService.complete(this)
 		lifecycleScope.launch(mainImmediateDispatcher) {
 			kotlin.runCatching {
 				launchWatcherNotification()
@@ -111,6 +103,7 @@ class AutoTunnelService : LifecycleService() {

 	override fun onBind(intent: Intent): IBinder? {
 		super.onBind(intent)
+		// We don't provide binding, so return null
 		return null
 	}

@@ -126,8 +119,9 @@ class AutoTunnelService : LifecycleService() {
 				launchWatcherNotification()
 				initWakeLock()
 			}
-			startAutoTunnelJob()
-			startAutoTunnelStateJob()
+			startSettingsJob()
+			startVpnStateJob()
+			startNetworkJobs()
 			startPingStateJob()
 		}.onFailure {
 			Timber.e(it)
@@ -135,7 +129,11 @@ class AutoTunnelService : LifecycleService() {
 	}

 	fun stop() {
-		wakeLock?.let { if (it.isHeld) it.release() }
+		wakeLock?.let {
+			if (it.isHeld) {
+				it.release()
+			}
+		}
 		stopSelf()
 	}

@@ -148,39 +146,62 @@ class AutoTunnelService : LifecycleService() {
 	private fun launchWatcherNotification(description: String = getString(R.string.monitoring_state_changes)) {
 		val notification =
 			notificationService.createNotification(
-				WireGuardNotification.NotificationChannels.AUTO_TUNNEL,
+				channelId = getString(R.string.watcher_channel_id),
+				channelName = getString(R.string.watcher_channel_name),
 				title = getString(R.string.auto_tunnel_title),
 				description = description,
-				actions = listOf(
-					notificationService.createNotificationAction(NotificationAction.AUTO_TUNNEL_OFF),
-				),
 			)
 		ServiceCompat.startForeground(
 			this,
-			NotificationService.AUTO_TUNNEL_NOTIFICATION_ID,
+			foregroundId,
 			notification,
 			Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
 		)
 	}

 	private fun initWakeLock() {
-		wakeLock = (getSystemService(POWER_SERVICE) as PowerManager).run {
-			val tag = this.javaClass.name
-			newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
-				try {
-					Timber.i("Initiating wakelock with 10 min timeout")
-					acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
-				} finally {
-					release()
+		wakeLock =
+			(getSystemService(POWER_SERVICE) as PowerManager).run {
+				val tag = this.javaClass.name
+				newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
+					try {
+						Timber.i("Initiating wakelock with 10 min timeout")
+						acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
+					} finally {
+						release()
+					}
 				}
 			}
-		}
+	}
+
+	private fun startSettingsJob() = lifecycleScope.launch {
+		watchForSettingsChanges()
+	}
+
+	private fun startVpnStateJob() = lifecycleScope.launch {
+		watchForVpnStateChanges()
+	}
+
+	private fun startWifiJob() = lifecycleScope.launch {
+		watchForWifiConnectivityChanges()
+	}
+
+	private fun startMobileDataJob() = lifecycleScope.launch {
+		watchForMobileDataConnectivityChanges()
+	}
+
+	private fun startEthernetJob() = lifecycleScope.launch {
+		watchForEthernetConnectivityChanges()
 	}

 	private fun startPingJob() = lifecycleScope.launch {
 		watchForPingFailure()
 	}

+	private fun startNetworkEventJob() = lifecycleScope.launch {
+		handleNetworkEventChanges()
+	}
+
 	private fun startPingStateJob() = lifecycleScope.launch {
 		autoTunnelStateFlow.collect {
 			if (it.isPingEnabled()) {
@@ -191,6 +212,30 @@ class AutoTunnelService : LifecycleService() {
 		}
 	}

+	private suspend fun watchForMobileDataConnectivityChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting mobile data watcher")
+			mobileDataService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Mobile data connection")
+						emitMobileDataConnected(true)
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						emitMobileDataConnected(true)
+						Timber.i("Mobile data capabilities changed")
+					}
+
+					is NetworkStatus.Unavailable -> {
+						emitMobileDataConnected(false)
+						Timber.i("Lost mobile data connection")
+					}
+				}
+			}
+		}
+	}
+
 	private suspend fun watchForPingFailure() {
 		withContext(ioDispatcher) {
 			Timber.i("Starting ping watcher")
@@ -229,52 +274,136 @@ class AutoTunnelService : LifecycleService() {
 		}
 	}

-	private fun startAutoTunnelStateJob() = lifecycleScope.launch(ioDispatcher) {
-		combine(
-			combineSettings(),
-			combineNetworkEventsJob(),
-		) { double, networkState ->
-			AutoTunnelState(tunnelService.get().vpnState.value, networkState, double.first, double.second)
-		}.collect { state ->
-			autoTunnelStateFlow.update {
-				it.copy(state.vpnState, state.networkState, state.settings, state.tunnels)
+	private suspend fun watchForSettingsChanges() {
+		Timber.i("Starting settings watcher")
+		withContext(ioDispatcher) {
+			appDataRepository.settings.getSettingsFlow().combine(
+				appDataRepository.tunnels.getTunnelConfigsFlow(),
+			) { settings, tunnels ->
+				Pair(settings, tunnels)
+			}.collect { pair ->
+				autoTunnelStateFlow.update {
+					it.copy(
+						settings = pair.first,
+						tunnels = pair.second,
+					)
+				}
 			}
 		}
 	}

+	private suspend fun watchForVpnStateChanges() {
+		Timber.i("Starting vpn state watcher")
+		withContext(ioDispatcher) {
+			tunnelService.get().vpnState.collect { state ->
+				autoTunnelStateFlow.update {
+					it.copy(vpnState = state)
+				}
+			}
+		}
+	}
+
+	private fun startNetworkJobs() {
+		Timber.i("Starting all network state jobs..")
+		startWifiJob()
+		startEthernetJob()
+		startMobileDataJob()
+		startNetworkEventJob()
+	}
+
 	private fun cancelAndResetPingJob() {
 		pingJob?.cancelWithMessage("Ping job canceled")
 		pingJob = null
 	}

-	private fun combineNetworkEventsJob(): Flow<NetworkState> {
-		return combine(
-			wifiService.networkStatus,
-			mobileDataService.networkStatus,
-			ethernetService.networkStatus,
-		) { wifi, mobileData, ethernet ->
-			NetworkState(
-				wifi.isConnected,
-				mobileData.isConnected,
-				ethernet.isConnected,
-				when (wifi) {
-					is NetworkStatus.CapabilitiesChanged -> getWifiSSID(wifi.networkCapabilities)
-					is NetworkStatus.Available -> autoTunnelStateFlow.value.networkState.wifiName
-					is NetworkStatus.Unavailable -> null
-				},
+	private fun emitEthernetConnected(connected: Boolean) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				isEthernetConnected = connected,
 			)
-		}.distinctUntilChanged().filterNot { it.isWifiConnected && it.wifiName == null }
+		}
 	}

-	private fun combineSettings(): Flow<Pair<Settings, TunnelConfigs>> {
-		return combine(
-			appDataRepository.get().settings.getSettingsFlow(),
-			appDataRepository.get().tunnels.getTunnelConfigsFlow().distinctUntilChanged { old, new ->
-				old.map { it.isActive } != new.map { it.isActive }
-			},
-		) { settings, tunnels ->
-			Pair(settings, tunnels)
-		}.distinctUntilChanged()
+	private fun emitWifiConnected(connected: Boolean) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				isWifiConnected = connected,
+			)
+		}
+	}
+
+	private fun emitWifiSSID(ssid: String) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				currentNetworkSSID = ssid,
+			)
+		}
+	}
+
+	private fun emitMobileDataConnected(connected: Boolean) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				isMobileDataConnected = connected,
+			)
+		}
+	}
+
+	private suspend fun watchForEthernetConnectivityChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting ethernet data watcher")
+			ethernetService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Ethernet connection")
+						emitEthernetConnected(true)
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						Timber.i("Ethernet capabilities changed")
+						emitEthernetConnected(true)
+					}
+
+					is NetworkStatus.Unavailable -> {
+						emitEthernetConnected(false)
+						Timber.i("Lost Ethernet connection")
+					}
+				}
+			}
+		}
+	}
+
+	private suspend fun watchForWifiConnectivityChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting wifi watcher")
+			wifiService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Wi-Fi connection")
+						emitWifiConnected(true)
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						Timber.i("Wifi capabilities changed")
+						emitWifiConnected(true)
+						val ssid = getWifiSSID(status.networkCapabilities)
+						ssid?.let { name ->
+							if (name.contains(Constants.UNREADABLE_SSID)) {
+								Timber.w("SSID unreadable: missing permissions")
+							} else {
+								Timber.i("Detected valid SSID")
+							}
+							appDataRepository.appState.setCurrentSsid(name)
+							emitWifiSSID(name)
+						} ?: Timber.w("Failed to read ssid")
+					}
+
+					is NetworkStatus.Unavailable -> {
+						emitWifiConnected(false)
+						Timber.i("Lost Wi-Fi connection")
+					}
+				}
+			}
+		}
 	}

 	private suspend fun getWifiSSID(networkCapabilities: NetworkCapabilities): String? {
@@ -282,27 +411,25 @@ class AutoTunnelService : LifecycleService() {
 			with(autoTunnelStateFlow.value.settings) {
 				if (isWifiNameByShellEnabled) return@withContext rootShell.get().getCurrentWifiName()
 				wifiService.getNetworkName(networkCapabilities)
-			}.also {
-				if (it?.contains(Constants.UNREADABLE_SSID) == true) {
-					Timber.w("SSID unreadable: missing permissions")
-				} else {
-					Timber.i("Detected valid SSID")
-				}
 			}
 		}
 	}

-	private fun startAutoTunnelJob() = lifecycleScope.launch(ioDispatcher) {
-		Timber.i("Starting auto-tunnel network event watcher")
-		autoTunnelStateFlow.collect { watcherState ->
-			Timber.d("New auto tunnel state emitted")
-			when (val event = watcherState.asAutoTunnelEvent()) {
-				is AutoTunnelEvent.Start -> tunnelService.get().startTunnel(
-					event.tunnelConfig
-						?: appDataRepository.get().getPrimaryOrFirstTunnel(),
-				)
-				is AutoTunnelEvent.Stop -> tunnelService.get().stopTunnel()
-				AutoTunnelEvent.DoNothing -> Timber.i("Auto-tunneling: no condition met")
+	private suspend fun handleNetworkEventChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting auto-tunnel network event watcher")
+			// ignore vpnState emits to allow manual overrides
+			autoTunnelStateFlow.distinctUntilChanged { old, new ->
+				old.copy(vpnState = new.vpnState) == new || old.tunnels.map { it.isActive } != new.tunnels.map { it.isActive }
+			}.collect { watcherState ->
+				when (val event = watcherState.asAutoTunnelEvent()) {
+					is AutoTunnelEvent.Start -> tunnelService.get().startTunnel(
+						event.tunnelConfig
+							?: appDataRepository.getPrimaryOrFirstTunnel(),
+					)
+					is AutoTunnelEvent.Stop -> tunnelService.get().stopTunnel()
+					AutoTunnelEvent.DoNothing -> Timber.i("Auto-tunneling: no condition met")
+				}
 			}
 		}
 	}
@@ -1,21 +1,23 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel.model
+package com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel

 import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnState
 import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 import com.zaneschepke.wireguardautotunnel.util.extensions.isMatchingToWildcardList
-import timber.log.Timber

 data class AutoTunnelState(
 	val vpnState: VpnState = VpnState(),
-	val networkState: NetworkState = NetworkState(),
+	val isWifiConnected: Boolean = false,
+	val isEthernetConnected: Boolean = false,
+	val isMobileDataConnected: Boolean = false,
+	val currentNetworkSSID: String = "",
 	val settings: Settings = Settings(),
 	val tunnels: TunnelConfigs = emptyList(),
 ) {

 	private fun isMobileDataActive(): Boolean {
-		return !networkState.isEthernetConnected && !networkState.isWifiConnected && networkState.isMobileDataConnected
+		return !isEthernetConnected && !isWifiConnected && isMobileDataConnected
 	}

 	private fun isMobileTunnelDataChangeNeeded(): Boolean {
@@ -42,19 +44,19 @@ data class AutoTunnelState(
 	}

 	private fun isWifiActive(): Boolean {
-		return !networkState.isEthernetConnected && networkState.isWifiConnected
+		return !isEthernetConnected && isWifiConnected
 	}

 	private fun startOnEthernet(): Boolean {
-		return networkState.isEthernetConnected && settings.isTunnelOnEthernetEnabled && vpnState.status.isDown()
+		return isEthernetConnected && settings.isTunnelOnEthernetEnabled && vpnState.status.isDown()
 	}

 	private fun stopOnEthernet(): Boolean {
-		return networkState.isEthernetConnected && !settings.isTunnelOnEthernetEnabled && vpnState.status.isUp()
+		return isEthernetConnected && !settings.isTunnelOnEthernetEnabled && vpnState.status.isUp()
 	}

 	fun isNoConnectivity(): Boolean {
-		return !networkState.isEthernetConnected && !networkState.isWifiConnected && !networkState.isMobileDataConnected
+		return !isEthernetConnected && !isWifiConnected && !isMobileDataConnected
 	}

 	private fun stopOnMobileData(): Boolean {
@@ -70,7 +72,7 @@ data class AutoTunnelState(
 	}

 	private fun changeOnEthernet(): Boolean {
-		return networkState.isEthernetConnected && settings.isTunnelOnEthernetEnabled && isEthernetTunnelChangeNeeded()
+		return isEthernetConnected && settings.isTunnelOnEthernetEnabled && isEthernetTunnelChangeNeeded()
 	}

 	private fun stopOnWifi(): Boolean {
@@ -82,7 +84,6 @@ data class AutoTunnelState(
 	}

 	private fun startOnUntrustedWifi(): Boolean {
-		Timber.d("Is tunnel on wifi enabled ${settings.isTunnelOnWifiEnabled}")
 		return isWifiActive() && settings.isTunnelOnWifiEnabled && vpnState.status.isDown() && !isCurrentSSIDTrusted()
 	}

@@ -119,23 +120,19 @@ data class AutoTunnelState(
 	}

 	private fun isCurrentSSIDTrusted(): Boolean {
-		return networkState.wifiName?.let {
-			hasTrustedWifiName(it)
-		} == true
-	}
-
-	private fun hasTrustedWifiName(wifiName: String, wifiNames: List<String> = settings.trustedNetworkSSIDs): Boolean {
 		return if (settings.isWildcardsEnabled) {
-			wifiNames.isMatchingToWildcardList(wifiName)
+			settings.trustedNetworkSSIDs.isMatchingToWildcardList(currentNetworkSSID)
 		} else {
-			wifiNames.contains(wifiName)
+			settings.trustedNetworkSSIDs.contains(currentNetworkSSID)
 		}
 	}

 	private fun getTunnelWithMatchingTunnelNetwork(): TunnelConfig? {
-		return networkState.wifiName?.let { wifiName ->
-			tunnels.firstOrNull {
-				hasTrustedWifiName(wifiName, it.tunnelNetworks)
+		return tunnels.firstOrNull {
+			if (settings.isWildcardsEnabled) {
+				it.tunnelNetworks.isMatchingToWildcardList(currentNetworkSSID)
+			} else {
+				it.tunnelNetworks.contains(currentNetworkSSID)
 			}
 		}
 	}
@@ -1,8 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground.autotunnel.model
-
-data class NetworkState(
-	val isWifiConnected: Boolean = false,
-	val isMobileDataConnected: Boolean = false,
-	val isEthernetConnected: Boolean = false,
-	val wifiName: String? = null,
-)
@@ -10,10 +10,7 @@ import android.os.Build
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.conflate
 import kotlinx.coroutines.flow.map
-import timber.log.Timber

 abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 	val context: Context,
@@ -25,17 +22,8 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 	val wifiManager =
 		context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager

-	fun checkHasCapability(networkCapability: Int): Boolean {
-		val network = connectivityManager.activeNetwork
-		val networkCapabilities = connectivityManager.getNetworkCapabilities(network)
-		return networkCapabilities?.hasTransport(networkCapability) == true
-	}
-
 	override val networkStatus =
 		callbackFlow {
-			if (!checkHasCapability(networkCapability)) {
-				trySend(NetworkStatus.Unavailable())
-			}
 			val networkStatusCallback =
 				when (Build.VERSION.SDK_INT) {
 					in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
@@ -48,7 +36,7 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 							}

 							override fun onLost(network: Network) {
-								trySend(NetworkStatus.Unavailable())
+								trySend(NetworkStatus.Unavailable(network))
 							}

 							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
@@ -69,7 +57,7 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 							}

 							override fun onLost(network: Network) {
-								trySend(NetworkStatus.Unavailable())
+								trySend(NetworkStatus.Unavailable(network))
 							}

 							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
@@ -92,20 +80,17 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 			connectivityManager.registerNetworkCallback(request, networkStatusCallback)

 			awaitClose { connectivityManager.unregisterNetworkCallback(networkStatusCallback) }
-		}.catch {
-			Timber.e(it)
-			// conflate for backpressure
-		}.conflate()
+		}
 }

 inline fun <Result> Flow<NetworkStatus>.map(
-	crossinline onUnavailable: suspend () -> Result,
+	crossinline onUnavailable: suspend (network: Network) -> Result,
 	crossinline onAvailable: suspend (network: Network) -> Result,
 	crossinline onCapabilitiesChanged:
 	suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result,
 ): Flow<Result> = map { status ->
 	when (status) {
-		is NetworkStatus.Unavailable -> onUnavailable()
+		is NetworkStatus.Unavailable -> onUnavailable(status.network)
 		is NetworkStatus.Available -> onAvailable(status.network)
 		is NetworkStatus.CapabilitiesChanged ->
 			onCapabilitiesChanged(
@@ -4,11 +4,10 @@ import android.net.Network
 import android.net.NetworkCapabilities

 sealed class NetworkStatus {
-	abstract val isConnected: Boolean
-	class Available(val network: Network, override val isConnected: Boolean = true) : NetworkStatus()
+	class Available(val network: Network) : NetworkStatus()

-	class Unavailable(override val isConnected: Boolean = false) : NetworkStatus()
+	class Unavailable(val network: Network) : NetworkStatus()

-	class CapabilitiesChanged(val network: Network, val networkCapabilities: NetworkCapabilities, override val isConnected: Boolean = true) :
+	class CapabilitiesChanged(val network: Network, val networkCapabilities: NetworkCapabilities) :
 		NetworkStatus()
 }
@@ -1,17 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.notification
-
-import android.content.Context
-import com.zaneschepke.wireguardautotunnel.R
-
-enum class NotificationAction {
-	TUNNEL_OFF,
-	AUTO_TUNNEL_OFF,
-	;
-
-	fun title(context: Context): String {
-		return when (this) {
-			TUNNEL_OFF -> context.getString(R.string.stop)
-			AUTO_TUNNEL_OFF -> context.getString(R.string.stop)
-		}
-	}
-}
@@ -2,32 +2,21 @@ package com.zaneschepke.wireguardautotunnel.service.notification

 import android.app.Notification
 import android.app.NotificationManager
-import android.content.Context
-import androidx.core.app.NotificationCompat
-import com.zaneschepke.wireguardautotunnel.service.notification.WireGuardNotification.NotificationChannels
+import android.app.PendingIntent

 interface NotificationService {
-	val context: Context
 	fun createNotification(
-		channel: NotificationChannels,
+		channelId: String,
+		channelName: String,
 		title: String = "",
-		actions: Collection<NotificationCompat.Action> = emptyList(),
-		description: String = "",
+		action: PendingIntent? = null,
+		actionText: String? = null,
+		description: String,
 		showTimestamp: Boolean = false,
 		importance: Int = NotificationManager.IMPORTANCE_HIGH,
+		vibration: Boolean = false,
 		onGoing: Boolean = true,
+		lights: Boolean = true,
 		onlyAlertOnce: Boolean = true,
 	): Notification
-
-	fun createNotificationAction(action: NotificationAction): NotificationCompat.Action
-
-	fun remove(notificationId: Int)
-
-	fun show(notificationId: Int, notification: Notification)
-
-	companion object {
-		const val KERNEL_SERVICE_NOTIFICATION_ID = 123
-		const val AUTO_TUNNEL_NOTIFICATION_ID = 122
-		const val VPN_NOTIFICATION_ID = 100
-	}
 }
@@ -1,134 +1,105 @@
 package com.zaneschepke.wireguardautotunnel.service.notification

-import android.Manifest
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
-import android.content.pm.PackageManager
 import android.graphics.Color
-import androidx.core.app.ActivityCompat
 import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
+import com.zaneschepke.wireguardautotunnel.ui.MainActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject

 class WireGuardNotification
@Inject
 constructor(
-	@ApplicationContext override val context: Context,
-) : NotificationService {
+	@ApplicationContext private val context: Context,
+) :
+	NotificationService {
+	private val notificationManager =
+		context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

-	enum class NotificationChannels {
-		VPN,
-		AUTO_TUNNEL,
-	}
-
-	private val notificationManager = NotificationManagerCompat.from(context)
+	private val watcherBuilder: NotificationCompat.Builder =
+		NotificationCompat.Builder(
+			context,
+			context.getString(R.string.watcher_channel_id),
+		)
+	private val tunnelBuilder: NotificationCompat.Builder =
+		NotificationCompat.Builder(
+			context,
+			context.getString(R.string.vpn_channel_id),
+		)

 	override fun createNotification(
-		channel: NotificationChannels,
+		channelId: String,
+		channelName: String,
 		title: String,
-		actions: Collection<NotificationCompat.Action>,
+		action: PendingIntent?,
+		actionText: String?,
 		description: String,
 		showTimestamp: Boolean,
 		importance: Int,
+		vibration: Boolean,
 		onGoing: Boolean,
+		lights: Boolean,
 		onlyAlertOnce: Boolean,
 	): Notification {
-		notificationManager.createNotificationChannel(channel.asChannel())
-		return channel.asBuilder().apply {
-			actions.forEach {
-				addAction(it)
-			}
-			setContentTitle(title)
-			setContentText(description)
-			setOnlyAlertOnce(onlyAlertOnce)
-			setOngoing(onGoing)
-			setPriority(NotificationCompat.PRIORITY_HIGH)
-			setShowWhen(showTimestamp)
-			setSmallIcon(R.drawable.ic_launcher)
-		}.build()
-	}
-
-	override fun createNotificationAction(notificationAction: NotificationAction): NotificationCompat.Action {
-		val pendingIntent = PendingIntent.getBroadcast(
-			context,
-			0,
-			Intent(context, NotificationActionReceiver::class.java).apply {
-				action = notificationAction.name
-			},
-			PendingIntent.FLAG_IMMUTABLE,
-		)
-		return NotificationCompat.Action.Builder(
-			R.drawable.ic_launcher,
-			notificationAction.title(context).uppercase(),
-			pendingIntent,
-		).build()
-	}
-
-	override fun remove(notificationId: Int) {
-		notificationManager.cancel(notificationId)
-	}
-
-	override fun show(notificationId: Int, notification: Notification) {
-		with(notificationManager) {
-			if (ActivityCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
-				return
-			}
-			notify(notificationId, notification)
-		}
-	}
-
-	fun NotificationChannels.asBuilder(): NotificationCompat.Builder {
-		return when (this) {
-			NotificationChannels.AUTO_TUNNEL -> {
-				NotificationCompat.Builder(
+		val channel =
+			NotificationChannel(
+				channelId,
+				channelName,
+				importance,
+			)
+				.let {
+					it.description = title
+					it.enableLights(lights)
+					it.lightColor = Color.RED
+					it.enableVibration(vibration)
+					it.vibrationPattern = longArrayOf(100, 200, 300)
+					it
+				}
+		notificationManager.createNotificationChannel(channel)
+		val pendingIntent: PendingIntent =
+			Intent(context, MainActivity::class.java).let { notificationIntent ->
+				PendingIntent.getActivity(
 					context,
-					context.getString(R.string.auto_tunnel_channel_id),
+					0,
+					notificationIntent,
+					PendingIntent.FLAG_IMMUTABLE,
 				)
 			}
-			NotificationChannels.VPN -> {
-				NotificationCompat.Builder(
-					context,
-					context.getString(R.string.vpn_channel_id),
-				)
-			}
-		}
-	}

-	fun NotificationChannels.asChannel(): NotificationChannel {
-		return when (this) {
-			NotificationChannels.VPN -> {
-				NotificationChannel(
-					context.getString(R.string.vpn_channel_id),
-					context.getString(R.string.vpn_channel_name),
-					NotificationManager.IMPORTANCE_HIGH,
-				).apply {
-					description = context.getString(R.string.vpn_channel_description)
-					enableLights(true)
-					lightColor = Color.WHITE
-					enableVibration(false)
-					vibrationPattern = longArrayOf(100, 200, 300)
+		val builder =
+			when (channelId) {
+				context.getString(R.string.watcher_channel_id) -> watcherBuilder
+				context.getString(R.string.vpn_channel_id) -> tunnelBuilder
+				else -> {
+					NotificationCompat.Builder(
+						context,
+						channelId,
+					)
 				}
 			}
-			NotificationChannels.AUTO_TUNNEL -> {
-				NotificationChannel(
-					context.getString(R.string.auto_tunnel_channel_id),
-					context.getString(R.string.auto_tunnel_channel_name),
-					NotificationManager.IMPORTANCE_HIGH,
-				).apply {
-					description = context.getString(R.string.auto_tunnel_channel_description)
-					enableLights(true)
-					lightColor = Color.WHITE
-					enableVibration(false)
-					vibrationPattern = longArrayOf(100, 200, 300)
-				}
+
+		return builder.let {
+			if (action != null && actionText != null) {
+				it.addAction(
+					NotificationCompat.Action.Builder(0, actionText, action).build(),
+				)
+				it.setAutoCancel(true)
 			}
+			it.setContentTitle(title)
+				.setContentText(description)
+				.setOnlyAlertOnce(onlyAlertOnce)
+				.setContentIntent(pendingIntent)
+				.setOngoing(onGoing)
+				.setPriority(NotificationCompat.PRIORITY_HIGH)
+				.setShowWhen(showTimestamp)
+				.setSmallIcon(R.drawable.ic_launcher)
+				.build()
 		}
 	}
 }
@@ -1,18 +1,24 @@
 package com.zaneschepke.wireguardautotunnel.service.tile

+import android.content.Intent
+import android.os.IBinder
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import javax.inject.Inject

@AndroidEntryPoint
-class AutoTunnelControlTile : TileService() {
+class AutoTunnelControlTile : TileService(), LifecycleOwner {
 	@Inject
 	lateinit var appDataRepository: AppDataRepository

@@ -23,26 +29,32 @@ class AutoTunnelControlTile : TileService() {
 	@ApplicationScope
 	lateinit var applicationScope: CoroutineScope

+	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
+
 	override fun onCreate() {
 		super.onCreate()
-		serviceManager.autoTunnelTile.complete(this)
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+	}
+
+	override fun onStopListening() {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
 	}

 	override fun onDestroy() {
 		super.onDestroy()
-		serviceManager.autoTunnelTile = CompletableDeferred()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
 	}

 	override fun onStartListening() {
 		super.onStartListening()
-		serviceManager.autoTunnelTile.complete(this)
-		applicationScope.launch {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
+		lifecycleScope.launch {
 			if (appDataRepository.tunnels.getAll().isEmpty()) return@launch setUnavailable()
 			updateTileState()
 		}
 	}

-	fun updateTileState() {
+	private fun updateTileState() {
 		serviceManager.autoTunnelActive.value.let {
 			if (it) setActive() else setInactive()
 		}
@@ -51,7 +63,7 @@ class AutoTunnelControlTile : TileService() {
 	override fun onClick() {
 		super.onClick()
 		unlockAndRun {
-			applicationScope.launch {
+			lifecycleScope.launch {
 				if (serviceManager.autoTunnelActive.value) {
 					serviceManager.stopAutoTunnel()
 					setInactive()
@@ -83,4 +95,18 @@ class AutoTunnelControlTile : TileService() {
 			qsTile.updateTile()
 		}
 	}
+
+	/* This works around an annoying unsolved frameworks bug some people are hitting. */
+	override fun onBind(intent: Intent): IBinder? {
+		var ret: IBinder? = null
+		try {
+			ret = super.onBind(intent)
+		} catch (_: Throwable) {
+			Timber.e("Failed to bind to TunnelControlTile")
+		}
+		return ret
+	}
+
+	override val lifecycle: Lifecycle
+		get() = lifecycleRegistry
 }
@@ -1,22 +1,27 @@
 package com.zaneschepke.wireguardautotunnel.service.tile

+import android.content.Intent
 import android.os.Build
+import android.os.IBinder
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import javax.inject.Inject
 import javax.inject.Provider

@AndroidEntryPoint
-class TunnelControlTile : TileService() {
+class TunnelControlTile : TileService(), LifecycleOwner {
 	@Inject
 	lateinit var appDataRepository: AppDataRepository

@@ -27,29 +32,33 @@ class TunnelControlTile : TileService() {
 	@ApplicationScope
 	lateinit var applicationScope: CoroutineScope

-	@Inject
-	lateinit var serviceManager: ServiceManager
+	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)

 	override fun onCreate() {
 		super.onCreate()
-		serviceManager.tunnelControlTile.complete(this)
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+	}
+
+	override fun onStopListening() {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
 	}

 	override fun onDestroy() {
 		super.onDestroy()
-		serviceManager.tunnelControlTile = CompletableDeferred()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
 	}

 	override fun onStartListening() {
 		super.onStartListening()
-		serviceManager.tunnelControlTile.complete(this)
-		applicationScope.launch {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
+		Timber.d("Updating tile!")
+		lifecycleScope.launch {
 			if (appDataRepository.tunnels.getAll().isEmpty()) return@launch setUnavailable()
 			updateTileState()
 		}
 	}

-	fun updateTileState() = applicationScope.launch {
+	private suspend fun updateTileState() {
 		val lastActive = appDataRepository.getStartTunnelConfig()
 		lastActive?.let {
 			updateTile(it)
@@ -59,7 +68,7 @@ class TunnelControlTile : TileService() {
 	override fun onClick() {
 		super.onClick()
 		unlockAndRun {
-			applicationScope.launch {
+			lifecycleScope.launch {
 				val lastActive = appDataRepository.getStartTunnelConfig()
 				lastActive?.let { tunnel ->
 					if (tunnel.isActive) {
@@ -116,4 +125,18 @@ class TunnelControlTile : TileService() {
 			}
 		}
 	}
+
+	/* This works around an annoying unsolved frameworks bug some people are hitting. */
+	override fun onBind(intent: Intent): IBinder? {
+		var ret: IBinder? = null
+		try {
+			ret = super.onBind(intent)
+		} catch (_: Throwable) {
+			Timber.e("Failed to bind to TunnelControlTile")
+		}
+		return ret
+	}
+
+	override val lifecycle: Lifecycle
+		get() = lifecycleRegistry
 }
@@ -1,7 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.tunnel
-
-enum class BackendState {
-	KILL_SWITCH_ACTIVE,
-	SERVICE_ACTIVE,
-	INACTIVE,
-}
@@ -12,17 +12,13 @@ interface TunnelService : Tunnel, org.amnezia.awg.backend.Tunnel {

 	suspend fun bounceTunnel()

-	suspend fun getBackendState(): BackendState
-
-	suspend fun setBackendState(backendState: BackendState, allowedIps: Collection<String>)
-
 	val vpnState: StateFlow<VpnState>

 	suspend fun runningTunnelNames(): Set<String>

 	suspend fun getState(): TunnelState

-	fun cancelActiveTunnelJobs()
+	fun cancelStatsJob()

-	fun startActiveTunnelJobs()
+	fun startStatsJob()
 }
@@ -9,29 +9,24 @@ import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.module.Kernel
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.AmneziaStatistics
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.WireGuardStatistics
-import com.zaneschepke.wireguardautotunnel.util.extensions.asAmBackendState
-import com.zaneschepke.wireguardautotunnel.util.extensions.asBackendState
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import org.amnezia.awg.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationAction
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService.Companion.VPN_NOTIFICATION_ID
 import timber.log.Timber
 import javax.inject.Inject
 import javax.inject.Provider
@@ -40,38 +35,31 @@ class WireGuardTunnel
@Inject
 constructor(
 	private val amneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
-	private val tunnelConfigRepository: TunnelConfigRepository,
+	tunnelConfigRepository: TunnelConfigRepository,
 	@Kernel private val kernelBackend: Provider<Backend>,
 	private val appDataRepository: AppDataRepository,
 	@ApplicationScope private val applicationScope: CoroutineScope,
 	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 	private val serviceManager: ServiceManager,
-	private val notificationService: NotificationService,
 ) : TunnelService {

 	private val _vpnState = MutableStateFlow(VpnState())
-	override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()
+	override val vpnState: StateFlow<VpnState> = _vpnState.combine(
+		tunnelConfigRepository.getTunnelConfigsFlow(),
+	) {
+			vpnState, tunnels ->
+		vpnState.copy(
+			tunnelConfig = tunnels.firstOrNull { it.id == vpnState.tunnelConfig?.id },
+		)
+	}.stateIn(applicationScope, SharingStarted.Eagerly, VpnState())

 	private var statsJob: Job? = null
-	private var tunnelChangesJob: Job? = null

-	@get:Synchronized @set:Synchronized
-	private var isKernelBackend: Boolean? = null
-
-	private val tunnelControlMutex = Mutex()
-
-	init {
-		applicationScope.launch(ioDispatcher) {
-			appDataRepository.settings.getSettingsFlow().collect {
-				isKernelBackend = it.isKernelEnabled
-			}
-		}
-	}
+	private val mutex = Mutex()

 	private suspend fun backend(): Any {
-		val isKernelEnabled = isKernelBackend
-			?: appDataRepository.settings.getSettings().isKernelEnabled
-		if (isKernelEnabled) return kernelBackend.get()
+		val settings = appDataRepository.settings.getSettings()
+		if (settings.isKernelEnabled) return kernelBackend.get()
 		return amneziaBackend.get()
 	}

@@ -85,7 +73,6 @@ constructor(

 	private suspend fun setState(tunnelConfig: TunnelConfig, tunnelState: TunnelState): Result<TunnelState> {
 		return runCatching {
-			updateTunnelConfig(tunnelConfig) //need so kernel can get tunnel name or it breaks kernel
 			when (val backend = backend()) {
 				is Backend -> backend.setState(this, tunnelState.toWgState(), TunnelConfig.configFromWgQuick(tunnelConfig.wgQuick)).let { TunnelState.from(it) }
 				is org.amnezia.awg.backend.Backend -> {
@@ -103,7 +90,6 @@ constructor(
 				else -> throw NotImplementedError()
 			}
 		}.onFailure {
-			//TODO add better error message and comms to user
 			Timber.e(it)
 		}
 	}
@@ -117,25 +103,13 @@ constructor(
 	override suspend fun startTunnel(tunnelConfig: TunnelConfig?, background: Boolean) {
 		if (tunnelConfig == null) return
 		withContext(ioDispatcher) {
-			if (isTunnelAlreadyRunning(tunnelConfig)) return@withContext
-			withServiceActive {
+			mutex.withLock {
+				if (isTunnelAlreadyRunning(tunnelConfig)) return@withContext
 				onBeforeStart(background)
-				tunnelControlMutex.withLock {
-					setState(tunnelConfig, TunnelState.UP).onSuccess {
-						startActiveTunnelJobs()
-						if (it.isUp()) appDataRepository.tunnels.save(tunnelConfig.copy(isActive = true))
-						with(notificationService) {
-							val notification = createNotification(
-								WireGuardNotification.NotificationChannels.VPN,
-								title = "${context.getString(R.string.tunnel_running)} - ${tunnelConfig.name}",
-								actions = listOf(
-									notificationService.createNotificationAction(NotificationAction.TUNNEL_OFF),
-								),
-							)
-							show(VPN_NOTIFICATION_ID, notification)
-						}
-						updateTunnelState(it, tunnelConfig)
-					}
+				setState(tunnelConfig, TunnelState.UP).onSuccess {
+					startStatsJob()
+					if (it.isUp()) appDataRepository.tunnels.save(tunnelConfig.copy(isActive = true))
+					updateTunnelState(it, tunnelConfig)
 				}.onFailure {
 					Timber.e(it)
 				}
@@ -145,14 +119,13 @@ constructor(

 	override suspend fun stopTunnel() {
 		withContext(ioDispatcher) {
-			if (_vpnState.value.status.isDown()) return@withContext
-			with(_vpnState.value) {
-				if (tunnelConfig == null) return@withContext
-				tunnelControlMutex.withLock {
+			mutex.withLock {
+				if (_vpnState.value.status.isDown()) return@withContext
+				with(_vpnState.value) {
+					if (tunnelConfig == null) return@withContext
 					setState(tunnelConfig, TunnelState.DOWN).onSuccess {
 						updateTunnelState(it, null)
 						onStop(tunnelConfig)
-						notificationService.remove(VPN_NOTIFICATION_ID)
 						stopBackgroundService()
 					}.onFailure {
 						Timber.e(it)
@@ -162,60 +135,11 @@ constructor(
 		}
 	}

-	private suspend fun toggleTunnel(tunnelConfig: TunnelConfig) {
-		withContext(ioDispatcher) {
-			tunnelControlMutex.withLock {
-				setState(tunnelConfig, TunnelState.TOGGLE)
-			}
-		}
-	}
-
-	// utility to keep vpnService alive during rapid changes to prevent bad states
-	private suspend fun withServiceActive(callback: suspend () -> Unit) {
-		when (val backend = backend()) {
-			is org.amnezia.awg.backend.Backend -> {
-				val backendState = backend.backendState
-				if (backendState == org.amnezia.awg.backend.Backend.BackendState.INACTIVE) {
-					backend.setBackendState(org.amnezia.awg.backend.Backend.BackendState.SERVICE_ACTIVE, emptyList())
-				}
-				callback()
-			}
-			is Backend -> callback()
-		}
-	}
-
 	override suspend fun bounceTunnel() {
-		_vpnState.value.tunnelConfig?.let {
-			withServiceActive {
-				toggleTunnel(it)
-				toggleTunnel(it)
-			}
-		}
-	}
-
-	override suspend fun getBackendState(): BackendState {
-		return when (val backend = backend()) {
-			is org.amnezia.awg.backend.Backend -> {
-				backend.backendState.asBackendState()
-			}
-			is Backend -> BackendState.SERVICE_ACTIVE
-			else -> BackendState.INACTIVE
-		}
-	}
-
-	override suspend fun setBackendState(backendState: BackendState, allowedIps: Collection<String>) {
-		kotlin.runCatching {
-			when (val backend = backend()) {
-				is org.amnezia.awg.backend.Backend -> {
-					backend.setBackendState(backendState.asAmBackendState(), allowedIps)
-				}
-				is Backend -> {
-					// TODO not yet implemented
-					Timber.d("Kernel backend state not yet implemented")
-				}
-				else -> Unit
-			}
-		}
+		if (_vpnState.value.tunnelConfig == null) return
+		val config = _vpnState.value.tunnelConfig
+		stopTunnel()
+		startTunnel(config)
 	}

 	private suspend fun shutDownActiveTunnel() {
@@ -228,12 +152,12 @@ constructor(

 	private suspend fun startBackgroundService() {
 		serviceManager.startBackgroundService()
-		serviceManager.updateTunnelTile()
+		serviceManager.requestTunnelTileUpdate()
 	}

 	private fun stopBackgroundService() {
 		serviceManager.stopBackgroundService()
-		serviceManager.updateTunnelTile()
+		serviceManager.requestTunnelTileUpdate()
 	}

 	private suspend fun onBeforeStart(background: Boolean) {
@@ -245,7 +169,7 @@ constructor(

 	private suspend fun onStop(tunnelConfig: TunnelConfig) {
 		appDataRepository.tunnels.save(tunnelConfig.copy(isActive = false))
-		cancelActiveTunnelJobs()
+		cancelStatsJob()
 		resetBackendStatistics()
 	}

@@ -255,13 +179,7 @@ constructor(
 		}
 	}

-	private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) {
-		_vpnState.update {
-			it.copy(tunnelConfig = tunnelConfig)
-		}
-	}
-
-	private fun updateBackendStatistics(statistics: TunnelStatistics) {
+	private fun emitBackendStatistics(statistics: TunnelStatistics) {
 		_vpnState.update {
 			it.copy(statistics = statistics)
 		}
@@ -281,14 +199,12 @@ constructor(
 		}
 	}

-	override fun cancelActiveTunnelJobs() {
+	override fun cancelStatsJob() {
 		statsJob?.cancel()
-		tunnelChangesJob?.cancel()
 	}

-	override fun startActiveTunnelJobs() {
+	override fun startStatsJob() {
 		statsJob = startTunnelStatisticsJob()
-		tunnelChangesJob = startTunnelConfigChangesJob()
 	}

 	override fun getName(): String {
@@ -300,11 +216,11 @@ constructor(
 		delay(STATS_START_DELAY)
 		while (true) {
 			when (backend) {
-				is Backend -> updateBackendStatistics(
+				is Backend -> emitBackendStatistics(
 					WireGuardStatistics(backend.getStatistics(this@WireGuardTunnel)),
 				)
 				is org.amnezia.awg.backend.Backend -> {
-					updateBackendStatistics(
+					emitBackendStatistics(
 						AmneziaStatistics(
 							backend.getStatistics(this@WireGuardTunnel),
 						),
@@ -315,34 +231,18 @@ constructor(
 		}
 	}

-	private fun startTunnelConfigChangesJob() = applicationScope.launch(ioDispatcher) {
-		tunnelConfigRepository.getTunnelConfigsFlow().collect {
-			with(_vpnState.value) {
-				if (status.isDown() || tunnelConfig == null) return@collect
-				val vpnConfigFromStorage = it.first { it.id == tunnelConfig.id }
-				val isRestartNeeded = vpnConfigFromStorage.wgQuick != tunnelConfig.wgQuick ||
-					vpnConfigFromStorage.amQuick != tunnelConfig.amQuick
-				updateTunnelConfig(vpnConfigFromStorage)
-				if (isRestartNeeded) {
-					Timber.d("Bouncing tunnel on config change")
-					bounceTunnel()
-				}
-			}
-		}
-	}
-
 	override fun onStateChange(newState: Tunnel.State) {
 		_vpnState.update {
 			it.copy(status = TunnelState.from(newState))
 		}
-		serviceManager.updateTunnelTile()
+		serviceManager.requestTunnelTileUpdate()
 	}

 	override fun onStateChange(state: State) {
 		_vpnState.update {
 			it.copy(status = TunnelState.from(state))
 		}
-		serviceManager.updateTunnelTile()
+		serviceManager.requestTunnelTileUpdate()
 	}

 	companion object {
@@ -1,5 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.ui

+import androidx.appcompat.app.AppCompatDelegate
+import androidx.core.os.LocaleListCompat
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wireguard.android.backend.WgQuickBackend
@@ -7,17 +9,16 @@ import com.wireguard.android.util.RootShell
 import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.AppShell
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.tunnel.BackendState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.SnackbarController
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
+import com.zaneschepke.wireguardautotunnel.util.LocaleUtil.OPTION_PHONE_LANGUAGE
 import com.zaneschepke.wireguardautotunnel.util.StringValue
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.CoroutineDispatcher
@@ -33,7 +34,6 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.plus
 import kotlinx.coroutines.withContext
-import timber.log.Timber
 import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
 import javax.inject.Provider
@@ -80,7 +80,7 @@ constructor(
 	init {
 		viewModelScope.launch {
 			initPin()
-			initServices()
+			initAutoTunnel()
 			initTunnel()
 			appReadyCheck()
 		}
@@ -94,7 +94,7 @@ constructor(
 	}

 	private suspend fun initTunnel() {
-		if (tunnelService.get().getState() == TunnelState.UP) tunnelService.get().startActiveTunnelJobs()
+		if (tunnelService.get().getState() == TunnelState.UP) tunnelService.get().startStatsJob()
 		val activeTunnels = appDataRepository.tunnels.getActive()
 		if (activeTunnels.isNotEmpty() &&
 			tunnelService.get().getState() == TunnelState.DOWN
@@ -108,12 +108,9 @@ constructor(
 		if (isPinEnabled) PinManager.initialize(WireGuardAutoTunnel.instance)
 	}

-	private suspend fun initServices() {
-		withContext(ioDispatcher) {
-			val settings = appDataRepository.settings.getSettings()
-			handleVpnKillSwitchChange(settings.isVpnKillSwitchEnabled)
-			if (settings.isAutoTunnelEnabled) serviceManager.startAutoTunnel(false)
-		}
+	private suspend fun initAutoTunnel() {
+		val settings = appDataRepository.settings.getSettings()
+		if (settings.isAutoTunnelEnabled) serviceManager.startAutoTunnel(false)
 	}

 	fun onPinLockDisabled() = viewModelScope.launch(ioDispatcher) {
@@ -141,6 +138,7 @@ constructor(
 	}

 	private suspend fun onLoggerStop() {
+		logReader.stop()
 		logReader.deleteAndClearLogs()
 	}

@@ -155,11 +153,11 @@ constructor(
 	}

 	fun onLocaleChange(localeTag: String) = viewModelScope.launch {
-		appDataRepository.appState.setLocale(localeTag)
-		LocaleUtil.changeLocale(localeTag)
-		_configurationChange.update {
-			true
-		}
+		val locale = LocaleUtil.getLocaleFromPrefCode(localeTag)
+		val storageLocale = if (localeTag == OPTION_PHONE_LANGUAGE) OPTION_PHONE_LANGUAGE else locale
+		appDataRepository.appState.setLocale(storageLocale)
+		val appLocale: LocaleListCompat = LocaleListCompat.forLanguageTags(locale)
+		AppCompatDelegate.setApplicationLocales(appLocale)
 	}

 	fun onToggleRestartAtBoot() = viewModelScope.launch {
@@ -172,50 +170,10 @@ constructor(
 		}
 	}

-	fun onToggleVpnKillSwitch(enabled: Boolean) = viewModelScope.launch {
-		with(uiState.value.settings) {
-			appDataRepository.settings.save(
-				copy(
-					isVpnKillSwitchEnabled = enabled,
-					isLanOnKillSwitchEnabled = if (enabled) isLanOnKillSwitchEnabled else false,
-				),
-			)
-		}
-		handleVpnKillSwitchChange(enabled)
-	}
-
-	private suspend fun handleVpnKillSwitchChange(enabled: Boolean) {
-		withContext(ioDispatcher) {
-			if (enabled) {
-				Timber.d("Starting kill switch")
-				val allowedIps = if (appDataRepository.settings.getSettings().isLanOnKillSwitchEnabled) {
-					TunnelConfig.IPV4_PUBLIC_NETWORKS
-				} else {
-					emptySet()
-				}
-				tunnelService.get().setBackendState(BackendState.KILL_SWITCH_ACTIVE, allowedIps)
-			} else {
-				Timber.d("Sending shutdown of kill switch")
-				tunnelService.get().setBackendState(BackendState.SERVICE_ACTIVE, emptySet())
-			}
-		}
-	}
-
-	fun onToggleLanOnKillSwitch(enabled: Boolean) = viewModelScope.launch(ioDispatcher) {
-		appDataRepository.settings.save(
-			uiState.value.settings.copy(
-				isLanOnKillSwitchEnabled = enabled,
-			),
-		)
-		val allowedIps = if (enabled) TunnelConfig.IPV4_PUBLIC_NETWORKS else emptySet()
-		Timber.d("Setting allowedIps $allowedIps")
-		tunnelService.get().setBackendState(BackendState.KILL_SWITCH_ACTIVE, allowedIps)
-	}
-
 	fun onToggleShortcutsEnabled() = viewModelScope.launch {
 		with(uiState.value.settings) {
 			appDataRepository.settings.save(
-				copy(
+				this.copy(
 					isShortcutsEnabled = !isShortcutsEnabled,
 				),
 			)
@@ -237,7 +195,6 @@ constructor(
 			if (!isKernelEnabled) {
 				requestRoot().onSuccess {
 					if (!isKernelSupported()) return@onSuccess SnackbarController.showMessage(StringValue.StringResource(R.string.kernel_not_supported))
-					tunnelService.get().setBackendState(BackendState.INACTIVE, emptyList())
 					appDataRepository.settings.save(
 						copy(
 							isKernelEnabled = true,
@@ -52,7 +52,6 @@ import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.displa
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.language.LanguageScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.autotunnel.AutoTunnelScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.disclosure.LocationDisclosureScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.killswitch.KillSwitchScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.logs.LogsScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
@@ -145,8 +144,8 @@ class MainActivity : AppCompatActivity() {
 									),
 								)
 							},
-						) { padding ->
-							Box(modifier = Modifier.fillMaxSize().padding(padding)) {
+						) {
+							Box(modifier = Modifier.fillMaxSize().padding(it)) {
 								NavHost(
 									navController,
 									enterTransition = { fadeIn(tween(Constants.TRANSITION_ANIMATION_TIME)) },
@@ -208,9 +207,6 @@ class MainActivity : AppCompatActivity() {
 									composable<Route.Scanner> {
 										ScannerScreen()
 									}
-									composable<Route.KillSwitch> {
-										KillSwitchScreen(appUiState, viewModel)
-									}
 								}
 							}
 						}
@@ -222,6 +218,6 @@ class MainActivity : AppCompatActivity() {
 	override fun onDestroy() {
 		super.onDestroy()
 		// save battery by not polling stats while app is closed
-		tunnelService.cancelActiveTunnelJobs()
+		tunnelService.cancelStatsJob()
 	}
 }
@@ -21,9 +21,6 @@ sealed class Route {
 	@Serializable
 	data object Display : Route()

-	@Serializable
-	data object KillSwitch : Route()
-
 	@Serializable
 	data object Language : Route()

@@ -1,38 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common.permission.vpn
-
-import android.net.VpnService
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.appcompat.app.AppCompatActivity.RESULT_OK
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.platform.LocalContext
-
-@Composable
-inline fun <T> withVpnPermission(crossinline onSuccess: (t: T) -> Unit): (t: T) -> Unit {
-	val context = LocalContext.current
-
-	var showVpnPermissionDialog by remember { mutableStateOf(false) }
-
-	val vpnActivity =
-		rememberLauncherForActivityResult(
-			ActivityResultContracts.StartActivityForResult(),
-			onResult = {
-				if (it.resultCode != RESULT_OK) showVpnPermissionDialog = true
-			},
-		)
-
-	VpnDeniedDialog(showVpnPermissionDialog, onDismiss = { showVpnPermissionDialog = false })
-
-	return {
-		val intent = VpnService.prepare(context)
-		if (intent != null) {
-			vpnActivity.launch(intent)
-		} else {
-			onSuccess(it)
-		}
-	}
-}
@@ -1,35 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common.permission
-
-import android.content.Intent
-import android.net.Uri
-import android.provider.Settings
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.ActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.platform.LocalContext
-import com.zaneschepke.wireguardautotunnel.util.extensions.isBatteryOptimizationsDisabled
-
-@Composable
-inline fun withIgnoreBatteryOpt(ignore: Boolean, crossinline callback: () -> Unit): () -> Unit {
-	val context = LocalContext.current
-	val batteryActivity =
-		rememberLauncherForActivityResult(
-			ActivityResultContracts.StartActivityForResult(),
-		) { result: ActivityResult ->
-			// we only ask once
-			callback()
-		}
-	return {
-		if (ignore || context.isBatteryOptimizationsDisabled()) {
-			callback()
-		} else {
-			batteryActivity.launch(
-				Intent().apply {
-					action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
-					data = Uri.parse("package:${context.packageName}")
-				},
-			)
-		}
-	}
-}
@@ -1,7 +1,13 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.main

+import android.content.Intent
+import android.net.Uri
+import android.net.VpnService
+import android.provider.Settings
 import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.ActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.appcompat.app.AppCompatActivity.RESULT_OK
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.gestures.ScrollableDefaults
 import androidx.compose.foundation.gestures.detectTapGestures
@@ -35,7 +41,6 @@ import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import androidx.core.os.ConfigurationCompat
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
@@ -46,19 +51,18 @@ import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
 import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberFileImportLauncherForResult
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.TopNavBar
-import com.zaneschepke.wireguardautotunnel.ui.common.permission.vpn.withVpnPermission
-import com.zaneschepke.wireguardautotunnel.ui.common.permission.withIgnoreBatteryOpt
 import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.SnackbarController
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.AutoTunnelRowItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.GettingStartedLabel
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.ScrollDismissFab
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.TunnelImportSheet
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.TunnelRowItem
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.VpnDeniedDialog
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.extensions.isBatteryOptimizationsDisabled
 import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
 import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
-import java.text.Collator

@OptIn(ExperimentalFoundationApi::class)
@Composable
@@ -69,35 +73,30 @@ fun MainScreen(viewModel: MainViewModel = hiltViewModel(), uiState: AppUiState)
 	val snackbar = SnackbarController.current

 	var showBottomSheet by remember { mutableStateOf(false) }
+	var showVpnPermissionDialog by remember { mutableStateOf(false) }
 	var isFabVisible by rememberSaveable { mutableStateOf(true) }
 	var showDeleteTunnelAlertDialog by remember { mutableStateOf(false) }
 	var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
 	val isRunningOnTv = remember { context.isRunningOnTv() }

-	val currentLocale = ConfigurationCompat.getLocales(context.resources.configuration)[0]
-	val collator = Collator.getInstance(currentLocale)
-
-	val sortedTunnels = remember(uiState.tunnels) {
-		uiState.tunnels.sortedWith(compareBy(collator) { it.name })
-	}
-
-	val startAutoTunnel = withVpnPermission<Unit> { viewModel.onToggleAutoTunnel() }
-	val startTunnel = withVpnPermission<TunnelConfig> {
-		viewModel.onTunnelStart(it, uiState.settings.isKernelEnabled)
-	}
-	val autoTunnelToggleBattery = withIgnoreBatteryOpt(uiState.generalState.isBatteryOptimizationDisableShown) {
-		if (!uiState.generalState.isBatteryOptimizationDisableShown) viewModel.setBatteryOptimizeDisableShown()
-		if (uiState.settings.isKernelEnabled) {
-			viewModel.onToggleAutoTunnel()
-		} else {
-			startAutoTunnel.invoke(Unit)
-		}
-	}
-
 	val nestedScrollConnection = remember {
 		NestedScrollListener({ isFabVisible = false }, { isFabVisible = true })
 	}

+	val vpnActivity =
+		rememberLauncherForActivityResult(
+			ActivityResultContracts.StartActivityForResult(),
+			onResult = {
+				if (it.resultCode != RESULT_OK) showVpnPermissionDialog = true
+			},
+		)
+	val batteryActivity =
+		rememberLauncherForActivityResult(
+			ActivityResultContracts.StartActivityForResult(),
+		) { result: ActivityResult ->
+			viewModel.setBatteryOptimizeDisableShown()
+		}
+
 	val tunnelFileImportResultLauncher = rememberFileImportLauncherForResult(onNoFileExplorer = {
 		snackbar.showMessage(
 			context.getString(R.string.error_no_file_explorer),
@@ -113,6 +112,8 @@ fun MainScreen(viewModel: MainViewModel = hiltViewModel(), uiState: AppUiState)
 		navController.navigate(Route.Scanner)
 	}

+	VpnDeniedDialog(showVpnPermissionDialog, onDismiss = { showVpnPermissionDialog = false })
+
 	if (showDeleteTunnelAlertDialog) {
 		InfoDialog(
 			onDismiss = { showDeleteTunnelAlertDialog = false },
@@ -127,13 +128,35 @@ fun MainScreen(viewModel: MainViewModel = hiltViewModel(), uiState: AppUiState)
 		)
 	}

-	fun onTunnelToggle(checked: Boolean, tunnel: TunnelConfig) {
-		if (!checked) viewModel.onTunnelStop().also { return }
-		if (uiState.settings.isKernelEnabled) {
-			viewModel.onTunnelStart(tunnel, uiState.settings.isKernelEnabled)
-		} else {
-			startTunnel.invoke(tunnel)
+	fun requestBatteryOptimizationsDisabled() {
+		val intent =
+			Intent().apply {
+				action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
+				data = Uri.parse("package:${context.packageName}")
+			}
+		batteryActivity.launch(intent)
+	}
+
+	fun onAutoTunnelToggle() {
+		if (!uiState.generalState.isBatteryOptimizationDisableShown &&
+			!context.isBatteryOptimizationsDisabled() && !isRunningOnTv
+		) {
+			return requestBatteryOptimizationsDisabled()
 		}
+		val intent = if (!uiState.settings.isKernelEnabled) {
+			VpnService.prepare(context)
+		} else {
+			null
+		}
+		if (intent != null) return vpnActivity.launch(intent)
+		viewModel.onToggleAutoTunnel()
+	}
+
+	fun onTunnelToggle(checked: Boolean, tunnel: TunnelConfig) {
+		val intent = if (uiState.settings.isKernelEnabled) null else VpnService.prepare(context)
+		if (intent != null) return vpnActivity.launch(intent)
+		if (!checked) viewModel.onTunnelStop().also { return }
+		viewModel.onTunnelStart(tunnel, uiState.settings.isKernelEnabled)
 	}

 	Scaffold(
@@ -216,13 +239,13 @@ fun MainScreen(viewModel: MainViewModel = hiltViewModel(), uiState: AppUiState)
 				}
 			} else {
 				item {
-					AutoTunnelRowItem(uiState) {
-						autoTunnelToggleBattery.invoke()
-					}
+					AutoTunnelRowItem(uiState, {
+						onAutoTunnelToggle()
+					})
 				}
 			}
 			items(
-				sortedTunnels,
+				uiState.tunnels,
 				key = { tunnel -> tunnel.id },
 			) { tunnel ->
 				val expanded = uiState.generalState.isTunnelStatsExpanded
@@ -159,7 +159,18 @@ constructor(
 	}

 	fun onToggleAutoTunnel() = viewModelScope.launch {
-		serviceManager.toggleAutoTunnel(false)
+		val settings = appDataRepository.settings.getSettings()
+		val toggled = !settings.isAutoTunnelEnabled
+		if (toggled) {
+			serviceManager.startAutoTunnel(false)
+		} else {
+			serviceManager.stopAutoTunnel()
+		}
+		appDataRepository.settings.save(
+			settings.copy(
+				isAutoTunnelEnabled = toggled,
+			),
+		)
 	}

 	private suspend fun saveTunnelsFromZipUri(uri: Uri, context: Context) {
@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.common.permission.vpn
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components

 import androidx.compose.foundation.text.ClickableText
 import androidx.compose.material3.MaterialTheme
@@ -12,13 +12,13 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.outlined.ViewQuilt
 import androidx.compose.material.icons.filled.AppShortcut
+import androidx.compose.material.icons.outlined.AdminPanelSettings
 import androidx.compose.material.icons.outlined.Bolt
 import androidx.compose.material.icons.outlined.Code
 import androidx.compose.material.icons.outlined.FolderZip
 import androidx.compose.material.icons.outlined.Notifications
 import androidx.compose.material.icons.outlined.Pin
 import androidx.compose.material.icons.outlined.Restore
-import androidx.compose.material.icons.outlined.VpnKeyOff
 import androidx.compose.material.icons.outlined.VpnLock
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -49,6 +49,7 @@ import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.Forwar
 import com.zaneschepke.wireguardautotunnel.ui.theme.topPadding
 import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchNotificationSettings
+import com.zaneschepke.wireguardautotunnel.util.extensions.launchVpnSettings
 import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
 import com.zaneschepke.wireguardautotunnel.util.extensions.scaledWidth
 import com.zaneschepke.wireguardautotunnel.util.extensions.showToast
@@ -151,51 +152,50 @@ fun SettingsScreen(viewModel: SettingsViewModel = hiltViewModel(), appViewModel:
 					),
 				)
 				if (!isRunningOnTv) {
-					add(
-						SelectionItem(
-							Icons.Outlined.VpnLock,
-							{
-								ScaledSwitch(
-									enabled = !(
-										(
-											uiState.settings.isTunnelOnWifiEnabled ||
-												uiState.settings.isTunnelOnEthernetEnabled ||
-												uiState.settings.isTunnelOnMobileDataEnabled
-											) &&
-											uiState.settings.isAutoTunnelEnabled
-										),
-									onClick = { appViewModel.onToggleAlwaysOnVPN() },
-									checked = uiState.settings.isAlwaysOnVpnEnabled,
-								)
-							},
-							title = {
-								Text(
-									stringResource(R.string.always_on_vpn_support),
-									style = MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
-								)
-							},
-							onClick = { appViewModel.onToggleAlwaysOnVPN() },
+					addAll(
+						listOf(
+							SelectionItem(
+								Icons.Outlined.VpnLock,
+								{
+									ScaledSwitch(
+										enabled = !(
+											(
+												uiState.settings.isTunnelOnWifiEnabled ||
+													uiState.settings.isTunnelOnEthernetEnabled ||
+													uiState.settings.isTunnelOnMobileDataEnabled
+												) &&
+												uiState.settings.isAutoTunnelEnabled
+											),
+										onClick = { appViewModel.onToggleAlwaysOnVPN() },
+										checked = uiState.settings.isAlwaysOnVpnEnabled,
+									)
+								},
+								title = {
+									Text(
+										stringResource(R.string.always_on_vpn_support),
+										style = MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
+									)
+								},
+								onClick = { appViewModel.onToggleAlwaysOnVPN() },
+							),
+							SelectionItem(
+								Icons.Outlined.AdminPanelSettings,
+								title = {
+									Text(
+										stringResource(R.string.kill_switch),
+										style = MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
+									)
+								},
+								onClick = {
+									context.launchVpnSettings()
+								},
+								trailing = {
+									ForwardButton { context.launchVpnSettings() }
+								},
+							),
 						),
 					)
 				}
-				add(
-					SelectionItem(
-						Icons.Outlined.VpnKeyOff,
-						title = {
-							Text(
-								stringResource(R.string.kill_switch_options),
-								style = MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
-							)
-						},
-						onClick = {
-							navController.navigate(Route.KillSwitch)
-						},
-						trailing = {
-							ForwardButton { navController.navigate(Route.KillSwitch) }
-						},
-					),
-				)
-
 				add(
 					SelectionItem(
 						Icons.Outlined.Restore,
@@ -2,8 +2,11 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.langu

 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.navigationBars
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.material3.Scaffold
@@ -50,7 +53,7 @@ fun LanguageScreen(appUiState: AppUiState, appViewModel: AppViewModel) {
 			modifier =
 			Modifier
 				.fillMaxSize().padding(padding)
-				.padding(horizontal = 24.dp.scaledWidth()),
+				.padding(horizontal = 24.dp.scaledWidth()).windowInsetsPadding(WindowInsets.navigationBars),
 		) {
 			item {
 				Box(modifier = Modifier.padding(top = 24.dp.scaledHeight())) {
@@ -6,12 +6,11 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.AirplanemodeActive
 import androidx.compose.material.icons.outlined.Code
@@ -117,6 +116,7 @@ fun AutoTunnelScreen(uiState: AppUiState, viewModel: AutoTunnelViewModel = hiltV
 	)

 	Scaffold(
+		contentWindowInsets = WindowInsets(0.dp),
 		topBar = {
 			TopNavBar(stringResource(R.string.auto_tunneling))
 		},
@@ -128,7 +128,6 @@ fun AutoTunnelScreen(uiState: AppUiState, viewModel: AutoTunnelViewModel = hiltV
 			Modifier
 				.fillMaxSize()
 				.padding(padding)
-				.verticalScroll(rememberScrollState())
 				.padding(top = 24.dp.scaledHeight())
 				.padding(horizontal = 24.dp.scaledWidth()),
 		) {
@@ -1,149 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.settings.killswitch
-
-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.material.icons.Icons
-import androidx.compose.material.icons.outlined.AdminPanelSettings
-import androidx.compose.material.icons.outlined.Lan
-import androidx.compose.material.icons.outlined.VpnKey
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-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 com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.AppUiState
-import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
-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.SurfaceSelectionGroupButton
-import com.zaneschepke.wireguardautotunnel.ui.common.navigation.TopNavBar
-import com.zaneschepke.wireguardautotunnel.ui.common.permission.vpn.withVpnPermission
-import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.SnackbarController
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.ForwardButton
-import com.zaneschepke.wireguardautotunnel.util.StringValue
-import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
-import com.zaneschepke.wireguardautotunnel.util.extensions.launchVpnSettings
-import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
-import com.zaneschepke.wireguardautotunnel.util.extensions.scaledWidth
-
-@Composable
-fun KillSwitchScreen(uiState: AppUiState, appViewModel: AppViewModel) {
-	val context = LocalContext.current
-
-	val toggleVpnSwitch = withVpnPermission<Boolean> { appViewModel.onToggleVpnKillSwitch(it) }
-
-	fun toggleVpnKillSwitch() {
-		with(uiState.settings) {
-			//TODO improve this error message
-			if(isKernelEnabled) return SnackbarController.showMessage(StringValue.StringResource(R.string.kernel_not_supported))
-			if (isVpnKillSwitchEnabled) {
-				appViewModel.onToggleVpnKillSwitch(false)
-			} else {
-				toggleVpnSwitch.invoke(true)
-			}
-		}
-	}
-
-	fun toggleLanOnKillSwitch() {
-		with(uiState.settings) {
-			appViewModel.onToggleLanOnKillSwitch(!isLanOnKillSwitchEnabled)
-		}
-	}
-
-	Scaffold(
-		topBar = {
-			TopNavBar(stringResource(R.string.kill_switch))
-		},
-	) { padding ->
-		Column(
-			horizontalAlignment = Alignment.Start,
-			verticalArrangement = Arrangement.spacedBy(24.dp.scaledHeight(), Alignment.Top),
-			modifier =
-			Modifier
-				.fillMaxSize().padding(padding)
-				.padding(top = 24.dp.scaledHeight())
-				.padding(horizontal = 24.dp.scaledWidth()),
-		) {
-			if (!context.isRunningOnTv()) {
-				SurfaceSelectionGroupButton(
-					listOf(
-						SelectionItem(
-							Icons.Outlined.AdminPanelSettings,
-							title = {
-								Text(
-									stringResource(R.string.native_kill_switch),
-									style = MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
-								)
-							},
-							onClick = { context.launchVpnSettings() },
-							trailing = {
-								ForwardButton { context.launchVpnSettings() }
-							},
-						),
-					),
-				)
-			}
-			SurfaceSelectionGroupButton(
-				buildList {
-					add(
-						SelectionItem(
-							Icons.Outlined.VpnKey,
-							title = {
-								Text(
-									stringResource(R.string.vpn_kill_switch),
-									style = MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
-								)
-							},
-							onClick = {
-								toggleVpnKillSwitch()
-							},
-							trailing = {
-								ScaledSwitch(
-									uiState.settings.isVpnKillSwitchEnabled,
-									onClick = {
-										toggleVpnKillSwitch()
-									},
-								)
-							},
-						),
-					)
-					if (uiState.settings.isVpnKillSwitchEnabled) {
-						add(
-							SelectionItem(
-								Icons.Outlined.Lan,
-								title = {
-									Text(
-										stringResource(R.string.allow_lan_traffic),
-										style = MaterialTheme.typography.bodyMedium.copy(MaterialTheme.colorScheme.onSurface),
-									)
-								},
-								onClick = { toggleLanOnKillSwitch() },
-								description = {
-									Text(
-										stringResource(R.string.bypass_lan_for_kill_switch),
-										style = MaterialTheme.typography.bodySmall.copy(MaterialTheme.colorScheme.outline),
-									)
-								},
-								trailing = {
-									ScaledSwitch(
-										uiState.settings.isLanOnKillSwitchEnabled,
-										onClick = {
-											toggleLanOnKillSwitch()
-										},
-									)
-								},
-							),
-						)
-					}
-				},
-			)
-		}
-	}
-}
@@ -1,20 +1,30 @@
 package com.zaneschepke.wireguardautotunnel.util

-import androidx.appcompat.app.AppCompatDelegate
-import androidx.core.os.LocaleListCompat
+import android.content.res.Resources
+import androidx.core.os.ConfigurationCompat
 import com.zaneschepke.wireguardautotunnel.BuildConfig

 object LocaleUtil {
+	private const val DEFAULT_LANG = "en"
 	val supportedLocales: Array<String> = BuildConfig.LANGUAGES
 	const val OPTION_PHONE_LANGUAGE = "sys_def"

-	fun changeLocale(locale: String) {
-		if (locale == OPTION_PHONE_LANGUAGE) return resetToSystemLanguage()
-		val appLocale: LocaleListCompat = LocaleListCompat.forLanguageTags(locale)
-		AppCompatDelegate.setApplicationLocales(appLocale)
-	}
-
-	private fun resetToSystemLanguage() {
-		AppCompatDelegate.setApplicationLocales(LocaleListCompat.getEmptyLocaleList())
+	/**
+	 * returns the locale to use depending on the preference value
+	 * when preference value = "sys_def" returns the locale of current system
+	 * else it returns the locale code e.g. "en", "bn" etc.
+	 */
+	fun getLocaleFromPrefCode(prefCode: String): String {
+		val localeCode = if (prefCode != OPTION_PHONE_LANGUAGE) {
+			prefCode
+		} else {
+			val systemLang = ConfigurationCompat.getLocales(Resources.getSystem().configuration).get(0)?.language ?: DEFAULT_LANG
+			if (systemLang in supportedLocales) {
+				systemLang
+			} else {
+				DEFAULT_LANG
+			}
+		}
+		return localeCode
 	}
 }
@@ -3,14 +3,12 @@ package com.zaneschepke.wireguardautotunnel.util.extensions
 import androidx.compose.ui.graphics.Color
 import com.wireguard.android.util.RootShell
 import com.wireguard.config.Peer
-import com.zaneschepke.wireguardautotunnel.service.tunnel.BackendState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.ui.theme.SilverTree
 import com.zaneschepke.wireguardautotunnel.ui.theme.Straw
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import org.amnezia.awg.backend.Backend
 import org.amnezia.awg.config.Config
 import timber.log.Timber
 import java.net.InetAddress
@@ -87,11 +85,3 @@ fun RootShell.getCurrentWifiName(): String? {
 	this.run(response, "dumpsys wifi | grep -o \"SSID: [^,]*\" | cut -d ' ' -f2- | tr -d '\"'")
 	return response.lastOrNull()
 }
-
-fun Backend.BackendState.asBackendState(): BackendState {
-	return BackendState.valueOf(this.name)
-}
-
-fun BackendState.asAmBackendState(): Backend.BackendState {
-	return Backend.BackendState.valueOf(this.name)
-}
@@ -81,6 +81,7 @@
    <string name="version">Version</string>
    <string name="settings">Einstellungen</string>
    <string name="support">Unterstützung</string>
+    <string name="watcher_channel_id">Wächterkanal</string>
    <string name="error_authentication_failed">Authentifizierung fehlgeschlagen</string>
    <string name="export_configs">Konfigurationen exportieren</string>
    <string name="unknown_error">Unbekannter Fehler aufgetreten</string>
@@ -98,6 +99,7 @@
    <string name="set_primary_tunnel">Als Primären Tunnel setzen</string>
    <string name="vpn_channel_id">VPN Kanal</string>
    <string name="vpn_channel_name">VPN Benachrichtigungskanal</string>
+    <string name="watcher_channel_name">Wächterbenachrichtigungskanal</string>
    <string name="turn_off_tunnel">Aktion erfordert deaktivierten Tunnel</string>
    <string name="kernel">Kernel</string>
    <string name="use_kernel">Kernelmodul verwenden</string>
@@ -169,4 +171,4 @@
    <string name="use_wildcards">Wildcards für Namen verwenden</string>
    <string name="stop_auto">Auto-Tunnel stoppen</string>
    <string name="monitoring_state_changes">Überwache Statusänderungen</string>
-</resources>
+</resources>
@@ -101,8 +101,10 @@
    <string name="app_name">WG Tunnel</string>
    <string name="vpn_channel_id">Canal VPN</string>
    <string name="vpn_channel_name">Canal de notificación VPN</string>
-	<string name="prominent_background_location_message">La monitorización SSID Wi-Fi necesita de permiso de ubicación en segundo plano incluso si la app está cerrada. Mira el enlace a la Política de Privacidad en la pantalla de ayuda para más detalles.</string>
+    <string name="watcher_channel_id">Canal del obvervador</string>
+    <string name="watcher_channel_name">Canal de notificación del obvervador</string>
+    <string name="prominent_background_location_message">La monitorización SSID Wi-Fi necesita de permiso de ubicación en segundo plano incluso si la app está cerrada. Mira el enlace a la Política de Privacidad en la pantalla de ayuda para más detalles.</string>
    <string name="junk_packet_count">Recuento de paquetes basura</string>
    <string name="junk_packet_minimum_size">Tamaño mínimo del paquete basura</string>
    <string name="add_from_clipboard">Agregar desde el portapapeles</string>
-</resources>
+</resources>
@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
    <string name="vpn_channel_id">Canal VPN</string>
+    <string name="watcher_channel_id">Canal de surveillance</string>
+    <string name="watcher_channel_name">Canal de notification de surveillance</string>
    <string name="turn_off_tunnel">Cette action nécessite la désactivation du tunnel</string>
    <string name="no_tunnels">Aucun tunnel n\'a été ajouté pour le moment !</string>
    <string name="tunnels">Tunnels</string>
@@ -169,4 +171,4 @@
    <string name="kernel_not_supported">Noyau non supporté</string>
    <string name="start_auto">Démarrer l\'auto-tunnel</string>
    <string name="requires_app_relaunch">Cette modification nécessite un redémarrage de l\'application. Voulez-vous continuer ?</string>
-</resources>
+</resources>
@@ -6,6 +6,7 @@
    <string name="kernel">Kernel</string>
    <string name="init_packet_junk_size">Ukuran sampah paket init</string>
    <string name="app_name">WG Tunnel</string>
+    <string name="watcher_channel_name">Notifikasi Saluran Pengamat</string>
    <string name="error_file_extension">File bukan .conf atau .zip</string>
    <string name="turn_off_tunnel">Aksi memerlukan tunnel mati</string>
    <string name="no_tunnels">Belum ada tunnel yang ditambahkan!</string>
@@ -98,6 +99,7 @@
    <string name="handshake">handshake</string>
    <string name="vpn_channel_id">Saluran VPN</string>
    <string name="vpn_channel_name">Notifikasi Saluran VPN</string>
+    <string name="watcher_channel_id">Saluran Pengamat</string>
    <string name="prominent_background_location_message">Fitur ini memerlukan izin lokasi latar belakang untuk mengaktifkan pemantauan SSID Wi-Fi bahkan saat aplikasi ditutup. Untuk detail lebih lanjut, silakan lihat Kebijakan Privasi yang ditautkan di layar Dukungan.</string>
    <string name="copy_public_key">Salin kunci publik</string>
    <string name="base64_key">kunci base64</string>
@@ -115,4 +117,4 @@
    <string name="create_pin">Buat pin</string>
    <string name="mobile_data_tunnel">Ditetapkan sebagai tunnel data seluler</string>
    <string name="set_primary_tunnel">Ditetapkan sebagai tunnel utama</string>
-</resources>
+</resources>
@@ -15,6 +15,8 @@
    <string name="icon">Icoon</string>
    <string name="include">Meenemen</string>
    <string name="addresses">Adres</string>
+    <string name="watcher_channel_id">Watcher Kanaal</string>
+    <string name="watcher_channel_name">Watcher Notificatiekanaal</string>
    <string name="peer">Peer (extern systeem)</string>
    <string name="allowed_ips">Allowed IPs</string>
    <string name="always_on_vpn_support">Altijd-aan VPN toestaan</string>
@@ -136,4 +138,4 @@
    <string name="location_services_missing_message">De app kan geen ingeschakelde locatieservices op je apparaat vinden. Afhankelijk van het type apparaat kan dit leiden tot een niet functionerende herkenning van het verbonden WiFi netwerk. De niet-vertrouwde WiFi functionaliteit werkt daardoor mogelijk niet. Toch doorgaan?</string>
    <string name="background_location_message">Permanente achtergrondtoegang tot exacte locatie is vereist voor deze functie. Bekijk aub de</string>
    <string name="transport_packet_magic_header">Transport packet magic header</string>
-</resources>
+</resources>
@@ -99,6 +99,8 @@
    <string name="app_name">WG Tunnel</string>
    <string name="vpn_channel_id">Canal de VPN</string>
    <string name="vpn_channel_name">Canal de notificações VPN</string>
+    <string name="watcher_channel_id">Canal de vigia</string>
+    <string name="watcher_channel_name">Canal de notificações de vigia</string>
    <string name="prominent_background_location_message">Este recurso precisa de permissões de localização em segundo plano para ativar o monitoramento do SSID da rede Wi-Fi mesmo quando a aplicação está fechado. Para mais pormenores, por favor veja a Política de Privacidade no ecrã de Suporte.</string>
    <string name="trusted_ssid_value_description">Envie o SSID</string>
    <string name="add_tunnels_text">Adicionar a partir de ficheiro ou zip</string>
@@ -130,4 +132,4 @@
    <string name="getting_started_guide">guia de início rápido</string>
    <string name="always_on_message2">para ter certeza que VPN Sempre-ligada é desligada para todas as outras aplicações e tente novamente</string>
    <string name="restart_at_boot">Reiniciar no arranque</string>
-</resources>
+</resources>
@@ -110,6 +110,8 @@
    <string name="error_file_format">Formato de configuração inválido</string>
    <string name="vpn_channel_id">Canal de VPN</string>
    <string name="vpn_channel_name">Canal de notificações VPN</string>
+    <string name="watcher_channel_id">Canal de vigia</string>
+    <string name="watcher_channel_name">Canal de notificações de vigia</string>
    <string name="db_name">wg-tunnel-db</string>
    <string name="set_custom_ping_ip">Definir ip ping personalizado</string>
    <string name="vpn_denied_dialog_title">Permissão negada</string>
@@ -128,4 +130,4 @@
    <string name="handshake">handshake</string>
    <string name="background_location_message">Permitir que toda a permissão de localização do tempo e/ou localização precisa é necessária para este recurso. Por favor, veja</string>
    <string name="sec">seg</string>
-</resources>
+</resources>
@@ -63,6 +63,8 @@
    <string name="app_name">WG Tunnel</string>
    <string name="vpn_channel_id">Канал VPN</string>
    <string name="vpn_channel_name">Канал уведомлений VPN</string>
+    <string name="watcher_channel_id">Канал наблюдателя</string>
+    <string name="watcher_channel_name">Канал уведомлений наблюдателя</string>
    <string name="tunnels">Туннели</string>
    <string name="okay">Хорошо</string>
    <string name="prominent_background_location_title">Фоновая передача местоположения</string>
@@ -169,4 +171,4 @@
    <string name="monitoring_state_changes">Отслеживание изменений состояния</string>
    <string name="enable_local_logging">Включить ведение журнала</string>
    <string name="add_from_clipboard">Добавить из буфера обмена</string>
-</resources>
+</resources>
@@ -3,6 +3,8 @@
    <string name="app_name">WG Tunnel</string>
    <string name="vpn_channel_id">VPN Kanalı</string>
    <string name="vpn_channel_name">VPN Bildirim Kanalı</string>
+    <string name="watcher_channel_id">İzleyici Kanalı</string>
+    <string name="watcher_channel_name">İzleyici Bildirim Kanalı</string>
    <string name="github_url" translatable="false">https://github.com/zaneschepke/wgtunnel/issues</string>
    <string name="docs_url" translatable="false">https://zaneschepke.com/wgtunnel-docs/overview.html</string>
    <string name="privacy_policy_url" translatable="false">https://zaneschepke.com/wgtunnel-docs/privacypolicy.html</string>
@@ -122,4 +124,4 @@
    <string name="getting_started_guide">başlangıç kılavuzu</string>
    <string name="error_file_format">Geçersiz tünel yapılandırma formatı</string>
    <string name="restart_at_boot">Önyüklemede yeniden başlat</string>
-</resources>
+</resources>
@@ -97,10 +97,12 @@
    <string name="no_browser_detected">没有安装浏览器</string>
    <string name="incorrect_pin">密码不正确</string>
    <string name="set_custom_ping_ip">自定义 Ping 的目标 ip</string>
+    <string name="watcher_channel_name">守护者通知频道</string>
    <string name="vpn_channel_id">VPN 频道</string>
    <string name="junk_packet_count">无效包计数</string>
    <string name="app_name">WG Tunnel</string>
    <string name="vpn_channel_name">VPN 通知频道</string>
+    <string name="watcher_channel_id">守护者频道</string>
    <string name="open_issue">查看问题</string>
    <string name="read_logs">查看日志</string>
    <string name="auto">(自动)</string>
@@ -169,4 +171,4 @@
    <string name="enable_local_logging">开启本地日志</string>
    <string name="configuration_change">配置更改</string>
    <string name="requires_app_relaunch">此更改需要重新启动应用程序。您是否要继续？</string>
-</resources>
+</resources>
@@ -2,7 +2,9 @@
    <string name="app_name">WG Tunnel</string>
    <string name="vpn_channel_id">VPN Channel</string>
    <string name="vpn_channel_name">VPN Notification Channel</string>
-	<string name="github_url" translatable="false">https://github.com/zaneschepke/wgtunnel/issues</string>
+    <string name="watcher_channel_id">Watcher Channel</string>
+    <string name="watcher_channel_name">Watcher Notification Channel</string>
+    <string name="github_url" translatable="false">https://github.com/zaneschepke/wgtunnel/issues</string>
    <string name="docs_url" translatable="false">https://zaneschepke.com/wgtunnel-docs/overview.html</string>
    <string name="privacy_policy_url" translatable="false">https://zaneschepke.com/wgtunnel-docs/privacypolicy.html</string>
 	<string name="docs_wildcards" translatable="false" >https://zaneschepke.com/wgtunnel-docs/features.html#wildcard-wi-fi-name-support</string>
@@ -80,7 +82,7 @@
    <string name="error_no_file_explorer">No file explorer installed</string>
    <string name="error_invalid_code">Invalid QR code</string>
    <string name="location_services_missing_message">The app is not detecting any location services enabled on your device. Depending on the device, this could cause the untrusted wifi feature to fail to read the wifi name. Would you like to continue anyways?</string>
-    <string name="auto_tunnel_title">Auto-tunnel service</string>
+    <string name="auto_tunnel_title">Auto-tunnel Service</string>
    <string name="delete_tunnel">Delete tunnel</string>
    <string name="delete_tunnel_message">Are you sure you would like to delete this tunnel?</string>
    <string name="yes">Yes</string>
@@ -180,14 +182,4 @@
 	<string name="stop_on_internet_loss">Stop tunnel on internet loss</string>
 	<string name="ethernet_tunnel">Ethernet tunnel</string>
 	<string name="set_ethernet_tunnel">Set as ethernet tunnel</string>
-	<string name="native_kill_switch">Native kill switch</string>
-	<string name="vpn_kill_switch">VPN kill switch</string>
-	<string name="kill_switch_options">Kill switch options</string>
-	<string name="allow_lan_traffic">Allow LAN traffic</string>
-	<string name="bypass_lan_for_kill_switch">Bypass LAN for kill switch</string>
-	<string name="vpn_channel_description">A channel for VPN state notifications</string>
-	<string name="auto_tunnel_channel_id">Auto-tunnel Channel</string>
-	<string name="auto_tunnel_channel_name">Auto-tunnel Notification Channel</string>
-	<string name="auto_tunnel_channel_description">A channel for auto-tunnel state notifications</string>
-	<string name="stop">stop</string>
 </resources>
@@ -1,7 +1,7 @@
 object Constants {
-	const val VERSION_NAME = "3.6.4"
+	const val VERSION_NAME = "3.6.1"
    const val JVM_TARGET = "17"
-    const val VERSION_CODE = 36400
+    const val VERSION_CODE = 36100
    const val TARGET_SDK = 35
    const val MIN_SDK = 26
    const val APP_ID = "com.zaneschepke.wireguardautotunnel"
@@ -1,5 +0,0 @@
-What's new:
- Added VPN kill switch w/LAN bypass
- Improved auto tunnel speed and reliability
- Improved tile sync
- Various bug fixes and improvements
@@ -1,3 +0,0 @@
-What's new:
- Fixed kernel mode toggle bug
- Fixed notification crash bug
@@ -1,7 +1,7 @@
 [versions]
 accompanist = "0.36.0"
 activityCompose = "1.9.3"
-amneziawgAndroid = "1.2.3"
+amneziawgAndroid = "1.2.2"
 androidx-junit = "1.2.1"
 appcompat = "1.7.0"
 biometricKtx = "1.2.0-alpha05"
@@ -10,7 +10,7 @@ coreKtx = "1.15.0"
 datastorePreferences = "1.1.1"
 desugar_jdk_libs = "2.1.3"
 espressoCore = "3.6.1"
-hiltAndroid = "2.53"
+hiltAndroid = "2.52"
 hiltNavigationCompose = "1.2.0"
 junit = "4.13.2"
 kotlinx-serialization-json = "1.7.3"
@@ -21,9 +21,9 @@ pinLockCompose = "1.0.4"
 roomVersion = "2.6.1"
 timber = "5.0.1"
 tunnel = "1.2.1"
-androidGradlePlugin = "8.8.0-rc01"
-kotlin = "2.1.0"
-ksp = "2.1.0-1.0.29"
+androidGradlePlugin = "8.7.3"
+kotlin = "2.0.21"
+ksp = "2.0.21-1.0.28"
 composeBom = "2024.11.00"
 compose = "1.7.5"
 zxingAndroidEmbedded = "4.3.0"
@@ -32,7 +32,7 @@ gradlePlugins-grgit = "5.3.0"

 #plugins
 material = "1.12.0"
-gradlePlugins-ktlint="12.1.2"
+gradlePlugins-ktlint="12.1.1"


 [libraries]
@@ -1,8 +1,8 @@
 #Wed Oct 11 22:39:21 EDT 2023
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
-distributionSha256Sum=31c55713e40233a8303827ceb42ca48a47267a0ad4bab9177123121e71524c26
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+distributionSha256Sum=d725d707bfabd4dfdc958c624003b3c80accc03f7037b5122c4b1d0ef15cecab
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -49,7 +49,6 @@ dependencies {
 	androidTestImplementation(libs.androidx.junit)
 	androidTestImplementation(libs.androidx.espresso.core)

-	implementation(libs.androidx.lifecycle.process)
 	// logging
 	implementation(libs.timber)
 }
@@ -4,7 +4,8 @@ import com.zaneschepke.logcatter.model.LogMessage
 import kotlinx.coroutines.flow.Flow

 interface LogReader {
-	fun initialize(onLogMessage: ((message: LogMessage) -> Unit)? = null)
+	suspend fun start(onLogMessage: ((message: LogMessage) -> Unit)? = null)
+	fun stop()
 	fun zipLogFiles(path: String)
 	suspend fun deleteAndClearLogs()
 	val bufferedLogs: Flow<LogMessage>
@@ -1,30 +1,26 @@
 package com.zaneschepke.logcatter

-import androidx.lifecycle.DefaultLifecycleObserver
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.ProcessLifecycleOwner
-import androidx.lifecycle.lifecycleScope
+import android.content.Context
 import com.zaneschepke.logcatter.model.LogMessage
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import timber.log.Timber
 import java.io.BufferedOutputStream
 import java.io.BufferedReader
 import java.io.File
+import java.io.FileNotFoundException
 import java.io.FileOutputStream
 import java.io.IOException
 import java.io.InputStreamReader
 import java.util.zip.ZipEntry
 import java.util.zip.ZipOutputStream

-object LogcatReader {
+object LogcatCollector {

 	private const val MAX_FILE_SIZE = 2097152L // 2MB
 	private const val MAX_FOLDER_SIZE = 10485760L // 10MB
@@ -44,7 +40,7 @@ object LogcatReader {
 		var logcatPath = ""
 	}

-	fun init(maxFileSize: Long = MAX_FILE_SIZE, maxFolderSize: Long = MAX_FOLDER_SIZE, storageDir: String): LogReader {
+	fun init(maxFileSize: Long = MAX_FILE_SIZE, maxFolderSize: Long = MAX_FOLDER_SIZE, context: Context): LogReader {
 		if (maxFileSize > maxFolderSize) {
 			throw IllegalStateException("maxFileSize must be less than maxFolderSize")
 		}
@@ -52,11 +48,13 @@ object LogcatReader {
 			LogcatHelperInit.maxFileSize = maxFileSize
 			LogcatHelperInit.maxFolderSize = maxFolderSize
 			LogcatHelperInit.pID = android.os.Process.myPid()
-			LogcatHelperInit.publicAppDirectory = storageDir
-			LogcatHelperInit.logcatPath = LogcatHelperInit.publicAppDirectory + File.separator + "logs"
-			val logDirectory = File(LogcatHelperInit.logcatPath)
-			if (!logDirectory.exists()) {
-				logDirectory.mkdir()
+			context.getExternalFilesDir(null)?.let {
+				LogcatHelperInit.publicAppDirectory = it.absolutePath
+				LogcatHelperInit.logcatPath = LogcatHelperInit.publicAppDirectory + File.separator + "logs"
+				val logDirectory = File(LogcatHelperInit.logcatPath)
+				if (!logDirectory.exists()) {
+					logDirectory.mkdir()
+				}
 			}
 			return Logcat
 		}
@@ -64,12 +62,7 @@ object LogcatReader {

 	internal object Logcat : LogReader {

-		private lateinit var logcatReader: LogcatReader
-
-		override fun initialize(onLogMessage: ((message: LogMessage) -> Unit)?) {
-			logcatReader = LogcatReader(LogcatHelperInit.pID.toString(), LogcatHelperInit.logcatPath, onLogMessage)
-			ProcessLifecycleOwner.get().lifecycle.addObserver(logcatReader)
-		}
+		private var logcatReader: LogcatReader? = null

 		private fun obfuscator(log: String): String {
 			return findKeyRegex.replace(log, "<crypto-key>").let { first ->
@@ -79,10 +72,22 @@ object LogcatReader {
 			}.let { last -> findIpv4AddressRegex.replace(last, "<ipv4-address>") }
 		}

+		override suspend fun start(onLogMessage: ((message: LogMessage) -> Unit)?) {
+			logcatReader ?: run {
+				logcatReader = LogcatReader(LogcatHelperInit.pID.toString(), LogcatHelperInit.logcatPath, onLogMessage)
+			}
+			logcatReader?.run()
+		}
+
+		override fun stop() {
+			logcatReader?.stop()
+			logcatReader = null
+		}
+
 		override fun zipLogFiles(path: String) {
-			logcatReader.cancel()
+			logcatReader?.pause()
 			zipAll(path)
-			logcatReader.onCreate(ProcessLifecycleOwner.get())
+			logcatReader?.resume()
 		}

 		private fun zipAll(zipFilePath: String) {
@@ -105,10 +110,10 @@ object LogcatReader {
 		@OptIn(ExperimentalCoroutinesApi::class)
 		override suspend fun deleteAndClearLogs() {
 			withContext(ioDispatcher) {
-				logcatReader.cancel()
+				logcatReader?.pause()
 				_bufferedLogs.resetReplayCache()
-				logcatReader.deleteAllFiles()
-				logcatReader.onCreate(ProcessLifecycleOwner.get())
+				logcatReader?.deleteAllFiles()
+				logcatReader?.resume()
 			}
 		}

@@ -129,25 +134,57 @@ object LogcatReader {
 			pID: String,
 			private val logcatPath: String,
 			private val callback: ((input: LogMessage) -> Unit)?,
-		) : DefaultLifecycleObserver {
+		) {
 			private var logcatProc: Process? = null
 			private var reader: BufferedReader? = null

-			private val command = "logcat -v epoch | grep \"($pID)\""
-			private val clearLogCommand = "logcat -c"
-			private var logJob: Job? = null
+			@get:Synchronized @set:Synchronized
+			private var paused = false
+
+			@get:Synchronized @set:Synchronized
+			private var stopped = false
+			private var command = ""
+			private var clearLogCommand = ""
 			private var outputStream: FileOutputStream? = null

-			override fun onCreate(owner: LifecycleOwner) {
-				super.onCreate(owner)
-				logJob = owner.lifecycleScope.launch(ioDispatcher) {
+			init {
+				try {
+					outputStream = FileOutputStream(createLogFile(logcatPath))
+				} catch (e: FileNotFoundException) {
+					Timber.e(e)
+				}
+
+				command = "logcat -v epoch | grep \"($pID)\""
+				clearLogCommand = "logcat -c"
+			}
+
+			fun pause() {
+				paused = true
+			}
+			fun stop() {
+				stopped = true
+			}
+
+			fun resume() {
+				paused = false
+			}
+
+			fun clear() {
+				Runtime.getRuntime().exec(clearLogCommand)
+			}
+
+			suspend fun run() {
+				withContext(ioDispatcher) {
+					paused = false
+					stopped = false
+					if (outputStream == null) return@withContext
 					try {
-						if (outputStream == null) outputStream = createNewLogFileStream()
 						clear()
 						logcatProc = Runtime.getRuntime().exec(command)
 						reader = BufferedReader(InputStreamReader(logcatProc!!.inputStream), 1024)
-						var line: String? = null
-						while (true) {
+						var line: String?
+						while (!stopped) {
+							if (paused) continue
 							line = reader?.readLine()
 							if (line.isNullOrEmpty()) continue
 							outputStream?.let {
@@ -159,8 +196,8 @@ object LogcatReader {
 									deleteOldestFile()
 								}
 								line.let { text ->
-									val sanitized = obfuscator(text)
-									it.write((sanitized + System.lineSeparator()).toByteArray())
+									val obfuscated = obfuscator(text)
+									it.write((obfuscated + System.lineSeparator()).toByteArray())
 									try {
 										val logMessage = LogMessage.from(text)
 										_bufferedLogs.tryEmit(logMessage)
@@ -177,34 +214,19 @@ object LogcatReader {
 					} catch (e: IOException) {
 						Timber.e(e)
 					} finally {
-						reset()
+						logcatProc?.destroy()
+						logcatProc = null
+
+						try {
+							reader?.close()
+							outputStream?.close()
+							reader = null
+							outputStream = null
+						} catch (e: IOException) {
+							Timber.e(e)
+						}
 					}
 				}
-				logJob?.invokeOnCompletion {
-					reset()
-				}
-			}
-
-			override fun onDestroy(owner: LifecycleOwner) {
-				super.onDestroy(owner)
-				logJob?.cancel()
-			}
-
-			fun cancel() {
-				logJob?.cancel()
-			}
-
-			private fun reset() {
-				logcatProc?.destroy()
-				logcatProc = null
-				reader?.close()
-				outputStream?.close()
-				reader = null
-				outputStream = null
-			}
-
-			fun clear() {
-				Runtime.getRuntime().exec(clearLogCommand)
 			}

 			private fun getFolderSize(path: String): Long {
@@ -244,6 +266,7 @@ object LogcatReader {
 				directory.listFiles()?.toMutableList()?.run {
 					this.forEach { it.delete() }
 				}
+				outputStream = createNewLogFileStream()
 			}
 		}
 	}
@@ -1 +1 @@
-13
+11