fix checksum

revert amnezia tun version bump
2026-07-03 14:07:49 +02:00 · 2025-08-08 15:08:11 -04:00 · 2025-08-08 15:05:11 -04:00 · 2025-08-08 14:43:23 -04:00 · 2025-08-08 04:46:32 -04:00 · 2025-08-08 04:07:04 -04:00
256 changed files with 6172 additions and 2895 deletions
@@ -12,7 +12,6 @@ on:
        default: debug
        options:
          - debug
-          - prerelease
          - nightly
          - release
      flavor:
@@ -105,9 +104,6 @@ jobs:
            "release")
              ./gradlew :app:assemble${flavor^}Release --info
              ;;
-            "prerelease")
-              ./gradlew :app:assemble${flavor^}Prerelease --info
-              ;;
            "nightly")
              ./gradlew :app:assemble${flavor^}Nightly --info
              ;;
@@ -20,7 +20,7 @@ jobs:
      - name: Check for new commits
        id: check
        env:
-          GITHUB_TOKEN: ${{ secrets.PAT }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          NEW_COMMITS=$(git rev-list --count --after="$(date -Iseconds -d '23 hours ago')" ${{ github.sha }})
          echo "new_commits=$NEW_COMMITS" >> $GITHUB_OUTPUT
@@ -25,7 +25,6 @@ on:
        description: "GitHub release type"
        options:
          - none
-          - prerelease
          - release
        default: release
        required: true
@@ -60,7 +59,7 @@ jobs:
      flavor: fdroid

  build-standalone:
-    if: ${{ github.event_name == 'push' || inputs.release_type == 'release' || inputs.release_type == 'prerelease' || inputs.flavor == 'standalone' }}
+    if: ${{ github.event_name == 'push' || inputs.release_type == 'release' || inputs.release_type == 'debug' || inputs.flavor == 'standalone' }}
    uses: ./.github/workflows/build.yml
    secrets: inherit
    with:
@@ -124,11 +123,6 @@ jobs:
          echo "$RELEASE_NOTES" >> $GITHUB_ENV
          echo "EOF" >> $GITHUB_ENV

-      - name: On prerelease release notes
-        if: ${{ github.event_name != 'push' && inputs.release_type == 'prerelease' }}
-        run: |
-          echo "RELEASE_NOTES=Testing version of app for specific feature." >> $GITHUB_ENV
-
      - name: Get checksum
        id: checksum
        run: |
@@ -162,8 +156,8 @@ jobs:
          tag_name: ${{ github.event_name == 'push' && github.ref_name || github.event.inputs.tag_name }}
          name: ${{ github.event_name == 'push' && github.ref_name || github.event.inputs.tag_name }}
          draft: false
-          prerelease: ${{ github.event_name != 'push' && inputs.release_type == 'prerelease' }}
-          make_latest: ${{ github.event_name == 'push' || inputs.release_type == 'release' }}
+          prerelease: false
+          make_latest: true
          files: |
            ${{ github.workspace }}/temp/**/*.apk
        env:
@@ -178,7 +172,7 @@ jobs:
      - name: Dispatch update for fdroid repo
        uses: peter-evans/repository-dispatch@v3
        with:
-          token: ${{ secrets.PAT }}
+          token: ${{ secrets.GITHUB_TOKEN }}
          repository: wgtunnel/fdroid
          event-type: fdroid-update

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
@@ -20,6 +22,8 @@ android {
        includeInBundle = false
    }

+    ksp { arg("room.schemaLocation", "$projectDir/schemas") }
+
    defaultConfig {
        applicationId = Constants.APP_ID
        minSdk = Constants.MIN_SDK
@@ -27,15 +31,10 @@ android {
        versionCode = computeVersionCode()
        versionName = computeVersionName()

-        ksp { arg("room.schemaLocation", "$projectDir/schemas") }
-
        sourceSets { getByName("debug").assets.srcDirs(files("$projectDir/schemas")) }

-        buildConfigField(
-            "String[]",
-            "LANGUAGES",
-            "new String[]{ ${languageList().joinToString(separator = ", ") { "\"$it\"" }} }",
-        )
+        val languagesArray = buildLanguagesArray(languageList())
+        buildConfigField("String[]", "LANGUAGES", "new String[]{ $languagesArray }")

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables { useSupportLibrary = true }
@@ -73,22 +72,15 @@ android {

        debug {
            applicationIdSuffix = ".debug"
-            resValue("string", "app_name", "WG Tunnel - Debug")
+            resValue("string", "app_name", "WG Tunnel Debug")
            isDebuggable = true
            resValue("string", "provider", "\"${Constants.APP_NAME}.provider.debug\"")
        }

-        create(Constants.PRERELEASE) {
-            initWith(buildTypes.getByName(Constants.RELEASE))
-            applicationIdSuffix = ".prerelease"
-            resValue("string", "app_name", "WG Tunnel - Pre")
-            resValue("string", "provider", "\"${Constants.APP_NAME}.provider.pre\"")
-        }
-
        create(Constants.NIGHTLY) {
            initWith(buildTypes.getByName(Constants.RELEASE))
            applicationIdSuffix = ".nightly"
-            resValue("string", "app_name", "WG Tunnel - Nightly")
+            resValue("string", "app_name", "WG Tunnel Nightly")
            resValue("string", "provider", "\"${Constants.APP_NAME}.provider.nightly\"")
        }
    }
@@ -114,7 +106,14 @@ android {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
-    kotlinOptions { jvmTarget = Constants.JVM_TARGET }
+
+    kotlin {
+        compilerOptions {
+            jvmTarget = JvmTarget.JVM_17
+            freeCompilerArgs = listOf("-XXLanguage:+PropertyParamAnnotationDefaultTargetMode")
+        }
+    }
+
    buildFeatures {
        compose = true
        buildConfig = true
@@ -122,8 +121,8 @@ android {
    packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }

    licensee {
-        Constants.allowedLicenses.forEach { allow(it) }
-        allowUrl(Constants.XZING_LICENSE_URL)
+        allowedLicenses().forEach { allow(it) }
+        allowedLicenseUrls().forEach { allowUrl(it) }
    }

    applicationVariants.all {
@@ -219,6 +218,16 @@ dependencies {
    implementation(libs.ktor.client.content.negotiation)
    implementation(libs.ktor.serialization.kotlinx.json)
    implementation(libs.slf4j.android)
+    implementation(libs.icmp4a)
+
+    // shizuku
+    implementation(libs.shizuku.api)
+    implementation(libs.shizuku.provider)
+
+    implementation(libs.reorderable)
+    implementation(libs.roomdatabasebackup) {
+        exclude(group = "org.reactivestreams", module = "reactive-streams")
+    }
 }

 tasks.register<Copy>("copyLicenseeJsonToAssets") {
@@ -155,9 +155,7 @@
          "columnNames": [
            "id"
          ]
-        },
-        "indices": [],
-        "foreignKeys": []
+        }
      },
      {
        "tableName": "TunnelConfig",
@@ -227,21 +225,18 @@
            "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"
          },
          {
@@ -275,11 +270,9 @@
            "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, 'ae51793c4d09ea3194ecd26f0606f35c')"
@@ -0,0 +1,295 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 17,
+    "identityHash": "380d82359c99933cc9ce783347c4ec31",
+    "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_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, `debounce_delay_seconds` INTEGER NOT NULL DEFAULT 3, `is_disable_kill_switch_on_trusted_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_unsecure_enabled` INTEGER NOT NULL DEFAULT false, `split_tunnel_apps` TEXT NOT NULL DEFAULT '', `wifi_detection_method` INTEGER NOT NULL DEFAULT 0)",
+        "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": "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"
+          },
+          {
+            "fieldPath": "debounceDelaySeconds",
+            "columnName": "debounce_delay_seconds",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "isDisableKillSwitchOnTrustedEnabled",
+            "columnName": "is_disable_kill_switch_on_trusted_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnUnsecureEnabled",
+            "columnName": "is_tunnel_on_unsecure_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "splitTunnelApps",
+            "columnName": "split_tunnel_apps",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "wifiDetectionMethod",
+            "columnName": "wifi_detection_method",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false, `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, `is_ipv4_preferred` INTEGER NOT NULL DEFAULT true)",
+        "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",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingCooldown",
+            "columnName": "ping_cooldown",
+            "affinity": "INTEGER",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingIp",
+            "columnName": "ping_ip",
+            "affinity": "TEXT",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "isEthernetTunnel",
+            "columnName": "is_ethernet_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isIpv4Preferred",
+            "columnName": "is_ipv4_preferred",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          }
+        ],
+        "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`)"
+          }
+        ]
+      }
+    ],
+    "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, '380d82359c99933cc9ce783347c4ec31')"
+    ]
+  }
+}
@@ -0,0 +1,302 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 18,
+    "identityHash": "505728bad740c12bab998a066b569333",
+    "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_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, `debounce_delay_seconds` INTEGER NOT NULL DEFAULT 3, `is_disable_kill_switch_on_trusted_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_unsecure_enabled` INTEGER NOT NULL DEFAULT false, `split_tunnel_apps` TEXT NOT NULL DEFAULT '', `wifi_detection_method` INTEGER NOT NULL DEFAULT 0)",
+        "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": "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"
+          },
+          {
+            "fieldPath": "debounceDelaySeconds",
+            "columnName": "debounce_delay_seconds",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "isDisableKillSwitchOnTrustedEnabled",
+            "columnName": "is_disable_kill_switch_on_trusted_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnUnsecureEnabled",
+            "columnName": "is_tunnel_on_unsecure_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "splitTunnelApps",
+            "columnName": "split_tunnel_apps",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "wifiDetectionMethod",
+            "columnName": "wifi_detection_method",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false, `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, `is_ipv4_preferred` INTEGER NOT NULL DEFAULT true, `position` INTEGER NOT NULL DEFAULT 0)",
+        "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",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingCooldown",
+            "columnName": "ping_cooldown",
+            "affinity": "INTEGER",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingIp",
+            "columnName": "ping_ip",
+            "affinity": "TEXT",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "isEthernetTunnel",
+            "columnName": "is_ethernet_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isIpv4Preferred",
+            "columnName": "is_ipv4_preferred",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          },
+          {
+            "fieldPath": "position",
+            "columnName": "position",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "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`)"
+          }
+        ]
+      }
+    ],
+    "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, '505728bad740c12bab998a066b569333')"
+    ]
+  }
+}
@@ -0,0 +1,316 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 19,
+    "identityHash": "82bdb96b7a9f8695a34ad1ec21d9aea8",
+    "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_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, `debounce_delay_seconds` INTEGER NOT NULL DEFAULT 3, `is_disable_kill_switch_on_trusted_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_unsecure_enabled` INTEGER NOT NULL DEFAULT false, `wifi_detection_method` INTEGER NOT NULL DEFAULT 0, `is_ping_monitoring_enabled` INTEGER NOT NULL DEFAULT true, `tunnel_ping_interval_sec` INTEGER NOT NULL DEFAULT 30, `tunnel_ping_attempts` INTEGER NOT NULL DEFAULT 3, `tunnel_ping_timeout_sec` INTEGER)",
+        "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": "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"
+          },
+          {
+            "fieldPath": "debounceDelaySeconds",
+            "columnName": "debounce_delay_seconds",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "isDisableKillSwitchOnTrustedEnabled",
+            "columnName": "is_disable_kill_switch_on_trusted_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnUnsecureEnabled",
+            "columnName": "is_tunnel_on_unsecure_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "wifiDetectionMethod",
+            "columnName": "wifi_detection_method",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          },
+          {
+            "fieldPath": "isPingMonitoringEnabled",
+            "columnName": "is_ping_monitoring_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          },
+          {
+            "fieldPath": "tunnelPingIntervalSeconds",
+            "columnName": "tunnel_ping_interval_sec",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "30"
+          },
+          {
+            "fieldPath": "tunnelPingAttempts",
+            "columnName": "tunnel_ping_attempts",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "tunnelPingTimeoutSeconds",
+            "columnName": "tunnel_ping_timeout_sec",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false, `restart_on_ping_failure` INTEGER NOT NULL DEFAULT false, `ping_target` TEXT DEFAULT null, `is_ethernet_tunnel` INTEGER NOT NULL DEFAULT false, `is_ipv4_preferred` INTEGER NOT NULL DEFAULT true, `position` INTEGER NOT NULL DEFAULT 0, `auto_tunnel_apps` TEXT NOT NULL DEFAULT '[]')",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "tunnelNetworks",
+            "columnName": "tunnel_networks",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isMobileDataTunnel",
+            "columnName": "is_mobile_data_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPrimaryTunnel",
+            "columnName": "is_primary_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "amQuick",
+            "columnName": "am_quick",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isActive",
+            "columnName": "is_Active",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "restartOnPingFailure",
+            "columnName": "restart_on_ping_failure",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "pingTarget",
+            "columnName": "ping_target",
+            "affinity": "TEXT",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "isEthernetTunnel",
+            "columnName": "is_ethernet_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isIpv4Preferred",
+            "columnName": "is_ipv4_preferred",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          },
+          {
+            "fieldPath": "position",
+            "columnName": "position",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          },
+          {
+            "fieldPath": "autoTunnelApps",
+            "columnName": "auto_tunnel_apps",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "'[]'"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ]
+      }
+    ],
+    "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, '82bdb96b7a9f8695a34ad1ec21d9aea8')"
+    ]
+  }
+}
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#648DB3</color>
+</resources>
@@ -12,7 +12,6 @@

    <!--foreground service permissions-->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
    <!--start service on boot permission-->
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
@@ -1,9 +1,7 @@
 package com.zaneschepke.wireguardautotunnel

-import android.Manifest
 import android.annotation.SuppressLint
 import android.content.Intent
-import android.content.pm.PackageManager
 import android.graphics.Color
 import android.os.Build
 import android.os.Bundle
@@ -27,10 +25,10 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.unit.dp
-import androidx.core.content.ContextCompat
 import androidx.core.net.toUri
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.lifecycle.lifecycleScope
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.currentBackStackEntryAsState
@@ -38,6 +36,9 @@ import androidx.navigation.compose.rememberNavController
 import androidx.navigation.toRoute
 import com.zaneschepke.networkmonitor.NetworkMonitor
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.di.MainDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
 import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.dialog.VpnDeniedDialog
@@ -49,10 +50,12 @@ import com.zaneschepke.wireguardautotunnel.ui.navigation.components.DynamicTopAp
 import com.zaneschepke.wireguardautotunnel.ui.navigation.components.currentNavBackStackEntryAsNavBarState
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.AutoTunnelScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.advanced.AutoTunnelAdvancedScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.detection.WifiDetectionMethodScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.LocationDisclosureScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.TunnelAutoTunnelScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.ConfigScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.sort.SortScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.SplitTunnelScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.tunneloptions.TunnelOptionsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.pin.PinLockScreen
@@ -63,17 +66,22 @@ 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.killswitch.KillSwitchScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.logs.LogsScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.monitoring.TunnelMonitoringScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.license.LicenseScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
 import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
+import com.zaneschepke.wireguardautotunnel.util.extensions.restartApp
+import com.zaneschepke.wireguardautotunnel.util.extensions.showToast
 import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
 import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 import dagger.hilt.android.AndroidEntryPoint
+import de.raphaelebner.roomdatabasebackup.core.RoomBackup
 import javax.inject.Inject
 import kotlin.system.exitProcess
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.launch
 import org.amnezia.awg.backend.GoBackend.VpnService
-import timber.log.Timber

@AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
@@ -84,8 +92,18 @@ class MainActivity : AppCompatActivity() {

    @Inject lateinit var networkMonitor: NetworkMonitor

+    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
+
+    @Inject @MainDispatcher lateinit var mainDispatcher: CoroutineDispatcher
+
+    @Inject lateinit var appDatabase: AppDatabase
+
    private var lastLocationPermissionState: Boolean? = null

+    private lateinit var roomBackup: RoomBackup
+
+    val REQUEST_CODE = 123
+
    @SuppressLint("BatteryLife")
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge(
@@ -96,6 +114,7 @@ class MainActivity : AppCompatActivity() {
            window.isNavigationBarContrastEnforced = false
        }
        super.onCreate(savedInstanceState)
+        roomBackup = RoomBackup(this)

        val viewModel by viewModels<AppViewModel>()

@@ -107,7 +126,6 @@ class MainActivity : AppCompatActivity() {
            val isTv = isRunningOnTv()
            val appUiState by viewModel.uiState.collectAsStateWithLifecycle()
            val appViewState by viewModel.appViewState.collectAsStateWithLifecycle()
-            val tunnelError by viewModel.tunnelManager.errorEvents.collectAsStateWithLifecycle(null)

            val navController = rememberNavController()
            val backStackEntry by navController.currentBackStackEntryAsState()
@@ -150,15 +168,6 @@ class MainActivity : AppCompatActivity() {
                    viewModel.handleEvent(AppEvent.SetBatteryOptimizeDisableShown)
                }

-            LaunchedEffect(tunnelError) {
-                if (tunnelError == null) return@LaunchedEffect
-                val message = tunnelError!!.second.toStringRes()
-                val context = this@MainActivity
-                snackbar.showSnackbar(
-                    context.getString(R.string.tunnel_error_template, context.getString(message))
-                )
-            }
-
            with(appViewState) {
                LaunchedEffect(isConfigChanged) {
                    if (isConfigChanged) {
@@ -259,13 +268,13 @@ class MainActivity : AppCompatActivity() {
                                        MainScreen(appUiState, appViewState, viewModel)
                                    }
                                    composable<Route.Settings> {
-                                        SettingsScreen(appUiState, viewModel)
+                                        SettingsScreen(appUiState, appViewState, viewModel)
                                    }
                                    composable<Route.SettingsAdvanced> {
                                        SettingsAdvancedScreen(appUiState, viewModel)
                                    }
                                    composable<Route.LocationDisclosure> {
-                                        LocationDisclosureScreen(appUiState, viewModel)
+                                        LocationDisclosureScreen(viewModel)
                                    }
                                    composable<Route.AutoTunnel> {
                                        AutoTunnelScreen(appUiState, viewModel)
@@ -284,6 +293,9 @@ class MainActivity : AppCompatActivity() {
                                    composable<Route.AutoTunnelAdvanced> {
                                        AutoTunnelAdvancedScreen(appUiState, viewModel)
                                    }
+                                    composable<Route.WifiDetectionMethod> {
+                                        WifiDetectionMethodScreen(appUiState, viewModel)
+                                    }
                                    composable<Route.Logs> { LogsScreen(appViewState, viewModel) }
                                    composable<Route.Config> { backStack ->
                                        val args = backStack.toRoute<Route.Config>()
@@ -296,7 +308,12 @@ class MainActivity : AppCompatActivity() {
                                        appUiState.tunnels
                                            .firstOrNull { it.id == args.id }
                                            ?.let { config ->
-                                                TunnelOptionsScreen(config, viewModel, appViewState)
+                                                TunnelOptionsScreen(
+                                                    config,
+                                                    viewModel,
+                                                    appViewState,
+                                                    appUiState.appSettings,
+                                                )
                                            }
                                    }
                                    composable<Route.Lock> { PinLockScreen(viewModel) }
@@ -316,6 +333,10 @@ class MainActivity : AppCompatActivity() {
                                                )
                                            }
                                    }
+                                    composable<Route.Sort> { SortScreen(appUiState, viewModel) }
+                                    composable<Route.TunnelMonitoring> {
+                                        TunnelMonitoringScreen(appUiState, viewModel)
+                                    }
                                }
                            }
                        }
@@ -327,19 +348,61 @@ class MainActivity : AppCompatActivity() {

    override fun onResume() {
        super.onResume()
-        checkPermissionAndNotify()
+        WireGuardAutoTunnel.setUiActive(true)
+        networkMonitor.checkPermissionsAndUpdateState()
    }

-    private fun checkPermissionAndNotify() {
-        val hasLocation =
-            ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) ==
-                PackageManager.PERMISSION_GRANTED
-        if (lastLocationPermissionState != hasLocation) {
-            Timber.d("Location permission changed to: $hasLocation")
-            if (hasLocation) {
-                networkMonitor.sendLocationPermissionsGrantedBroadcast()
-            }
-            lastLocationPermissionState = hasLocation
-        }
+    override fun onPause() {
+        super.onPause()
+        WireGuardAutoTunnel.setUiActive(false)
    }
+
+    fun performBackup() =
+        lifecycleScope.launch(ioDispatcher) {
+            roomBackup
+                .database(appDatabase)
+                .backupLocation(RoomBackup.BACKUP_FILE_LOCATION_CUSTOM_DIALOG)
+                .enableLogDebug(true)
+                .maxFileCount(5)
+                .apply {
+                    onCompleteListener { success, message, exitCode ->
+                        lifecycleScope.launch(mainDispatcher) {
+                            if (success) {
+                                showToast(
+                                    getString(
+                                        R.string.backup_success,
+                                        getString(R.string.restarting_app),
+                                    )
+                                )
+                                restartApp()
+                            } else showToast(R.string.backup_failed)
+                        }
+                    }
+                }
+                .backup()
+        }
+
+    fun performRestore() =
+        lifecycleScope.launch {
+            roomBackup
+                .database(appDatabase)
+                .enableLogDebug(true)
+                .backupLocation(RoomBackup.BACKUP_FILE_LOCATION_CUSTOM_DIALOG)
+                .apply {
+                    onCompleteListener { success, message, exitCode ->
+                        lifecycleScope.launch(mainDispatcher) {
+                            if (success) {
+                                showToast(
+                                    getString(
+                                        R.string.restore_success,
+                                        getString(R.string.restarting_app),
+                                    )
+                                )
+                                restartApp()
+                            } else showToast(R.string.restore_failed)
+                        }
+                    }
+                }
+                .restore()
+        }
 }
@@ -4,12 +4,10 @@ import android.app.Application
 import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
 import androidx.hilt.work.HiltWorkerFactory
-import androidx.lifecycle.DefaultLifecycleObserver
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.work.Configuration
 import com.wireguard.android.backend.GoBackend
 import com.zaneschepke.logcatter.LogReader
+import com.zaneschepke.wireguardautotunnel.core.notification.NotificationMonitor
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.core.worker.ServiceWorker
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
@@ -21,10 +19,10 @@ import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
 import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
 import dagger.hilt.android.HiltAndroidApp
 import javax.inject.Inject
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
 import timber.log.Timber

@HiltAndroidApp
@@ -45,12 +43,13 @@ class WireGuardAutoTunnel : Application(), Configuration.Provider {

    @Inject @MainDispatcher lateinit var mainDispatcher: CoroutineDispatcher

+    @Inject lateinit var notificationMonitor: NotificationMonitor
+
    @Inject lateinit var tunnelManager: TunnelManager

    override fun onCreate() {
        super.onCreate()
        instance = this
-        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
        if (BuildConfig.DEBUG) {
            Timber.plant(Timber.DebugTree())
            StrictMode.setThreadPolicy(
@@ -80,6 +79,7 @@ class WireGuardAutoTunnel : Application(), Configuration.Provider {
        ServiceWorker.start(this)

        applicationScope.launch {
+            launch { notificationMonitor.handleApplicationNotifications() }
            appDataRepository.appState.getLocale()?.let {
                withContext(mainDispatcher) { LocaleUtil.changeLocale(it) }
            }
@@ -90,30 +90,20 @@ class WireGuardAutoTunnel : Application(), Configuration.Provider {
    }

    override fun onTerminate() {
-        applicationScope.launch {
-            tunnelManager.setBackendState(BackendState.INACTIVE, emptyList())
-        }
+        applicationScope.cancel()
+        tunnelManager.setBackendState(BackendState.INACTIVE, emptyList())
        super.onTerminate()
    }

-    class AppLifecycleObserver : DefaultLifecycleObserver {
-
-        override fun onStart(owner: LifecycleOwner) {
-            Timber.d("Application entered foreground")
-            foreground = true
-        }
-
-        override fun onPause(owner: LifecycleOwner) {
-            Timber.d("Application entered background")
-            foreground = false
-        }
-    }
-
    companion object {
-        private var foreground = false

-        fun isForeground(): Boolean {
-            return foreground
+        private val _uiActive = MutableStateFlow(false)
+
+        val uiActive: StateFlow<Boolean>
+            get() = _uiActive
+
+        fun setUiActive(active: Boolean) {
+            _uiActive.update { active }
        }

        @Volatile private var lastActiveTunnels: List<Int> = emptyList()
@@ -43,8 +43,14 @@ interface NotificationManager {
    fun show(notificationId: Int, notification: Notification)

    companion object {
+        const val AUTO_TUNNEL_LOCATION_PERMISSION_ID = 123
+        const val AUTO_TUNNEL_LOCATION_SERVICES_ID = 124
+        // For auto tunnel foreground notification
        const val AUTO_TUNNEL_NOTIFICATION_ID = 122
+        // for tunnel foreground notification
        const val VPN_NOTIFICATION_ID = 100
+        const val TUNNEL_ERROR_NOTIFICATION_ID = 101
+        const val TUNNEL_MESSAGES_NOTIFICATION_ID = 102
        const val EXTRA_ID = "id"
    }
 }
@@ -0,0 +1,63 @@
+package com.zaneschepke.wireguardautotunnel.core.notification
+
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+import jakarta.inject.Inject
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
+
+class NotificationMonitor
+@Inject
+constructor(
+    private val tunnelManager: TunnelManager,
+    private val notificationManager: NotificationManager,
+) {
+    suspend fun handleApplicationNotifications() = coroutineScope {
+        launch { handleTunnelErrors() }
+        launch { handleTunnelMessages() }
+    }
+
+    private suspend fun handleTunnelErrors() =
+        tunnelManager.errorEvents.collectLatest { (tunnelConf, error) ->
+            if (!WireGuardAutoTunnel.uiActive.value) {
+                val notification =
+                    notificationManager.createNotification(
+                        WireGuardNotification.NotificationChannels.VPN,
+                        title = StringValue.DynamicString(tunnelConf.name),
+                        description =
+                            when (error) {
+                                is BackendError.BounceFailed -> error.toStringValue()
+                                else ->
+                                    StringValue.StringResource(
+                                        R.string.tunnel_error_template,
+                                        error.toStringRes(),
+                                    )
+                            },
+                    )
+                notificationManager.show(
+                    NotificationManager.TUNNEL_ERROR_NOTIFICATION_ID,
+                    notification,
+                )
+            }
+        }
+
+    private suspend fun handleTunnelMessages() =
+        tunnelManager.messageEvents.collectLatest { (tunnelConf, message) ->
+            if (!WireGuardAutoTunnel.uiActive.value) {
+                val notification =
+                    notificationManager.createNotification(
+                        WireGuardNotification.NotificationChannels.VPN,
+                        title = StringValue.DynamicString(tunnelConf.name),
+                        description = message.toStringValue(),
+                    )
+                notificationManager.show(
+                    NotificationManager.TUNNEL_MESSAGES_NOTIFICATION_ID,
+                    notification,
+                )
+            }
+        }
+}
@@ -7,9 +7,6 @@ import android.content.ServiceConnection
 import android.net.VpnService
 import android.os.IBinder
 import com.zaneschepke.wireguardautotunnel.core.service.autotunnel.AutoTunnelService
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.di.MainDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.util.extensions.requestAutoTunnelTileServiceUpdate
 import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
@@ -29,9 +26,9 @@ class ServiceManager
@Inject
 constructor(
    private val context: Context,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-    @ApplicationScope private val applicationScope: CoroutineScope,
-    @MainDispatcher private val mainDispatcher: CoroutineDispatcher,
+    private val ioDispatcher: CoroutineDispatcher,
+    private val applicationScope: CoroutineScope,
+    private val mainDispatcher: CoroutineDispatcher,
    private val appDataRepository: AppDataRepository,
 ) {

@@ -96,6 +93,8 @@ constructor(
                service.stop()
                try {
                    context.unbindService(autoTunnelServiceConnection)
+                } catch (e: Exception) {
+                    Timber.e(e, "Failed to unbind AutoTunnelService")
                } finally {
                    _tunnelService.value = null
                }
@@ -120,6 +119,8 @@ constructor(
            service.stop()
            try {
                context.unbindService(tunnelServiceConnection)
+            } catch (e: Exception) {
+                Timber.e(e, "Failed to stop TunnelForegroundService")
            } finally {
                _tunnelService.value = null
            }
@@ -7,39 +7,24 @@ import android.os.IBinder
 import androidx.core.app.ServiceCompat
 import androidx.lifecycle.LifecycleService
 import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.networkmonitor.NetworkMonitor
-import com.zaneschepke.networkmonitor.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
-import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
-import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.extensions.distinctByKeys
 import dagger.hilt.android.AndroidEntryPoint
-import java.util.concurrent.ConcurrentHashMap
+import io.ktor.util.collections.*
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.NonCancellable
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
 import timber.log.Timber

@AndroidEntryPoint
@@ -49,23 +34,18 @@ class TunnelForegroundService : LifecycleService() {

    @Inject lateinit var serviceManager: ServiceManager

-    @Inject lateinit var networkMonitor: NetworkMonitor
+    @Inject lateinit var tunnelManager: TunnelManager
+
+    @Inject lateinit var tunnelMonitor: TunnelMonitor

    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher

-    @Inject lateinit var tunnelRepo: TunnelRepository
-
-    @Inject lateinit var tunnelManager: TunnelManager
-
-    private val isNetworkConnected = MutableStateFlow(true)
-
-    private val tunnelJobs = ConcurrentHashMap<TunnelConf, Job>()
-    private val pingJobs = ConcurrentHashMap<TunnelConf, Job>()
-
-    private val jobsMutex = Mutex()
+    @Inject lateinit var appDataRepository: AppDataRepository

    class LocalBinder(val service: TunnelForegroundService) : Binder()

+    private val tunnelJobs = ConcurrentMap<TunnelConf, Job>()
+
    private val binder = LocalBinder(this)

    override fun onCreate() {
@@ -98,94 +78,23 @@ class TunnelForegroundService : LifecycleService() {
    fun start() =
        lifecycleScope.launch(ioDispatcher) {
            tunnelManager.activeTunnels.distinctByKeys().collect { activeTunnels ->
-                // No active tunnels and no jobs: nothing to do
-                if (activeTunnels.isEmpty() && tunnelJobs.isEmpty()) return@collect
-
-                // Synchronize jobs with active tunnels
-                synchronizeJobs(activeTunnels)
-                updateServiceNotification()
-            }
-        }
-
-    private suspend fun synchronizeJobs(activeTunnels: Map<TunnelConf, TunnelState>) {
-        jobsMutex.withLock {
-            // Stop jobs for tunnels that are no longer active
-            stopInactiveJobs(activeTunnels)
-            // Start jobs for new tunnels
-            startNewJobs(activeTunnels)
-        }
-    }
-
-    private fun stopInactiveJobs(activeTunnels: Map<TunnelConf, TunnelState>) {
-        // If no active tunnels, clear all jobs
-        if (activeTunnels.isEmpty()) {
-            clearAllJobs()
-            return
-        }
-        // Stop jobs for tunnels not in activeTunnels
-        val tunnelsToStop = tunnelJobs.keys - activeTunnels.keys
-        tunnelsToStop.forEach { tun -> stopTunnelJobs(tun) }
-    }
-
-    private fun clearAllJobs() {
-        tunnelJobs.forEach { (tun, job) ->
-            Timber.d("Stopping tunnel job for ${tun.tunName}")
-            job.cancel()
-        }
-        tunnelJobs.clear()
-
-        pingJobs.forEach { (tun, job) ->
-            if (isPingBounce(tun)) {
-                Timber.d("Preserving ping job for ${tun.tunName} due to PING bounce")
-                return@forEach
-            }
-            Timber.d("Stopping ping job for ${tun.tunName}")
-            job.cancel()
-        }
-        pingJobs.entries.removeIf { (tun, _) -> !isPingBounce(tun) }
-    }
-
-    private fun stopTunnelJobs(tun: TunnelConf) {
-        tunnelJobs.remove(tun)?.cancel()
-        Timber.d("Stopped tunnel job for ${tun.tunName}")
-        if (isPingBounce(tun))
-            return Timber.d("Preserving ${tun.tunName} ping job due to ping bounce")
-        pingJobs.remove(tun)?.cancel()
-        Timber.d("Stopped ping job for ${tun.tunName}")
-    }
-
-    private fun startNewJobs(activeTunnels: Map<TunnelConf, TunnelState>) {
-        val tunnelsToStart = activeTunnels.keys - tunnelJobs.keys
-        tunnelsToStart.forEach { tun ->
-            tunnelJobs[tun] = startTunnelJobs(tun)
-            Timber.d("Started tunnel job for ${tun.tunName}")
-
-            if (pingJobs[tun]?.isActive == true) {
-                Timber.d("Reusing active ping job for ${tun.tunName}")
-            } else {
-                pingJobs[tun]?.cancel() // Cancel any stale job
-                if (tun.isPingEnabled) {
-                    if (tun.isStaticallyConfigured()) {
-                        Timber.d("Skipping ping for statically configured tunnel")
-                    } else {
-                        pingJobs[tun] = startPingJob(tun)
-                        Timber.d("Started ping job for ${tun.tunName}")
-                    }
+                val activeTunConfigs = activeTunnels.keys
+                val obsoleteJobs = tunnelJobs.keys - activeTunConfigs
+                obsoleteJobs.forEach { tunnelConf -> tunnelJobs[tunnelConf]?.cancel() }
+                activeTunConfigs.forEach { tun ->
+                    if (tunnelJobs.containsKey(tun)) return@forEach
+                    tunnelJobs[tun] = launch { tunnelMonitor.startMonitoring(tun, true) }
                }
+                updateServiceNotification(activeTunnels)
            }
        }
-    }
-
-    private fun isPingBounce(tun: TunnelConf): Boolean =
-        tunnelManager.bouncingTunnelIds[tun.id] == TunnelStatus.StopReason.PING

    // TODO Would be cool to have this include kill switch
-    // TODO also we need to include errors
-    private fun updateServiceNotification() {
+    private fun updateServiceNotification(activeTunnels: Map<TunnelConf, TunnelState>) {
        val notification =
-            when (tunnelJobs.size) {
+            when (activeTunnels.size) {
                0 -> onCreateNotification()
-                1 -> createTunnelNotification(tunnelJobs.keys.first())
+                1 -> createTunnelNotification(activeTunnels.keys.first())
                else -> createTunnelsNotification()
            }
        ServiceCompat.startForeground(
@@ -196,91 +105,18 @@ class TunnelForegroundService : LifecycleService() {
        )
    }

-    // use same scope so we can cancel all of these
-    private fun startTunnelJobs(tunnelConf: TunnelConf) =
-        lifecycleScope.launch(ioDispatcher) {
-            // monitor if we have internet connectivity
-            launch { startNetworkMonitorJob() }
-            // job to trigger stats emit on interval
-            launch { startTunnelStatsJob(tunnelConf) }
-            // monitor changes to the tunnel config
-            launch { startTunnelConfChangesJob(tunnelConf) }
-        }
-
-    private suspend fun startTunnelConfChangesJob(tunnelConf: TunnelConf) {
-        tunnelRepo.flow
-            .flowOn(ioDispatcher)
-            .map { storedTunnels -> storedTunnels.firstOrNull { it.id == tunnelConf.id } }
-            .filterNotNull()
-            // only emit when one of these 3 values change
-            .distinctUntilChanged { old, new -> old == new }
-            .collect { storedTunnel ->
-                if (tunnelConf != storedTunnel) {
-                    Timber.d("Config changed for ${storedTunnel.tunName}, bouncing")
-                    // let this complete, even after cancel
-                    withContext(NonCancellable) {
-                        tunnelManager.bounceTunnel(
-                            storedTunnel,
-                            TunnelStatus.StopReason.CONFIG_CHANGED,
-                        )
-                    }
-                }
-            }
-    }
-
-    private suspend fun startNetworkMonitorJob() {
-        networkMonitor.networkStatusFlow.flowOn(ioDispatcher).collectLatest { status ->
-            val isAvailable = status !is NetworkStatus.Disconnected
-            isNetworkConnected.value = isAvailable
-            Timber.d("Network available: $status")
-        }
-    }
-
-    private suspend fun startTunnelStatsJob(tunnel: TunnelConf) = coroutineScope {
-        while (isActive) {
-            tunnelManager.updateTunnelStatistics(tunnel)
-            delay(STATS_DELAY)
-        }
-    }
-
-    private fun startPingJob(tunnel: TunnelConf) =
-        lifecycleScope.launch(ioDispatcher) {
-            // delay for initial duration
-            delay(tunnel.pingInterval ?: Constants.PING_INTERVAL)
-            while (isActive) {
-                val shouldBounce = shouldBounceTunnel(tunnel)
-                val delayMs =
-                    if (shouldBounce) {
-                        // let this complete, even after cancel
-                        withContext(NonCancellable) {
-                            tunnelManager.bounceTunnel(tunnel, TunnelStatus.StopReason.PING)
-                        }
-                        tunnel.pingCooldown ?: Constants.PING_COOLDOWN
-                    } else {
-                        tunnel.pingInterval ?: Constants.PING_INTERVAL
-                    }
-                delay(delayMs)
-            }
-        }
-
-    private suspend fun shouldBounceTunnel(tunnel: TunnelConf): Boolean {
-        if (!isNetworkConnected.value) {
-            Timber.d("Network disconnected, skipping ping for ${tunnel.tunName}")
-            return false
-        }
-        return runCatching { !tunnel.isTunnelPingable(ioDispatcher) }
-            .onFailure { e -> Timber.e(e, "Ping check failed for ${tunnel.tunName}") }
-            .getOrDefault(true)
-    }
-
    fun stop() {
+        Timber.d("Stop called")
+        tunnelJobs.forEach { it.value.cancel() }
        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
        stopSelf()
    }

    override fun onDestroy() {
+        tunnelJobs.forEach { it.value.cancel() }
        serviceManager.handleTunnelServiceDestroy()
        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        Timber.d("onDestroy")
        super.onDestroy()
    }

@@ -315,14 +151,4 @@ class TunnelForegroundService : LifecycleService() {
            title = getString(R.string.tunnel_starting),
        )
    }
-
-    // TODO add notification handling and optional log reading for restart on handshake failures
-    companion object {
-        const val STATS_DELAY = 1_000L
-        // ipv6 disabled or block on network
-        // Failed to send handshake initiation: write udp [::]"
-        // Failed to send data packets: write udp [::]
-        // Failed to send data packets: write udp 0.0.0.0:51820
-        // Handshake did not complete after 5 seconds, retrying
-    }
 }
@@ -3,47 +3,39 @@ package com.zaneschepke.wireguardautotunnel.core.service.autotunnel
 import android.content.Intent
 import android.os.Binder
 import android.os.IBinder
-import android.os.PowerManager
 import androidx.core.app.ServiceCompat
 import androidx.lifecycle.LifecycleService
 import androidx.lifecycle.lifecycleScope
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
+import com.zaneschepke.networkmonitor.ConnectivityState
 import com.zaneschepke.networkmonitor.NetworkMonitor
-import com.zaneschepke.networkmonitor.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus.StopReason.Ping
 import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent
-import com.zaneschepke.wireguardautotunnel.domain.events.KillSwitchEvent
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.AutoTunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
+import com.zaneschepke.wireguardautotunnel.util.extensions.toMillis
 import dagger.hilt.android.AndroidEntryPoint
 import javax.inject.Inject
 import javax.inject.Provider
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
+import kotlin.math.pow
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import timber.log.Timber

@AndroidEntryPoint
@@ -61,13 +53,19 @@ class AutoTunnelService : LifecycleService() {

    @Inject lateinit var tunnelManager: TunnelManager

+    @Inject lateinit var tunnelMonitor: TunnelMonitor
+
    private val defaultState = AutoTunnelState()

+    private val autoTunMutex = Mutex()
+
    private val autoTunnelStateFlow = MutableStateFlow(defaultState)

-    private var wakeLock: PowerManager.WakeLock? = null
+    private val bounceCounts = MutableStateFlow<Map<Int, Int>>(emptyMap())

-    private var killSwitchJob: Job? = null
+    private var eventHandlerJob: Job? = null
+
+    private val lastBounceTimes = mutableMapOf<Int, Long>()

    class LocalBinder(val service: AutoTunnelService) : Binder()

@@ -91,25 +89,19 @@ class AutoTunnelService : LifecycleService() {
    }

    fun start() {
-        kotlin
-            .runCatching {
-                launchWatcherNotification()
-                initWakeLock()
-                startAutoTunnelJob()
-                startAutoTunnelStateJob()
-                killSwitchJob = startKillSwitchJob()
-            }
-            .onFailure { Timber.e(it) }
+        launchWatcherNotification()
+        startAutoTunnelStateJob()
+        startLocationPermissionsNotificationJob()
    }

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

    override fun onDestroy() {
        serviceManager.handleAutoTunnelServiceDestroy()
        restoreVpnKillSwitch()
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
        super.onDestroy()
    }

@@ -119,7 +111,7 @@ class AutoTunnelService : LifecycleService() {
                settings.isVpnKillSwitchEnabled &&
                    tunnelManager.getBackendState() != BackendState.KILL_SWITCH_ACTIVE
            ) {
-                killSwitchJob?.cancel()
+                eventHandlerJob?.cancel()
                val allowedIps =
                    if (settings.isLanOnKillSwitchEnabled) TunnelConf.LAN_BYPASS_ALLOWED_IPS
                    else emptyList()
@@ -151,80 +143,141 @@ class AutoTunnelService : LifecycleService() {
        )
    }

-    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()
-                    }
-                }
-            }
-    }
-
-    private fun buildNetworkState(networkStatus: NetworkStatus): NetworkState {
-        return with(autoTunnelStateFlow.value.networkState) {
-            val wifiName =
-                when (networkStatus) {
-                    is NetworkStatus.Connected -> {
-                        networkStatus.wifiSsid
-                    }
-                    else -> null
-                }
-            copy(
-                isWifiConnected = networkStatus.wifiConnected,
-                isMobileDataConnected = networkStatus.cellularConnected,
-                isEthernetConnected = networkStatus.ethernetConnected,
-                wifiName = wifiName,
-            )
-        }
-    }
-
-    @OptIn(ExperimentalCoroutinesApi::class)
    private fun startAutoTunnelStateJob() =
        lifecycleScope.launch(ioDispatcher) {
-            combine(
-                    combineSettings(),
-                    appDataRepository
-                        .get()
-                        .settings
-                        .flow
-                        .distinctUntilChanged { old, new ->
-                            old.isKernelEnabled == new.isKernelEnabled
-                        } // Only emit when isKernelEnabled changes
-                        .flatMapLatest {
-                            networkMonitor.networkStatusFlow.flowOn(ioDispatcher).map {
-                                buildNetworkState(it)
-                            }
-                        }
-                        .distinctUntilChanged(),
-                ) { double, networkState ->
-                    AutoTunnelState(
-                        tunnelManager.activeTunnels.value,
-                        networkState,
-                        double.first,
-                        double.second,
-                    )
-                }
-                .collect { state ->
+            val networkFlow =
+                debouncedConnectivityStateFlow
+                    .flowOn(ioDispatcher)
+                    .map(NetworkState::from)
+                    .map { StateChange.NetworkChange(it) }
+                    .distinctUntilChanged()
+
+            val settingsFlow =
+                combineSettings().map { StateChange.SettingsChange(it.first, it.second) }
+
+            val tunnelsFlow =
+                tunnelManager.activeTunnels.map { StateChange.ActiveTunnelsChange(it) }
+
+            val monitoringFlow =
+                tunnelManager.activeTunnels
+                    .map { map -> map.mapValues { (_, state) -> state.pingStates } }
+                    .distinctUntilChanged()
+                    .map { StateChange.MonitoringChange(it) }
+
+            var reevaluationJob: Job? = null
+
+            // get everything in sync before we use merge
+            combine(networkFlow, settingsFlow, tunnelsFlow, monitoringFlow) {
+                    network,
+                    settings,
+                    tunnels,
+                    monitoring ->
                    autoTunnelStateFlow.update {
                        it.copy(
-                            activeTunnels = state.activeTunnels,
-                            networkState = state.networkState,
-                            settings = state.settings,
-                            tunnels = state.tunnels,
+                            activeTunnels = tunnels.activeTunnels,
+                            networkState = network.networkState,
+                            settings = settings.settings,
+                            tunnels = settings.tunnels,
                        )
                    }
                }
+                .first()
+
+            // use merge to limit the noise of a combine and also increase the scalability of auto
+            // tunnel handling new states
+            merge(networkFlow, settingsFlow, tunnelsFlow, monitoringFlow).collect { change ->
+                if (change !is StateChange.ActiveTunnelsChange) {
+                    Timber.d("New state changed to ${change.javaClass.simpleName}")
+                }
+
+                when (change) {
+                    is StateChange.NetworkChange -> {
+                        reevaluationJob?.cancel()
+                        val previousState = autoTunnelStateFlow.value
+                        autoTunnelStateFlow.update { it.copy(networkState = change.networkState) }
+                        // Android late mobile data state change, we can ignore handling this
+                        if (
+                            isAndroidLateCellularActiveChange(
+                                previousState.networkState,
+                                change.networkState,
+                            )
+                        ) {
+                            Timber.d("Android late cellular active state change")
+                            return@collect
+                        }
+                    }
+                    is StateChange.SettingsChange -> {
+                        reevaluationJob?.cancel()
+                        autoTunnelStateFlow.update {
+                            it.copy(settings = change.settings, tunnels = change.tunnels)
+                        }
+                    }
+                    is StateChange.ActiveTunnelsChange -> {
+                        autoTunnelStateFlow.update { it.copy(activeTunnels = change.activeTunnels) }
+                        return@collect
+                    }
+                    is StateChange.MonitoringChange -> {
+                        change.pingStates.forEach { (config, pingState) ->
+                            Timber.d("Ping state $pingState")
+                            if (pingState?.all { it.value.isReachable } == true) {
+                                Timber.d("Clearing bounce count on success")
+                                bounceCounts.update { current ->
+                                    current.toMutableMap().apply { remove(config.id) }
+                                }
+                            }
+                        }
+                        return@collect handleAutoTunnelEvent(
+                            autoTunnelStateFlow.value.determineAutoTunnelEvent(
+                                StateChange.MonitoringChange(change.pingStates)
+                            )
+                        )
+                    }
+                }
+
+                handleAutoTunnelEvent(autoTunnelStateFlow.value.determineAutoTunnelEvent(change))
+
+                reevaluationJob = launch {
+                    delay(REEVALUATE_CHECK_DELAY)
+                    val currentState = autoTunnelStateFlow.value
+                    if (currentState != defaultState) {
+                        Timber.d("Re-evaluating auto-tunnel state..")
+                        handleAutoTunnelEvent(currentState.determineAutoTunnelEvent(change))
+                    }
+                }
+            }
        }

+    private fun isAndroidLateCellularActiveChange(
+        previous: NetworkState,
+        new: NetworkState,
+    ): Boolean {
+        return (previous.isWifiConnected != new.isWifiConnected &&
+            previous.wifiName == new.wifiName &&
+            previous.isMobileDataConnected != new.isMobileDataConnected)
+    }
+
+    // all relevant settings to auto tunnel
+    private fun areAutoTunnelSettingsTheSame(old: AppSettings, new: AppSettings): Boolean {
+        return (old.isTunnelOnWifiEnabled == new.isTunnelOnWifiEnabled &&
+            old.isTunnelOnMobileDataEnabled == new.isTunnelOnMobileDataEnabled &&
+            old.isTunnelOnEthernetEnabled == new.isTunnelOnEthernetEnabled &&
+            old.trustedNetworkSSIDs == new.trustedNetworkSSIDs &&
+            old.isPingEnabled == new.isPingEnabled &&
+            old.debounceDelaySeconds == new.debounceDelaySeconds &&
+            old.wifiDetectionMethod == new.wifiDetectionMethod &&
+            old.isVpnKillSwitchEnabled == new.isVpnKillSwitchEnabled &&
+            old.isLanOnKillSwitchEnabled == new.isLanOnKillSwitchEnabled &&
+            old.isDisableKillSwitchOnTrustedEnabled == new.isDisableKillSwitchOnTrustedEnabled &&
+            old.isStopOnNoInternetEnabled == new.isStopOnNoInternetEnabled)
+    }
+
    private fun combineSettings(): Flow<Pair<AppSettings, Tunnels>> {
        return combine(
-                appDataRepository.get().settings.flow,
+                appDataRepository
+                    .get()
+                    .settings
+                    .flow
+                    .distinctUntilChanged(::areAutoTunnelSettingsTheSame),
                appDataRepository.get().tunnels.flow.map { tunnels ->
                    // isActive is ignored for equality checks so user can manually toggle off
                    // tunnel with auto-tunnel
@@ -236,70 +289,174 @@ class AutoTunnelService : LifecycleService() {
            .distinctUntilChanged()
    }

-    private fun startKillSwitchJob() =
+    private fun areAutoTunnelPermissionsRequiredTheSame(
+        old: AutoTunnelState,
+        new: AutoTunnelState,
+    ): Boolean {
+        return (old.settings.wifiDetectionMethod == new.settings.wifiDetectionMethod &&
+            old.networkState.locationPermissionGranted ==
+                new.networkState.locationPermissionGranted &&
+            old.networkState.locationServicesEnabled == new.networkState.locationServicesEnabled &&
+            old.tunnels == new.tunnels &&
+            old.settings.trustedNetworkSSIDs == new.settings.trustedNetworkSSIDs)
+    }
+
+    //     watch for changes to location permission and notify user it will impact auto-tunneling
+    //     TODO or a recheck button for location permission so we dont have to poll it
+    private fun startLocationPermissionsNotificationJob(): Job =
        lifecycleScope.launch(ioDispatcher) {
-            autoTunnelStateFlow.collect {
-                if (it == defaultState) return@collect
-                when (val event = it.asKillSwitchEvent()) {
-                    KillSwitchEvent.DoNothing -> Unit
-                    is KillSwitchEvent.Start -> {
-                        Timber.d("Starting kill switch")
-                        tunnelManager.setBackendState(
-                            BackendState.KILL_SWITCH_ACTIVE,
-                            event.allowedIps,
-                        )
+            var locationServicesShown = false
+            var locationPermissionsShown = false
+
+            data class NetworkPermissionState(
+                val detectionMethod: AndroidNetworkMonitor.WifiDetectionMethod,
+                val locationServicesEnabled: Boolean,
+                val locationPermissionsEnabled: Boolean,
+                val ssidReadRequired: Boolean,
+            )
+
+            autoTunnelStateFlow
+                .distinctUntilChanged(::areAutoTunnelPermissionsRequiredTheSame)
+                .map {
+                    NetworkPermissionState(
+                        it.settings.wifiDetectionMethod,
+                        it.networkState.locationServicesEnabled == true,
+                        it.networkState.locationPermissionGranted == true,
+                        (it.tunnels.any { tunnel -> tunnel.tunnelNetworks.isNotEmpty() } ||
+                            it.settings.trustedNetworkSSIDs.isNotEmpty()),
+                    )
+                }
+                .collect { state ->
+                    when (state.detectionMethod) {
+                        AndroidNetworkMonitor.WifiDetectionMethod.DEFAULT,
+                        AndroidNetworkMonitor.WifiDetectionMethod.LEGACY -> {
+                            if (
+                                !state.locationPermissionsEnabled &&
+                                    !locationPermissionsShown &&
+                                    state.ssidReadRequired
+                            ) {
+                                locationPermissionsShown = true
+                                val notification =
+                                    notificationManager.createNotification(
+                                        WireGuardNotification.NotificationChannels.AUTO_TUNNEL,
+                                        title = getString(R.string.warning),
+                                        description =
+                                            getString(R.string.location_permissions_missing),
+                                    )
+                                notificationManager.show(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_PERMISSION_ID,
+                                    notification,
+                                )
+                            }
+                            if (
+                                !state.locationServicesEnabled &&
+                                    !locationServicesShown &&
+                                    state.ssidReadRequired
+                            ) {
+                                locationServicesShown = true
+                                val notification =
+                                    notificationManager.createNotification(
+                                        WireGuardNotification.NotificationChannels.AUTO_TUNNEL,
+                                        title = getString(R.string.warning),
+                                        description =
+                                            getString(R.string.location_services_not_detected),
+                                    )
+                                notificationManager.show(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_SERVICES_ID,
+                                    notification,
+                                )
+                            }
+                            if (state.locationServicesEnabled || !state.ssidReadRequired) {
+                                notificationManager.remove(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_SERVICES_ID
+                                )
+                                locationServicesShown = false
+                            }
+                            if (state.locationPermissionsEnabled || !state.ssidReadRequired) {
+                                notificationManager.remove(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_PERMISSION_ID
+                                )
+                                locationPermissionsShown = false
+                            }
+                        }
+                        else -> Unit
                    }
-                    KillSwitchEvent.Stop -> {
-                        Timber.d("Stopping kill switch")
-                        tunnelManager.setBackendState(BackendState.SERVICE_ACTIVE, emptySet())
+                }
+        }
+
+    private suspend fun handleAutoTunnelEvent(autoTunnelEvent: AutoTunnelEvent) {
+        autoTunMutex.withLock {
+            when (
+                val event =
+                    autoTunnelEvent.also {
+                        Timber.i("Auto tunnel event: ${it.javaClass.simpleName}")
                    }
+            ) {
+                is AutoTunnelEvent.Start ->
+                    (event.tunnelConf ?: appDataRepository.get().getPrimaryOrFirstTunnel())?.let {
+                        tunnelManager.startTunnel(it)
+                    }
+                is AutoTunnelEvent.Stop -> tunnelManager.stopTunnel()
+                AutoTunnelEvent.DoNothing -> Timber.i("Auto-tunneling: nothing to do")
+                is AutoTunnelEvent.Bounce ->
+                    handleBounceWithBackoff(event.configsPeerKeyResolvedMap)
+                is AutoTunnelEvent.StartKillSwitch -> {
+                    Timber.d("Starting kill switch")
+                    tunnelManager.setBackendState(BackendState.KILL_SWITCH_ACTIVE, event.allowedIps)
+                }
+                AutoTunnelEvent.StopKillSwitch -> {
+                    Timber.d("Stopping kill switch")
+                    tunnelManager.setBackendState(BackendState.SERVICE_ACTIVE, emptySet())
                }
            }
        }
+    }

-    @OptIn(FlowPreview::class)
-    private fun startAutoTunnelJob() =
-        lifecycleScope.launch(ioDispatcher) {
-            Timber.i("Starting auto-tunnel network event watcher")
-            val settings = appDataRepository.get().settings.get()
-
-            var reevaluationJob: Job? = null
-
-            autoTunnelStateFlow.debounce(settings.debounceDelayMillis()).collect { watcherState ->
-                if (watcherState == defaultState) return@collect
-                reevaluationJob?.cancel()
-                handleAutoTunnelEvent(watcherState)
-
-                // schedule one-time re-evaluation
-                reevaluationJob = launch {
-                    delay(REEVALUATE_CHECK_DELAY)
-                    if (watcherState != defaultState) {
-                        Timber.d("Re-evaluating auto-tunnel state..")
-                        handleAutoTunnelEvent(watcherState)
-                    }
+    private suspend fun handleBounceWithBackoff(
+        configsPeerKeyResolvedMap: List<Pair<TunnelConf, Map<String, String?>>>
+    ) { // Simplified param: no failureCount
+        val settings = appDataRepository.get().settings.get()
+        val pingIntervalMillis = settings.tunnelPingIntervalSeconds.toMillis()
+        configsPeerKeyResolvedMap.forEach { (config, peerMap) ->
+            val bounceCount = bounceCounts.value.getOrDefault(config.id, 0)
+            val exponent = bounceCount.toDouble()
+            val backoffDelay =
+                (pingIntervalMillis * 2.0.pow(exponent)).toLong().coerceAtMost(MAX_BACKOFF_MS)
+            val currentTime = System.currentTimeMillis()
+            val lastTime = lastBounceTimes.getOrDefault(config.id, 0L)
+            if (currentTime - lastTime >= backoffDelay) {
+                Timber.d(
+                    "Bouncing tunnel ${config.name} after detecting failure, with bounce count $bounceCount and calculated backoff delay $backoffDelay ms"
+                )
+                tunnelManager.bounceTunnel(config, Ping(peerMap))
+                lastBounceTimes[config.id] = currentTime
+                bounceCounts.update { current ->
+                    current.toMutableMap().apply { this[config.id] = (this[config.id] ?: 0) + 1 }
                }
+            } else {
+                Timber.d(
+                    "Backoff in progress for tunnel ${config.name}, skipping bounce (required delay: $backoffDelay ms)"
+                )
            }
        }
+    }

-    private suspend fun handleAutoTunnelEvent(watcherState: AutoTunnelState) {
-        Timber.i("Auto-tunnel settings: ${watcherState.settings.toAutoTunnelStateString()}")
-        Timber.i("Auto-tunnel network state: ${watcherState.networkState}")
-        when (
-            val event =
-                watcherState.asAutoTunnelEvent().also {
-                    Timber.i("Auto-tunnel event: ${it.javaClass.simpleName}")
-                }
-        ) {
-            is AutoTunnelEvent.Start ->
-                (event.tunnelConf ?: appDataRepository.get().getPrimaryOrFirstTunnel())?.let {
-                    tunnelManager.startTunnel(it)
-                }
-            is AutoTunnelEvent.Stop -> tunnelManager.stopTunnel()
-            AutoTunnelEvent.DoNothing -> Timber.i("Auto-tunneling: nothing to do")
-        }
+    @OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
+    private val debouncedConnectivityStateFlow: Flow<ConnectivityState> by lazy {
+        appDataRepository
+            .get()
+            .settings
+            .flow
+            .map { it.debounceDelaySeconds.toMillis() }
+            .distinctUntilChanged()
+            .flatMapLatest { debounceMillis ->
+                networkMonitor.connectivityStateFlow.debounce(debounceMillis)
+            }
    }

    companion object {
-        const val REEVALUATE_CHECK_DELAY = 5_000L
+        // try to keep this window short as it will interrupt manual overrides
+        const val REEVALUATE_CHECK_DELAY = 2_000L
+        const val MAX_BACKOFF_MS = 300_000L // 5 minutes
    }
 }
@@ -0,0 +1,20 @@
+package com.zaneschepke.wireguardautotunnel.core.service.autotunnel
+
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
+import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
+import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
+import org.amnezia.awg.crypto.Key
+
+sealed class StateChange {
+    data class NetworkChange(val networkState: NetworkState) : StateChange()
+
+    data class SettingsChange(val settings: AppSettings, val tunnels: Tunnels) : StateChange()
+
+    data class ActiveTunnelsChange(val activeTunnels: Map<TunnelConf, TunnelState>) : StateChange()
+
+    data class MonitoringChange(val pingStates: Map<TunnelConf, Map<Key, PingState>?>) :
+        StateChange()
+}
@@ -13,7 +13,7 @@ import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import dagger.hilt.android.AndroidEntryPoint
@@ -2,37 +2,42 @@ package com.zaneschepke.wireguardautotunnel.core.tunnel

 import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
-import com.zaneschepke.wireguardautotunnel.domain.enums.BackendError
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
+import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
 import com.zaneschepke.wireguardautotunnel.util.extensions.asTunnelState
 import java.util.concurrent.ConcurrentHashMap
-import kotlin.concurrent.thread
+import kotlin.coroutines.cancellation.CancellationException
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import org.amnezia.awg.crypto.Key
 import timber.log.Timber

 abstract class BaseTunnel(
-    @ApplicationScope private val applicationScope: CoroutineScope,
+    private val applicationScope: CoroutineScope,
    private val appDataRepository: AppDataRepository,
    private val serviceManager: ServiceManager,
 ) : TunnelProvider {

-    private val _errorEvents =
-        MutableSharedFlow<Pair<TunnelConf, BackendError>>(replay = 0, extraBufferCapacity = 1)
+    private val _errorEvents = MutableSharedFlow<Pair<TunnelConf, BackendError>>()
    override val errorEvents = _errorEvents.asSharedFlow()

+    private val _messageEvents = MutableSharedFlow<Pair<TunnelConf, BackendMessage>>()
+    override val messageEvents = _messageEvents.asSharedFlow()
+
    private val activeTuns = MutableStateFlow<Map<TunnelConf, TunnelState>>(emptyMap())
-    private val tunThreads = ConcurrentHashMap<Int, Thread>()
+    private val tunJobs = ConcurrentHashMap<Int, Job>()
    override val activeTunnels = activeTuns.asStateFlow()

    private val tunMutex = Mutex()
@@ -49,32 +54,43 @@ abstract class BaseTunnel(
        return serviceManager.hasVpnPermission()
    }

-    protected suspend fun updateTunnelStatus(
+    override suspend fun updateTunnelStatus(
        tunnelConf: TunnelConf,
-        status: TunnelStatus? = null,
-        stats: TunnelStatistics? = null,
+        status: TunnelStatus?,
+        stats: TunnelStatistics?,
+        pingStates: Map<Key, PingState>?,
+        handshakeSuccessLogs: Boolean?,
    ) {
        tunStatusMutex.withLock {
            activeTuns.update { currentTuns ->
                val originalConf = currentTuns.getKeyById(tunnelConf.id) ?: tunnelConf
                val existingState = currentTuns.getValueById(tunnelConf.id) ?: TunnelState()
-                val newState = status ?: existingState.status
-                if (newState == TunnelStatus.Down) {
+                val newStatus = status ?: existingState.status
+                if (newStatus == TunnelStatus.Down) {
                    Timber.d("Removing tunnel ${tunnelConf.id} from activeTunnels as state is DOWN")
-                    cleanUpTunThread(tunnelConf)
+                    cleanUpTunJob(tunnelConf)
                    currentTuns - originalConf
-                } else if (existingState.status == newState && stats == null) {
-                    Timber.d("Skipping redundant state update for ${tunnelConf.id}: $newState")
+                } else if (
+                    existingState.status == newStatus &&
+                        stats == null &&
+                        pingStates == null &&
+                        handshakeSuccessLogs == null
+                ) {
+                    Timber.d("Skipping redundant state update for ${tunnelConf.id}: $newStatus")
                    currentTuns
                } else {
                    val updated =
                        existingState.copy(
-                            status = newState,
+                            status = newStatus,
                            statistics = stats ?: existingState.statistics,
+                            pingStates = pingStates ?: existingState.pingStates,
+                            handshakeSuccessLogs =
+                                handshakeSuccessLogs ?: existingState.handshakeSuccessLogs,
                        )
                    currentTuns + (originalConf to updated)
                }
            }
+            handleServiceStateOnChange()
        }
    }

@@ -104,44 +120,100 @@ abstract class BaseTunnel(
        }
    }

-    override suspend fun updateTunnelStatistics(tunnel: TunnelConf) {
-        val stats = getStatistics(tunnel)
-        updateTunnelStatus(tunnel, null, stats)
-    }
-
    override suspend fun startTunnel(tunnelConf: TunnelConf) {
-        if (activeTuns.exists(tunnelConf.id) || tunThreads.containsKey(tunnelConf.id)) return
+        if (activeTuns.exists(tunnelConf.id) || tunJobs.containsKey(tunnelConf.id))
+            return Timber.w("Tunnel is already running ${tunnelConf.name}")
+        // For userspace, we need to make sure all previous tunnels are down
        if (this@BaseTunnel is UserspaceTunnel) stopActiveTunnels()
        tunMutex.withLock {
-            tunThreads[tunnelConf.id] = thread {
-                try {
-                    runBlocking {
+            val job =
+                applicationScope.launch {
+                    try {
                        Timber.d("Starting tunnel ${tunnelConf.id}...")
                        startTunnelInner(tunnelConf)
                        Timber.d("Started complete for tunnel ${tunnelConf.name}...")
+                        // catch cancellation that could occur before and during startTunnelInner
+                        // and trigger at that suspend point
+                    } catch (e: CancellationException) {
+                        Timber.w(
+                            "Tunnel start has been cancelled as ${tunnelConf.name} failed to start"
+                        )
                    }
-                } catch (e: InterruptedException) {
-                    Timber.w(
-                        "Tunnel start has been interrupted as ${tunnelConf.name} failed to start"
-                    )
                }
+            tunJobs[tunnelConf.id] = job
+            job.invokeOnCompletion {
+                tunJobs.remove(tunnelConf.id)
+                Timber.d("Start job completed for tunnel ${tunnelConf.id}")
            }
        }
    }

    private suspend fun startTunnelInner(tunnelConf: TunnelConf) {
        configureTunnelCallbacks(tunnelConf)
-        Timber.d("Starting  backend for tunnel ${tunnelConf.id}...")
-        try {
-            startBackend(tunnelConf)
-            updateTunnelStatus(tunnelConf, TunnelStatus.Up)
-            Timber.d("Started for tun ${tunnelConf.id}...")
-            saveTunnelActiveState(tunnelConf, true)
-            serviceManager.startTunnelForegroundService()
-        } catch (e: BackendError) {
-            Timber.e(e, "Failed to start backend for ${tunnelConf.name}")
-            _errorEvents.emit(tunnelConf to e)
-            updateTunnelStatus(tunnelConf, TunnelStatus.Down)
+        Timber.d("Starting backend for tunnel ${tunnelConf.id}...")
+
+        var currentConf = tunnelConf
+        var restoreAttempted = false
+        var originalError: BackendError? = null
+
+        while (true) {
+            try {
+                startBackend(currentConf)
+                updateTunnelStatus(currentConf, TunnelStatus.Up)
+                Timber.d("Started for tun ${currentConf.id}...")
+                saveTunnelActiveState(currentConf, true)
+                serviceManager.startTunnelForegroundService()
+                if (restoreAttempted)
+                    _messageEvents.emit(tunnelConf to BackendMessage.BounceRecovery)
+                if (bouncingTunnelIds[currentConf.id] is TunnelStatus.StopReason.Ping) {
+                    _messageEvents.emit(tunnelConf to BackendMessage.BounceSuccess)
+                }
+                return // Success, return
+            } catch (e: BackendError) {
+                originalError = originalError ?: e
+                val bounceReason = bouncingTunnelIds[currentConf.id]
+                if (!restoreAttempted && bounceReason is TunnelStatus.StopReason.Ping) {
+                    Timber.i(
+                        "Attempting to recover bounce failure with previously resolved endpoints for ${currentConf.name}"
+                    )
+                    try {
+                        val previouslyResolved = bounceReason.previouslyResolvedEndpoints
+                        val configProxy = ConfigProxy.from(currentConf.toAmConfig())
+                        val updatedConfigProxy =
+                            configProxy.copy(
+                                peers =
+                                    configProxy.peers.map {
+                                        it.copy(
+                                            endpoint =
+                                                previouslyResolved[it.publicKey] ?: it.endpoint
+                                        )
+                                    }
+                            )
+                        val (wg, amnezia) = updatedConfigProxy.buildConfigs()
+                        currentConf =
+                            currentConf.copyWithCallback(
+                                amQuick = amnezia.toAwgQuickString(true),
+                                wgQuick = wg.toWgQuickString(true),
+                            )
+                        bouncingTunnelIds.remove(currentConf.id)
+                        restoreAttempted = true
+                        continue // Retry
+                    } catch (e: Exception) {
+                        Timber.e(
+                            e,
+                            "Failed to update config with resolved endpoints for ${currentConf.name}",
+                        )
+                        // Fall through to failure (will emit BounceFailed since
+                        // retryAttempted=true)
+                    }
+                }
+                Timber.e(e, "Failed to start backend for ${currentConf.name}")
+                val emitError =
+                    if (restoreAttempted) BackendError.BounceFailed(originalError) else e
+                _errorEvents.emit(currentConf to emitError)
+                updateTunnelStatus(currentConf, TunnelStatus.Down)
+                return
+            }
        }
    }

@@ -174,30 +246,23 @@ abstract class BaseTunnel(
    }

    private fun handleServiceStateOnChange() {
-        if (activeTuns.value.isEmpty() && bouncingTunnelIds.isEmpty())
-            serviceManager.stopTunnelForegroundService()
+        if (activeTuns.value.isEmpty()) serviceManager.stopTunnelForegroundService()
    }

    private suspend fun handleStuckStartingTunnelShutdown(tunnel: TunnelConf) {
-        Timber.d("Stuck in starting state so shutting down tunnel thread for tunnel ${tunnel.name}")
+        Timber.d("Stuck in starting state so cancelling job for tunnel ${tunnel.name}")
        try {
-            tunThreads[tunnel.id]?.let {
-                if (it.state != Thread.State.TERMINATED) {
-                    it.interrupt()
-                } else {
-                    Timber.d("Thread already terminated")
-                }
-            }
+            tunJobs[tunnel.id]?.cancel() ?: Timber.d("No job found for ${tunnel.name}")
        } catch (e: Exception) {
-            Timber.e(e, "Failed to stop tunnel thread for ${tunnel.name}")
+            Timber.e(e, "Failed to cancel job for ${tunnel.name}")
        } finally {
            updateTunnelStatus(tunnel, TunnelStatus.Down)
        }
    }

-    private fun cleanUpTunThread(tunnel: TunnelConf) {
-        Timber.d("Removing thread for ${tunnel.name}")
-        tunThreads -= tunnel.id
+    private fun cleanUpTunJob(tunnel: TunnelConf) {
+        Timber.d("Removing job for ${tunnel.name}")
+        tunJobs -= tunnel.id
    }

    private fun removeActiveTunnel(tunnelConf: TunnelConf) {
@@ -210,16 +275,10 @@ abstract class BaseTunnel(
                "Bounce tunnel ${tunnelConf.name} for reason: $reason, current bouncing: ${bouncingTunnelIds.size}"
            )
            bouncingTunnelIds[tunnelConf.id] = reason
-            try {
+            runCatching {
                stopTunnel(tunnelConf, reason)
                delay(BOUNCE_DELAY)
                startTunnel(tunnelConf)
-            } finally {
-                bouncingTunnelIds.remove(tunnelConf.id)
-                handleServiceStateOnChange()
-                Timber.d(
-                    "Cleared bounce state for ${tunnelConf.name}, remaining: ${bouncingTunnelIds.size}"
-                )
            }
        }
    }
@@ -1,7 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel

-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import kotlinx.coroutines.flow.MutableStateFlow

@@ -5,9 +5,10 @@ import com.wireguard.android.backend.BackendException
 import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.domain.state.WireGuardStatistics
@@ -35,11 +36,17 @@ constructor(
    }

    override suspend fun startBackend(tunnel: TunnelConf) {
+        // name too long for kernel mode
+        if (!tunnel.isNameKernelCompatible) throw BackendError.TunnelNameTooLong
        try {
            updateTunnelStatus(tunnel, TunnelStatus.Starting)
            backend.setState(tunnel, Tunnel.State.UP, tunnel.toWgConfig())
        } catch (e: BackendException) {
+            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
            throw e.toBackendError()
+        } catch (e: IllegalArgumentException) {
+            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
+            throw BackendError.Config
        }
    }

@@ -1,37 +1,32 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel

-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.di.Kernel
-import com.zaneschepke.wireguardautotunnel.di.Userspace
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
-import com.zaneschepke.wireguardautotunnel.domain.enums.BackendError
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
+import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
 import java.util.concurrent.ConcurrentHashMap
 import javax.inject.Inject
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.plus
+import org.amnezia.awg.crypto.Key

+@OptIn(ExperimentalCoroutinesApi::class)
 class TunnelManager
@Inject
 constructor(
-    @Kernel private val kernelTunnel: TunnelProvider,
-    @Userspace private val userspaceTunnel: TunnelProvider,
+    private val kernelTunnel: TunnelProvider,
+    private val userspaceTunnel: TunnelProvider,
    private val appDataRepository: AppDataRepository,
-    @ApplicationScope private val applicationScope: CoroutineScope,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    applicationScope: CoroutineScope,
+    ioDispatcher: CoroutineDispatcher,
 ) : TunnelProvider {

    @OptIn(ExperimentalCoroutinesApi::class)
@@ -47,25 +42,29 @@ constructor(
                initialValue = userspaceTunnel,
            )

+    override val activeTunnels: StateFlow<Map<TunnelConf, TunnelState>> =
+        tunnelProviderFlow.value.activeTunnels
+
    @OptIn(ExperimentalCoroutinesApi::class)
-    override val activeTunnels =
-        appDataRepository.settings.flow
-            .filterNotNull()
-            .flatMapLatest { settings ->
-                if (settings.isKernelEnabled) {
-                    kernelTunnel.activeTunnels
-                } else {
-                    userspaceTunnel.activeTunnels
-                }
-            }
-            .stateIn(
+    override val errorEvents: SharedFlow<Pair<TunnelConf, BackendError>> =
+        tunnelProviderFlow
+            .flatMapLatest { it.errorEvents }
+            .shareIn(
                scope = applicationScope.plus(ioDispatcher),
                started = SharingStarted.Eagerly,
-                initialValue = emptyMap(),
+                replay = 0,
            )

-    override val errorEvents: SharedFlow<Pair<TunnelConf, BackendError>>
-        get() = tunnelProviderFlow.value.errorEvents
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override val messageEvents: SharedFlow<Pair<TunnelConf, BackendMessage>> =
+        tunnelProviderFlow
+            .flatMapLatest { it.messageEvents }
+            .filterNotNull()
+            .shareIn(
+                scope = applicationScope.plus(ioDispatcher),
+                started = SharingStarted.Eagerly,
+                replay = 0,
+            )

    override val bouncingTunnelIds: ConcurrentHashMap<Int, TunnelStatus.StopReason> =
        tunnelProviderFlow.value.bouncingTunnelIds
@@ -74,8 +73,8 @@ constructor(
        return userspaceTunnel.hasVpnPermission()
    }

-    override suspend fun updateTunnelStatistics(tunnel: TunnelConf) {
-        tunnelProviderFlow.value.updateTunnelStatistics(tunnel)
+    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
+        return tunnelProviderFlow.value.getStatistics(tunnelConf)
    }

    override suspend fun startTunnel(tunnelConf: TunnelConf) {
@@ -102,24 +101,35 @@ constructor(
        return tunnelProviderFlow.value.runningTunnelNames()
    }

-    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
-        return tunnelProviderFlow.value.getStatistics(tunnelConf)
+    override suspend fun updateTunnelStatus(
+        tunnelConf: TunnelConf,
+        status: TunnelStatus?,
+        stats: TunnelStatistics?,
+        pingStates: Map<Key, PingState>?,
+        handshakeSuccessLogs: Boolean?,
+    ) {
+        tunnelProviderFlow.value.updateTunnelStatus(
+            tunnelConf,
+            status,
+            stats,
+            pingStates,
+            handshakeSuccessLogs,
+        )
    }

-    fun restorePreviousState() =
-        applicationScope.launch(ioDispatcher) {
-            val settings = appDataRepository.settings.get()
-            if (settings.isRestoreOnBootEnabled) {
-                val previouslyActiveTuns = appDataRepository.tunnels.getActive()
-                val tunsToStart =
-                    previouslyActiveTuns.filterNot { tun ->
-                        activeTunnels.value.any { tun.id == it.key.id }
-                    }
-                if (settings.isKernelEnabled) {
-                    return@launch tunsToStart.forEach { startTunnel(it) }
-                } else {
-                    tunsToStart.firstOrNull()?.let { startTunnel(it) }
+    suspend fun restorePreviousState() {
+        val settings = appDataRepository.settings.get()
+        if (settings.isRestoreOnBootEnabled) {
+            val previouslyActiveTuns = appDataRepository.tunnels.getActive()
+            val tunsToStart =
+                previouslyActiveTuns.filterNot { tun ->
+                    activeTunnels.value.any { tun.id == it.key.id }
                }
+            if (settings.isKernelEnabled) {
+                return tunsToStart.forEach { startTunnel(it) }
+            } else {
+                tunsToStart.firstOrNull()?.let { startTunnel(it) }
            }
        }
+    }
 }
@@ -0,0 +1,266 @@
+package com.zaneschepke.wireguardautotunnel.core.tunnel
+
+import com.zaneschepke.logcatter.LogReader
+import com.zaneschepke.networkmonitor.NetworkMonitor
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.FailureReason
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
+import com.zaneschepke.wireguardautotunnel.util.extensions.toMillis
+import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
+import dagger.hilt.android.scopes.ServiceScoped
+import io.ktor.util.collections.*
+import javax.inject.Inject
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import org.amnezia.awg.crypto.Key
+import timber.log.Timber
+
+@ServiceScoped
+class TunnelMonitor
+@Inject
+constructor(
+    private val appDataRepository: AppDataRepository,
+    private val tunnelManager: TunnelManager,
+    private val networkMonitor: NetworkMonitor,
+    private val networkUtils: NetworkUtils,
+    private val logReader: LogReader,
+) {
+
+    @OptIn(FlowPreview::class)
+    suspend fun startMonitoring(tunnelConf: TunnelConf, withLogs: Boolean): Job = coroutineScope {
+        launch {
+            launch { startTunnelConfChangesJob(tunnelConf) }
+            launch { startPingMonitor(tunnelConf) }
+            launch { startWgStatsPoll(tunnelConf) }
+            if (withLogs) launch { startLogsMonitor(tunnelConf) }
+        }
+    }
+
+    private suspend fun startTunnelConfChangesJob(tunnelConf: TunnelConf) {
+        appDataRepository.tunnels.flow
+            .map { storedTunnels -> storedTunnels.firstOrNull { it.id == tunnelConf.id } }
+            .filterNotNull()
+            .distinctUntilChanged { old, new -> old == new }
+            .collect { storedTunnel ->
+                if (tunnelConf != storedTunnel) {
+                    Timber.d("Config changed for ${storedTunnel.tunName}, bouncing")
+                    withContext(NonCancellable) {
+                        tunnelManager.bounceTunnel(
+                            storedTunnel,
+                            TunnelStatus.StopReason.ConfigChanged,
+                        )
+                    }
+                }
+            }
+    }
+
+    private suspend fun startLogsMonitor(tunnelConf: TunnelConf) {
+        logReader.liveLogs.collect { log ->
+            val healthLogs =
+                when {
+                    log.message.contains(HANDSHAKE_RESPONSE_TEXT, true) ||
+                        log.message.contains(KEEPALIVE_RESPONSE_TEXT, true) -> true
+                    log.message.contains(HANDSHAKE_INIT_FAILED_TEXT, true) ||
+                        log.message.contains(HANDSHAKE_NOT_COMPLETED_TEXT) ||
+                        log.message.contains(DATA_PACKET_FAILED_TEXT) -> false
+
+                    else -> null
+                }
+            healthLogs?.let { healthy ->
+                tunnelManager.updateTunnelStatus(tunnelConf, null, null, null, healthy)
+            }
+        }
+    }
+
+    private suspend fun startPingMonitor(tunnelConf: TunnelConf) = coroutineScope {
+        val pingStatsFlow = MutableStateFlow<Map<Key, PingState>>(emptyMap())
+
+        val tunStateFlow =
+            tunnelManager.activeTunnels.mapNotNull { it.getValueById(tunnelConf.id) }.stateIn(this)
+
+        val connectivityStateFlow = networkMonitor.connectivityStateFlow.stateIn(this)
+
+        val isNetworkConnected = connectivityStateFlow.map { it.hasConnectivity() }.stateIn(this)
+
+        data class NetworkChangeKey(
+            val ethernetConnected: Boolean,
+            val wifiConnected: Boolean,
+            val cellularConnected: Boolean,
+            val wifiSsid: String?,
+        )
+
+        connectivityStateFlow
+            .map {
+                NetworkChangeKey(
+                    ethernetConnected = it.ethernetConnected,
+                    wifiConnected = it.wifiState.connected,
+                    cellularConnected = it.cellularConnected,
+                    wifiSsid = if (it.wifiState.connected) it.wifiState.ssid else null,
+                )
+            }
+            .distinctUntilChanged()
+            .stateIn(this)
+
+        appDataRepository.settings.flow
+            .distinctUntilChanged { old, new ->
+                old.isPingEnabled == new.isPingEnabled &&
+                    old.tunnelPingIntervalSeconds == new.tunnelPingIntervalSeconds &&
+                    old.tunnelPingAttempts == new.tunnelPingAttempts &&
+                    old.tunnelPingTimeoutSeconds == new.tunnelPingTimeoutSeconds
+            }
+            .collectLatest { settings ->
+                if (!settings.isPingEnabled) return@collectLatest
+
+                Timber.d("Starting pinger for ${tunnelConf.tunName} with settings")
+
+                val config = tunnelConf.toAmConfig()
+
+                val pingablePeers = config.peers.filter { it.allowedIps.isNotEmpty() }
+                if (pingablePeers.isEmpty()) return@collectLatest
+
+                suspend fun performPing() {
+                    val updates = ConcurrentMap<Key, PingState>()
+
+                    pingablePeers.forEach { peer ->
+                        val previousState = pingStatsFlow.value[peer.publicKey] ?: PingState()
+
+                        val allowedIpStr = peer.allowedIps.firstOrNull()?.toString()
+                        if (allowedIpStr == null) {
+                            updates[peer.publicKey] =
+                                previousState.copy(
+                                    isReachable = false,
+                                    failureReason = FailureReason.NoResolvedEndpoint,
+                                    lastPingAttemptMillis = System.currentTimeMillis(),
+                                )
+                            return@forEach
+                        }
+
+                        val host =
+                            {
+                                    val parts = allowedIpStr.split("/")
+                                    val internalIp = if (parts.size == 2) parts[0] else allowedIpStr
+
+                                    val prefix =
+                                        if (parts.size == 2) parts[1].toIntOrNull() ?: 32 else 32
+                                    if (prefix <= 1) {
+                                        tunnelConf.pingTarget ?: CLOUDFLARE_IPV4_IP
+                                    } else {
+                                        internalIp.removeSurrounding("[", "]")
+                                    }
+                                }
+                                .invoke()
+
+                        val attemptTime = System.currentTimeMillis()
+                        runCatching {
+                                val pingStats =
+                                    settings.tunnelPingTimeoutSeconds?.let {
+                                        networkUtils.pingWithStats(
+                                            host,
+                                            settings.tunnelPingAttempts,
+                                            it.toMillis(),
+                                        )
+                                    }
+                                        ?: networkUtils.pingWithStats(
+                                            host,
+                                            settings.tunnelPingAttempts,
+                                        )
+
+                                updates[peer.publicKey] =
+                                    previousState.copy(
+                                        transmitted = pingStats.transmitted,
+                                        received = pingStats.received,
+                                        packetLoss = pingStats.packetLoss,
+                                        rttMin = pingStats.rttMin,
+                                        rttMax = pingStats.rttMax,
+                                        rttAvg = pingStats.rttAvg,
+                                        rttStddev = pingStats.rttStddev,
+                                        isReachable = pingStats.isReachable,
+                                        failureReason =
+                                            if (pingStats.isReachable) null
+                                            else FailureReason.PingFailed,
+                                        lastSuccessfulPingMillis =
+                                            pingStats.lastSuccessfulPingMillis
+                                                ?: previousState.lastSuccessfulPingMillis,
+                                        pingTarget = host,
+                                        lastPingAttemptMillis = attemptTime,
+                                    )
+                                Timber.d(
+                                    "Ping completed for peer ${peer.publicKey.toBase64().substring(0, 5)}.. to host $host with stats: $pingStats"
+                                )
+                            }
+                            .onFailure {
+                                Timber.e(
+                                    it,
+                                    "Ping failed for peer ${peer.publicKey} in ${tunnelConf.tunName} to host $host",
+                                )
+                                updates[peer.publicKey] =
+                                    previousState.copy(
+                                        isReachable = false,
+                                        failureReason = FailureReason.PingFailed,
+                                        pingTarget = host,
+                                        lastPingAttemptMillis = attemptTime,
+                                    )
+                            }
+                    }
+
+                    if (updates.isNotEmpty()) {
+                        pingStatsFlow.update { updates }
+                        tunnelManager.updateTunnelStatus(tunnelConf, null, null, updates)
+                    }
+                }
+
+                // Wait for the tunnel to be fully active
+                tunStateFlow.filter { state -> state.status == TunnelStatus.Up }.first()
+
+                // small delay to make sure tunnel is fully up before we actively monitor
+                delay(3_000L)
+
+                while (isActive) {
+                    if (isNetworkConnected.value) {
+                        performPing()
+                    } else {
+                        pingStatsFlow.update { current ->
+                            current.mapValues { entry ->
+                                entry.value.copy(
+                                    isReachable = false,
+                                    failureReason = FailureReason.NoConnectivity,
+                                    lastPingAttemptMillis = System.currentTimeMillis(),
+                                )
+                            }
+                        }
+                        tunnelManager.updateTunnelStatus(
+                            tunnelConf,
+                            null,
+                            null,
+                            pingStatsFlow.value,
+                        )
+                    }
+                    delay(settings.tunnelPingIntervalSeconds.toMillis())
+                }
+            }
+    }
+
+    private suspend fun startWgStatsPoll(tunnelConf: TunnelConf) = coroutineScope {
+        while (isActive) {
+            val stats = tunnelManager.getStatistics(tunnelConf)
+            tunnelManager.updateTunnelStatus(tunnelConf, null, stats, null)
+            delay(STATS_DELAY)
+        }
+    }
+
+    companion object {
+        const val CLOUDFLARE_IPV6_IP = "2606:4700:4700::1111"
+        const val CLOUDFLARE_IPV4_IP = "1.1.1.1"
+
+        const val STATS_DELAY = 1_000L
+
+        const val KEEPALIVE_RESPONSE_TEXT = "Receiving keepalive packet"
+        const val HANDSHAKE_RESPONSE_TEXT = "Received handshake response"
+        const val HANDSHAKE_INIT_FAILED_TEXT = "Failed to send handshake initiation: write udp"
+        const val DATA_PACKET_FAILED_TEXT = "Failed to send data packets"
+        const val HANDSHAKE_NOT_COMPLETED_TEXT =
+            "Handshake did not complete after 5 seconds, retrying"
+    }
+}
@@ -1,14 +1,17 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel

-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
-import com.zaneschepke.wireguardautotunnel.domain.enums.BackendError
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
 import java.util.concurrent.ConcurrentHashMap
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.StateFlow
+import org.amnezia.awg.crypto.Key

 interface TunnelProvider {
    /** Starts the specified tunnel configuration. */
@@ -23,19 +26,19 @@ interface TunnelProvider {
     */
    suspend fun stopTunnel(
        tunnelConf: TunnelConf? = null,
-        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.USER,
+        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.User,
    )

    /**
     * Bounces (stops and restarts) the specified tunnel.
     *
     * @param tunnelConf The tunnel to bounce.
-     * @param reason The reason for bouncing, defaults to USER for manual actions. Callers should
-     *   override with specific reasons (e.g., PING, CONFIG_CHANGED) when applicable.
+     * @param reason The reason for bouncing, defaults to User for manual actions. Callers should
+     *   override with specific reasons (e.g., Ping, ConfigChanged) when applicable.
     */
    suspend fun bounceTunnel(
        tunnelConf: TunnelConf,
-        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.USER,
+        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.User,
    )

    fun setBackendState(backendState: BackendState, allowedIps: Collection<String>)
@@ -50,9 +53,17 @@ interface TunnelProvider {

    val errorEvents: SharedFlow<Pair<TunnelConf, BackendError>>

+    val messageEvents: SharedFlow<Pair<TunnelConf, BackendMessage>>
+
    val bouncingTunnelIds: ConcurrentHashMap<Int, TunnelStatus.StopReason>

    fun hasVpnPermission(): Boolean

-    suspend fun updateTunnelStatistics(tunnel: TunnelConf)
+    suspend fun updateTunnelStatus(
+        tunnelConf: TunnelConf,
+        status: TunnelStatus? = null,
+        stats: TunnelStatistics? = null,
+        pingStates: Map<Key, PingState>? = null,
+        handshakeSuccessLogs: Boolean? = null,
+    )
 }
@@ -1,10 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel

 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.AmneziaStatistics
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
@@ -23,7 +23,7 @@ import timber.log.Timber
 class UserspaceTunnel
@Inject
 constructor(
-    @ApplicationScope private val applicationScope: CoroutineScope,
+    applicationScope: CoroutineScope,
    val serviceManager: ServiceManager,
    val appDataRepository: AppDataRepository,
    private val backend: Backend,
@@ -40,6 +40,9 @@ constructor(
        } catch (e: BackendException) {
            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
            throw e.toBackendError()
+        } catch (e: IllegalArgumentException) {
+            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
+            throw BackendError.Config
        }
    }

@@ -2,11 +2,7 @@ package com.zaneschepke.wireguardautotunnel.core.worker

 import android.content.Context
 import androidx.hilt.work.HiltWorker
-import androidx.work.CoroutineWorker
-import androidx.work.ExistingPeriodicWorkPolicy
-import androidx.work.PeriodicWorkRequestBuilder
-import androidx.work.WorkManager
-import androidx.work.WorkerParameters
+import androidx.work.*
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
@@ -1,19 +1,15 @@
 package com.zaneschepke.wireguardautotunnel.data

-import androidx.room.AutoMigration
-import androidx.room.Database
-import androidx.room.DeleteColumn
-import androidx.room.RoomDatabase
-import androidx.room.TypeConverters
+import androidx.room.*
 import androidx.room.migration.AutoMigrationSpec
 import com.zaneschepke.wireguardautotunnel.data.dao.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.dao.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import com.zaneschepke.wireguardautotunnel.data.entity.TunnelConfig

@Database(
    entities = [Settings::class, TunnelConfig::class],
-    version = 16,
+    version = 19,
    autoMigrations =
        [
            AutoMigration(from = 1, to = 2),
@@ -31,10 +27,13 @@ import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
            AutoMigration(from = 13, to = 14),
            AutoMigration(from = 14, to = 15),
            AutoMigration(from = 15, to = 16),
+            AutoMigration(from = 16, to = 17, spec = WifiDetectionMigration::class),
+            AutoMigration(from = 17, to = 18),
+            AutoMigration(from = 18, to = 19, spec = PingMigration::class),
        ],
    exportSchema = true,
 )
-@TypeConverters(DatabaseListConverters::class)
+@TypeConverters(DatabaseConverters::class)
 abstract class AppDatabase : RoomDatabase() {
    abstract fun settingDao(): SettingsDao

@@ -47,3 +46,25 @@ class RemoveLegacySettingColumnsMigration : AutoMigrationSpec

@DeleteColumn(tableName = "Settings", columnName = "is_auto_tunnel_paused")
 class RemoveTunnelPauseMigration : AutoMigrationSpec
+
+@DeleteColumn(tableName = "Settings", columnName = "is_wifi_by_shell_enabled")
+class WifiDetectionMigration : AutoMigrationSpec
+
+@DeleteColumn.Entries(
+    DeleteColumn(tableName = "TunnelConfig", columnName = "ping_interval"),
+    DeleteColumn(tableName = "TunnelConfig", columnName = "ping_cooldown"),
+    DeleteColumn(tableName = "Settings", columnName = "split_tunnel_apps"),
+)
+@RenameColumn.Entries(
+    RenameColumn(
+        tableName = "TunnelConfig",
+        fromColumnName = "is_ping_enabled",
+        toColumnName = "restart_on_ping_failure",
+    ),
+    RenameColumn(
+        tableName = "TunnelConfig",
+        fromColumnName = "ping_ip",
+        toColumnName = "ping_target",
+    ),
+)
+class PingMigration : AutoMigrationSpec
@@ -31,6 +31,7 @@ class DataStoreManager(
        val theme = stringPreferencesKey("THEME")
        val isRemoteControlEnabled = booleanPreferencesKey("IS_REMOTE_CONTROL_ENABLED")
        val remoteKey = stringPreferencesKey("REMOTE_KEY")
+        val showDetailedPingStats = booleanPreferencesKey("SHOW_DETAILED_PING_STATS")
    }

    // preferences
@@ -0,0 +1,30 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.TypeConverter
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import kotlinx.serialization.json.Json
+
+class DatabaseConverters {
+    @TypeConverter
+    fun listToString(value: List<String>): String {
+        return Json.encodeToString(value)
+    }
+
+    @TypeConverter
+    fun stringToList(value: String): List<String> {
+        if (value.isBlank() || value.isEmpty()) return mutableListOf()
+        return try {
+            Json.decodeFromString<List<String>>(value)
+        } catch (e: Exception) {
+            val list = value.split(",").toMutableList()
+            val json = listToString(list)
+            Json.decodeFromString<List<String>>(json)
+        }
+    }
+
+    @TypeConverter fun fromStatus(status: Settings.WifiDetectionMethod): Int = status.value
+
+    @TypeConverter
+    fun toStatus(value: Int): Settings.WifiDetectionMethod =
+        Settings.WifiDetectionMethod.fromValue(value)
+}
@@ -1,23 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data
-
-import androidx.room.TypeConverter
-import kotlinx.serialization.json.Json
-
-class DatabaseListConverters {
-    @TypeConverter
-    fun listToString(value: MutableList<String>): String {
-        return Json.encodeToString(value)
-    }
-
-    @TypeConverter
-    fun stringToList(value: String): MutableList<String> {
-        if (value.isBlank() || value.isEmpty()) return mutableListOf()
-        return try {
-            Json.decodeFromString<MutableList<String>>(value)
-        } catch (e: Exception) {
-            val list = value.split(",").toMutableList()
-            val json = listToString(list)
-            Json.decodeFromString<MutableList<String>>(json)
-        }
-    }
-}
@@ -1,11 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.data.dao

-import androidx.room.Dao
-import androidx.room.Delete
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import androidx.room.*
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
 import kotlinx.coroutines.flow.Flow

@Dao
@@ -1,11 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.data.dao

-import androidx.room.Dao
-import androidx.room.Delete
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import androidx.room.*
+import com.zaneschepke.wireguardautotunnel.data.entity.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 import kotlinx.coroutines.flow.Flow

@@ -46,5 +42,6 @@ interface TunnelConfigDao {
    @Query("SELECT * FROM TUNNELCONFIG WHERE is_mobile_data_tunnel=1")
    suspend fun findByMobileDataTunnel(): TunnelConfigs

-    @Query("SELECT * FROM tunnelconfig") fun getAllFlow(): Flow<MutableList<TunnelConfig>>
+    @Query("SELECT * FROM tunnelconfig ORDER BY position")
+    fun getAllFlow(): Flow<List<TunnelConfig>>
 }
@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.data.model
+package com.zaneschepke.wireguardautotunnel.data.entity

 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
@@ -0,0 +1,26 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
+
+data class GeneralState(
+    val isLocationDisclosureShown: Boolean = LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+    val isBatteryOptimizationDisableShown: Boolean = BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+    val isPinLockEnabled: Boolean = PIN_LOCK_ENABLED_DEFAULT,
+    val expandedTunnelIds: List<Int> = emptyList(),
+    val isLocalLogsEnabled: Boolean = IS_LOGS_ENABLED_DEFAULT,
+    val isRemoteControlEnabled: Boolean = IS_REMOTE_CONTROL_ENABLED,
+    val showDetailedPingStats: Boolean = SHOW_DETAILED_PING_STATS_DEFAULT,
+    val remoteKey: String? = null,
+    val locale: String? = null,
+    val theme: Theme = Theme.AUTOMATIC,
+) {
+
+    companion object {
+        const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
+        const val BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT = false
+        const val PIN_LOCK_ENABLED_DEFAULT = false
+        const val IS_LOGS_ENABLED_DEFAULT = false
+        const val IS_REMOTE_CONTROL_ENABLED = false
+        const val SHOW_DETAILED_PING_STATS_DEFAULT = false
+    }
+}
@@ -0,0 +1,12 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class GitHubRelease(
+    @SerialName("tag_name") val tagName: String,
+    val name: String?,
+    val body: String?,
+    val assets: List<Asset>,
+)
@@ -1,9 +1,8 @@
-package com.zaneschepke.wireguardautotunnel.data.model
+package com.zaneschepke.wireguardautotunnel.data.entity

 import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.PrimaryKey
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings

@Entity
 data class Settings(
@@ -11,8 +10,7 @@ data class Settings(
    @ColumnInfo(name = "is_tunnel_enabled") val isAutoTunnelEnabled: Boolean = false,
    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled")
    val isTunnelOnMobileDataEnabled: Boolean = false,
-    @ColumnInfo(name = "trusted_network_ssids")
-    val trustedNetworkSSIDs: MutableList<String> = mutableListOf(),
+    @ColumnInfo(name = "trusted_network_ssids") val trustedNetworkSSIDs: List<String> = emptyList(),
    @ColumnInfo(name = "is_always_on_vpn_enabled") val isAlwaysOnVpnEnabled: Boolean = false,
    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled")
    val isTunnelOnEthernetEnabled: Boolean = false,
@@ -32,8 +30,6 @@ data class Settings(
    val isAmneziaEnabled: Boolean = false,
    @ColumnInfo(name = "is_wildcards_enabled", defaultValue = "false")
    val isWildcardsEnabled: Boolean = false,
-    @ColumnInfo(name = "is_wifi_by_shell_enabled", defaultValue = "false")
-    val isWifiNameByShellEnabled: Boolean = false,
    @ColumnInfo(name = "is_stop_on_no_internet_enabled", defaultValue = "false")
    val isStopOnNoInternetEnabled: Boolean = false,
    @ColumnInfo(name = "is_vpn_kill_switch_enabled", defaultValue = "false")
@@ -46,61 +42,26 @@ data class Settings(
    val debounceDelaySeconds: Int = 3,
    @ColumnInfo(name = "is_disable_kill_switch_on_trusted_enabled", defaultValue = "false")
    val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_unsecure_enabled", defaultValue = "false")
+    val isTunnelOnUnsecureEnabled: Boolean = false,
+    @ColumnInfo(name = "wifi_detection_method", defaultValue = "0")
+    val wifiDetectionMethod: WifiDetectionMethod = WifiDetectionMethod.fromValue(0),
+    @ColumnInfo(name = "is_ping_monitoring_enabled", defaultValue = "true")
+    val isPingMonitoringEnabled: Boolean = true,
+    @ColumnInfo(name = "tunnel_ping_interval_sec", defaultValue = "30")
+    val tunnelPingIntervalSeconds: Int = 30,
+    @ColumnInfo(name = "tunnel_ping_attempts", defaultValue = "3") val tunnelPingAttempts: Int = 3,
+    @ColumnInfo(name = "tunnel_ping_timeout_sec") val tunnelPingTimeoutSeconds: Int? = null,
 ) {
+    enum class WifiDetectionMethod(val value: Int) {
+        DEFAULT(0),
+        LEGACY(1),
+        ROOT(2),
+        SHIZUKU(3);

-    fun toAppSettings(): AppSettings {
-        return AppSettings(
-            id,
-            isAutoTunnelEnabled,
-            isTunnelOnMobileDataEnabled,
-            trustedNetworkSSIDs,
-            isAlwaysOnVpnEnabled,
-            isTunnelOnEthernetEnabled,
-            isShortcutsEnabled,
-            isTunnelOnWifiEnabled,
-            isKernelEnabled,
-            isRestoreOnBootEnabled,
-            isMultiTunnelEnabled,
-            isPingEnabled,
-            isAmneziaEnabled,
-            isWildcardsEnabled,
-            isWifiNameByShellEnabled,
-            isStopOnNoInternetEnabled,
-            isVpnKillSwitchEnabled,
-            isKernelKillSwitchEnabled,
-            isLanOnKillSwitchEnabled,
-            debounceDelaySeconds,
-            isDisableKillSwitchOnTrustedEnabled,
-        )
-    }
-
-    companion object {
-        fun from(appSettings: AppSettings): Settings {
-            return with(appSettings) {
-                Settings(
-                    id,
-                    isAutoTunnelEnabled,
-                    isTunnelOnMobileDataEnabled,
-                    trustedNetworkSSIDs.toMutableList(),
-                    isAlwaysOnVpnEnabled,
-                    isTunnelOnEthernetEnabled,
-                    isShortcutsEnabled,
-                    isTunnelOnWifiEnabled,
-                    isKernelEnabled,
-                    isRestoreOnBootEnabled,
-                    isMultiTunnelEnabled,
-                    isPingEnabled,
-                    isAmneziaEnabled,
-                    isWildcardsEnabled,
-                    isWifiNameByShellEnabled,
-                    isStopOnNoInternetEnabled,
-                    isVpnKillSwitchEnabled,
-                    isKernelKillSwitchEnabled,
-                    isLanOnKillSwitchEnabled,
-                    debounceDelaySeconds,
-                    isDisableKillSwitchOnTrustedEnabled,
-                )
-            }
+        companion object {
+            fun fromValue(value: Int): WifiDetectionMethod =
+                entries.find { it.value == value } ?: DEFAULT
        }
    }
 }
@@ -0,0 +1,36 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(indices = [Index(value = ["name"], unique = true)])
+data class TunnelConfig(
+    @PrimaryKey(autoGenerate = true) val id: Int = 0,
+    @ColumnInfo(name = "name") val name: String,
+    @ColumnInfo(name = "wg_quick") val wgQuick: String,
+    @ColumnInfo(name = "tunnel_networks", defaultValue = "")
+    val tunnelNetworks: List<String> = listOf(),
+    @ColumnInfo(name = "is_mobile_data_tunnel", defaultValue = "false")
+    val isMobileDataTunnel: Boolean = false,
+    @ColumnInfo(name = "is_primary_tunnel", defaultValue = "false")
+    val isPrimaryTunnel: Boolean = false,
+    @ColumnInfo(name = "am_quick", defaultValue = "") val amQuick: String = AM_QUICK_DEFAULT,
+    @ColumnInfo(name = "is_Active", defaultValue = "false") val isActive: Boolean = false,
+    @ColumnInfo(name = "restart_on_ping_failure", defaultValue = "false")
+    val restartOnPingFailure: Boolean = false,
+    @ColumnInfo(name = "ping_target", defaultValue = "null") var pingTarget: String? = null,
+    @ColumnInfo(name = "is_ethernet_tunnel", defaultValue = "false")
+    val isEthernetTunnel: Boolean = false,
+    @ColumnInfo(name = "is_ipv4_preferred", defaultValue = "true")
+    val isIpv4Preferred: Boolean = true,
+    @ColumnInfo(name = "position", defaultValue = "0") val position: Int = 0,
+    @ColumnInfo(name = "auto_tunnel_apps", defaultValue = "[]")
+    val autoTunnelApps: List<String> = listOf(),
+) {
+
+    companion object {
+        const val AM_QUICK_DEFAULT = ""
+    }
+}
@@ -0,0 +1,39 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.wireguardautotunnel.data.entity.GeneralState
+import com.zaneschepke.wireguardautotunnel.domain.model.AppState
+
+object GeneralStateMapper {
+    fun toAppState(generalState: GeneralState): AppState =
+        with(generalState) {
+            AppState(
+                isLocationDisclosureShown,
+                isBatteryOptimizationDisableShown,
+                isPinLockEnabled,
+                expandedTunnelIds,
+                isLocalLogsEnabled,
+                isRemoteControlEnabled,
+                showDetailedPingStats,
+                remoteKey,
+                locale,
+                theme,
+            )
+        }
+
+    fun toGeneralState(appState: AppState): GeneralState {
+        return with(appState) {
+            GeneralState(
+                isLocationDisclosureShown,
+                isBatteryOptimizationDisableShown,
+                isPinLockEnabled,
+                expandedTunnelIds,
+                isLocalLogsEnabled,
+                isRemoteControlEnabled,
+                showDetailedPingStats,
+                remoteKey,
+                locale,
+                theme,
+            )
+        }
+    }
+}
@@ -0,0 +1,19 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.wireguardautotunnel.data.entity.GitHubRelease
+import com.zaneschepke.wireguardautotunnel.domain.model.AppUpdate
+
+object GitHubReleaseMapper {
+    fun toAppUpdate(gitHubRelease: GitHubRelease, newVersion: String): AppUpdate {
+        with(gitHubRelease) {
+            val apkAsset = assets.firstOrNull { it.name.endsWith(".apk") }
+            return AppUpdate(
+                version = newVersion,
+                title = name ?: "Update $tagName",
+                releaseNotes = body ?: "No release notes provided",
+                apkUrl = apkAsset?.browserDownloadUrl,
+                apkFileName = apkAsset?.name,
+            )
+        }
+    }
+}
@@ -0,0 +1,71 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+
+object SettingsMapper {
+    fun toAppSettings(settings: Settings): AppSettings {
+        return AppSettings(
+            id = settings.id,
+            isAutoTunnelEnabled = settings.isAutoTunnelEnabled,
+            isTunnelOnMobileDataEnabled = settings.isTunnelOnMobileDataEnabled,
+            trustedNetworkSSIDs = settings.trustedNetworkSSIDs,
+            isAlwaysOnVpnEnabled = settings.isAlwaysOnVpnEnabled,
+            isTunnelOnEthernetEnabled = settings.isTunnelOnEthernetEnabled,
+            isShortcutsEnabled = settings.isShortcutsEnabled,
+            isTunnelOnWifiEnabled = settings.isTunnelOnWifiEnabled,
+            isKernelEnabled = settings.isKernelEnabled,
+            isRestoreOnBootEnabled = settings.isRestoreOnBootEnabled,
+            isMultiTunnelEnabled = settings.isMultiTunnelEnabled,
+            isPingEnabled = settings.isPingEnabled,
+            isAmneziaEnabled = settings.isAmneziaEnabled,
+            isWildcardsEnabled = settings.isWildcardsEnabled,
+            isStopOnNoInternetEnabled = settings.isStopOnNoInternetEnabled,
+            isVpnKillSwitchEnabled = settings.isVpnKillSwitchEnabled,
+            isKernelKillSwitchEnabled = settings.isKernelKillSwitchEnabled,
+            isLanOnKillSwitchEnabled = settings.isLanOnKillSwitchEnabled,
+            debounceDelaySeconds = settings.debounceDelaySeconds,
+            isDisableKillSwitchOnTrustedEnabled = settings.isDisableKillSwitchOnTrustedEnabled,
+            isTunnelOnUnsecureEnabled = settings.isTunnelOnUnsecureEnabled,
+            wifiDetectionMethod =
+                AndroidNetworkMonitor.WifiDetectionMethod.fromValue(
+                    settings.wifiDetectionMethod.value
+                ),
+            tunnelPingIntervalSeconds = settings.tunnelPingIntervalSeconds,
+            tunnelPingAttempts = settings.tunnelPingAttempts,
+            tunnelPingTimeoutSeconds = settings.tunnelPingTimeoutSeconds,
+        )
+    }
+
+    fun toSettings(appSettings: AppSettings): Settings {
+        return Settings(
+            id = appSettings.id,
+            isAutoTunnelEnabled = appSettings.isAutoTunnelEnabled,
+            isTunnelOnMobileDataEnabled = appSettings.isTunnelOnMobileDataEnabled,
+            trustedNetworkSSIDs = appSettings.trustedNetworkSSIDs,
+            isAlwaysOnVpnEnabled = appSettings.isAlwaysOnVpnEnabled,
+            isTunnelOnEthernetEnabled = appSettings.isTunnelOnEthernetEnabled,
+            isShortcutsEnabled = appSettings.isShortcutsEnabled,
+            isTunnelOnWifiEnabled = appSettings.isTunnelOnWifiEnabled,
+            isKernelEnabled = appSettings.isKernelEnabled,
+            isRestoreOnBootEnabled = appSettings.isRestoreOnBootEnabled,
+            isMultiTunnelEnabled = appSettings.isMultiTunnelEnabled,
+            isPingEnabled = appSettings.isPingEnabled,
+            isAmneziaEnabled = appSettings.isAmneziaEnabled,
+            isWildcardsEnabled = appSettings.isWildcardsEnabled,
+            isStopOnNoInternetEnabled = appSettings.isStopOnNoInternetEnabled,
+            isVpnKillSwitchEnabled = appSettings.isVpnKillSwitchEnabled,
+            isKernelKillSwitchEnabled = appSettings.isKernelKillSwitchEnabled,
+            isLanOnKillSwitchEnabled = appSettings.isLanOnKillSwitchEnabled,
+            debounceDelaySeconds = appSettings.debounceDelaySeconds,
+            isDisableKillSwitchOnTrustedEnabled = appSettings.isDisableKillSwitchOnTrustedEnabled,
+            isTunnelOnUnsecureEnabled = appSettings.isTunnelOnUnsecureEnabled,
+            wifiDetectionMethod =
+                Settings.WifiDetectionMethod.fromValue(appSettings.wifiDetectionMethod.value),
+            tunnelPingIntervalSeconds = appSettings.tunnelPingIntervalSeconds,
+            tunnelPingAttempts = appSettings.tunnelPingAttempts,
+            tunnelPingTimeoutSeconds = appSettings.tunnelPingTimeoutSeconds,
+        )
+    }
+}
@@ -0,0 +1,46 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.wireguardautotunnel.data.entity.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+
+object TunnelConfigMapper {
+    fun toTunnelConf(tunnelConfig: TunnelConfig): TunnelConf {
+        return with(tunnelConfig) {
+            TunnelConf(
+                id,
+                name,
+                wgQuick,
+                tunnelNetworks,
+                isMobileDataTunnel,
+                isPrimaryTunnel,
+                amQuick,
+                isActive,
+                pingTarget,
+                restartOnPingFailure,
+                isEthernetTunnel,
+                isIpv4Preferred,
+                position,
+            )
+        }
+    }
+
+    fun toTunnelConfig(tunnelConf: TunnelConf): TunnelConfig {
+        return with(tunnelConf) {
+            TunnelConfig(
+                id,
+                tunName,
+                wgQuick,
+                tunnelNetworks,
+                isMobileDataTunnel,
+                isPrimaryTunnel,
+                amQuick,
+                isActive,
+                restartOnPingFailure,
+                pingTarget,
+                isEthernetTunnel,
+                isIpv4Preferred,
+                position,
+            )
+        }
+    }
+}
@@ -1,54 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppState
-import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
-
-data class GeneralState(
-    val isLocationDisclosureShown: Boolean = LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-    val isBatteryOptimizationDisableShown: Boolean = BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-    val isPinLockEnabled: Boolean = PIN_LOCK_ENABLED_DEFAULT,
-    val expandedTunnelIds: List<Int> = emptyList(),
-    val isLocalLogsEnabled: Boolean = IS_LOGS_ENABLED_DEFAULT,
-    val isRemoteControlEnabled: Boolean = IS_REMOTE_CONTROL_ENABLED,
-    val remoteKey: String? = null,
-    val locale: String? = null,
-    val theme: Theme = Theme.AUTOMATIC,
-) {
-
-    fun toAppState(): AppState =
-        AppState(
-            isLocationDisclosureShown,
-            isBatteryOptimizationDisableShown,
-            isPinLockEnabled,
-            expandedTunnelIds,
-            isLocalLogsEnabled,
-            isRemoteControlEnabled,
-            remoteKey,
-            locale,
-            theme,
-        )
-
-    companion object {
-        fun from(appState: AppState): GeneralState {
-            return with(appState) {
-                GeneralState(
-                    isLocationDisclosureShown,
-                    isBatteryOptimizationDisableShown,
-                    isPinLockEnabled,
-                    expandedTunnelIds,
-                    isLocalLogsEnabled,
-                    isRemoteControlEnabled,
-                    remoteKey,
-                    locale,
-                    theme,
-                )
-            }
-        }
-
-        const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
-        const val BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT = false
-        const val PIN_LOCK_ENABLED_DEFAULT = false
-        const val IS_LOGS_ENABLED_DEFAULT = false
-        const val IS_REMOTE_CONTROL_ENABLED = false
-    }
-}
@@ -1,24 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppUpdate
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class GitHubRelease(
-    @SerialName("tag_name") val tagName: String,
-    val name: String?,
-    val body: String?,
-    val assets: List<Asset>,
-) {
-    fun toAppUpdate(): AppUpdate {
-        val apkAsset = assets.firstOrNull { it.name.endsWith(".apk") }
-        return AppUpdate(
-            version = tagName.removePrefix("v"),
-            title = name ?: "Update $tagName",
-            releaseNotes = body ?: "No release notes provided",
-            apkUrl = apkAsset?.browserDownloadUrl,
-            apkFileName = apkAsset?.name,
-        )
-    }
-}
@@ -1,77 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
-
-@Entity(indices = [Index(value = ["name"], unique = true)])
-data class TunnelConfig(
-    @PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "name") val name: String,
-    @ColumnInfo(name = "wg_quick") val wgQuick: String,
-    @ColumnInfo(name = "tunnel_networks", defaultValue = "")
-    val tunnelNetworks: MutableList<String> = mutableListOf(),
-    @ColumnInfo(name = "is_mobile_data_tunnel", defaultValue = "false")
-    val isMobileDataTunnel: Boolean = false,
-    @ColumnInfo(name = "is_primary_tunnel", defaultValue = "false")
-    val isPrimaryTunnel: Boolean = false,
-    @ColumnInfo(name = "am_quick", defaultValue = "") val amQuick: String = AM_QUICK_DEFAULT,
-    @ColumnInfo(name = "is_Active", defaultValue = "false") val isActive: Boolean = false,
-    @ColumnInfo(name = "is_ping_enabled", defaultValue = "false")
-    val isPingEnabled: Boolean = false,
-    @ColumnInfo(name = "ping_interval", defaultValue = "null") val pingInterval: Long? = null,
-    @ColumnInfo(name = "ping_cooldown", defaultValue = "null") val pingCooldown: Long? = null,
-    @ColumnInfo(name = "ping_ip", defaultValue = "null") var pingIp: String? = null,
-    @ColumnInfo(name = "is_ethernet_tunnel", defaultValue = "false")
-    var isEthernetTunnel: Boolean = false,
-    @ColumnInfo(name = "is_ipv4_preferred", defaultValue = "true")
-    var isIpv4Preferred: Boolean = true,
-) {
-
-    fun toTunnel(): TunnelConf {
-        return TunnelConf(
-            id,
-            name,
-            wgQuick,
-            tunnelNetworks,
-            isMobileDataTunnel,
-            isPrimaryTunnel,
-            amQuick,
-            isActive,
-            isPingEnabled,
-            pingInterval,
-            pingCooldown,
-            pingIp,
-            isEthernetTunnel,
-            isIpv4Preferred,
-        )
-    }
-
-    companion object {
-
-        const val AM_QUICK_DEFAULT = ""
-
-        fun from(tunnelConf: TunnelConf): TunnelConfig {
-            return with(tunnelConf) {
-                return TunnelConfig(
-                    id,
-                    tunName,
-                    wgQuick,
-                    tunnelNetworks.toMutableList(),
-                    isMobileDataTunnel,
-                    isPrimaryTunnel,
-                    amQuick,
-                    isActive,
-                    isPingEnabled,
-                    pingInterval,
-                    pingCooldown,
-                    pingIp,
-                    isEthernetTunnel,
-                    isIpv4Preferred,
-                )
-            }
-        }
-    }
-}
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.data.network

-import com.zaneschepke.wireguardautotunnel.data.model.GitHubRelease
+import com.zaneschepke.wireguardautotunnel.data.entity.GitHubRelease

 interface GitHubApi {
    suspend fun getLatestRelease(owner: String, repo: String): Result<GitHubRelease>
@@ -1,10 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.data.network

-import io.ktor.client.HttpClient
-import io.ktor.client.engine.okhttp.OkHttp
-import io.ktor.client.plugins.HttpTimeout
-import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
-import io.ktor.serialization.kotlinx.json.json
+import io.ktor.client.*
+import io.ktor.client.engine.okhttp.*
+import io.ktor.client.plugins.*
+import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.serialization.kotlinx.json.*
 import kotlinx.serialization.json.Json

 object KtorClient {
@@ -1,11 +1,11 @@
 package com.zaneschepke.wireguardautotunnel.data.network

-import com.zaneschepke.wireguardautotunnel.data.model.GitHubRelease
-import io.ktor.client.HttpClient
-import io.ktor.client.call.body
-import io.ktor.client.plugins.ClientRequestException
-import io.ktor.client.request.get
-import io.ktor.http.HttpStatusCode
+import com.zaneschepke.wireguardautotunnel.data.entity.GitHubRelease
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.plugins.*
+import io.ktor.client.request.*
+import io.ktor.http.*

 class KtorGitHubApi(private val client: HttpClient) : GitHubApi {
    override suspend fun getLatestRelease(owner: String, repo: String): Result<GitHubRelease> {
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.data.repository

-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
@@ -1,8 +1,9 @@
 package com.zaneschepke.wireguardautotunnel.data.repository

 import com.zaneschepke.wireguardautotunnel.data.DataStoreManager
-import com.zaneschepke.wireguardautotunnel.data.model.GeneralState
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppState
+import com.zaneschepke.wireguardautotunnel.data.entity.GeneralState
+import com.zaneschepke.wireguardautotunnel.data.mapper.GeneralStateMapper
+import com.zaneschepke.wireguardautotunnel.domain.model.AppState
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
 import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
 import kotlinx.coroutines.flow.Flow
@@ -118,6 +119,15 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
        return dataStoreManager.getFromStore(DataStoreManager.remoteKey)
    }

+    override suspend fun setShowDetailedPingStats(showDetailedPing: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.showDetailedPingStats, showDetailedPing)
+    }
+
+    override suspend fun getShowDetailedPing(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.showDetailedPingStats)
+            ?: GeneralState.SHOW_DETAILED_PING_STATS_DEFAULT
+    }
+
    override val flow: Flow<AppState> =
        dataStoreManager.preferencesFlow
            .map { prefs ->
@@ -143,6 +153,9 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
                            isRemoteControlEnabled =
                                pref[DataStoreManager.isRemoteControlEnabled]
                                    ?: GeneralState.IS_REMOTE_CONTROL_ENABLED,
+                            showDetailedPingStats =
+                                pref[DataStoreManager.showDetailedPingStats]
+                                    ?: GeneralState.SHOW_DETAILED_PING_STATS_DEFAULT,
                            remoteKey = pref[DataStoreManager.remoteKey],
                            locale = pref[DataStoreManager.locale],
                            theme = getTheme(),
@@ -153,5 +166,5 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
                    }
                } ?: GeneralState()
            }
-            .map { it.toAppState() }
+            .map(GeneralStateMapper::toAppState)
 }
@@ -2,18 +2,18 @@ package com.zaneschepke.wireguardautotunnel.data.repository

 import android.content.Context
 import com.zaneschepke.wireguardautotunnel.BuildConfig
+import com.zaneschepke.wireguardautotunnel.data.mapper.GitHubReleaseMapper
 import com.zaneschepke.wireguardautotunnel.data.network.GitHubApi
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppUpdate
+import com.zaneschepke.wireguardautotunnel.domain.model.AppUpdate
 import com.zaneschepke.wireguardautotunnel.domain.repository.UpdateRepository
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import io.ktor.client.HttpClient
-import io.ktor.client.request.get
-import io.ktor.client.statement.HttpResponse
-import io.ktor.client.statement.bodyAsChannel
-import io.ktor.http.contentLength
-import io.ktor.utils.io.ByteReadChannel
-import io.ktor.utils.io.readAvailable
+import io.ktor.client.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import io.ktor.utils.io.*
 import java.io.File
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
@@ -30,24 +30,30 @@ class GitHubUpdateRepository(
    override suspend fun checkForUpdate(currentVersion: String): Result<AppUpdate?> =
        withContext(ioDispatcher) {
            Timber.i("Checking for update")
+            val isNightly = BuildConfig.VERSION_NAME.contains("nightly")
            val release =
-                if (BuildConfig.VERSION_NAME.contains("nightly")) {
-                    gitHubApi.getNightlyRelease(githubOwner, githubRepo)
+                if (isNightly) {
+                    gitHubApi.getNightlyRelease(githubOwner, githubRepo).onFailure(Timber::e)
                } else {
-                    gitHubApi.getLatestRelease(githubOwner, githubRepo)
+                    gitHubApi.getLatestRelease(githubOwner, githubRepo).onFailure(Timber::e)
                }
            release.map { release ->
                val apkAsset =
                    release.assets.find { asset ->
-                        asset.name.startsWith("wgtunnel-full-v") && asset.name.endsWith(".apk")
+                        asset.name.startsWith("wgtunnel-${Constants.STANDALONE_FLAVOR}-v") &&
+                            asset.name.endsWith(".apk")
                    }
                val newVersion =
-                    apkAsset?.name?.removePrefix("wgtunnel-full-v")?.removeSuffix(".apk")
-                        ?: return@map null
+                    apkAsset
+                        ?.name
+                        ?.removePrefix("wgtunnel-${Constants.STANDALONE_FLAVOR}-v")
+                        ?.removeSuffix(".apk") ?: return@map null

                Timber.i("Latest version: $newVersion, current version: $currentVersion")
+                if (isNightly && newVersion != currentVersion)
+                    return@map GitHubReleaseMapper.toAppUpdate(release, newVersion)
                if (NumberUtils.compareVersions(newVersion, currentVersion) > 0) {
-                    release.toAppUpdate()
+                    GitHubReleaseMapper.toAppUpdate(release, newVersion)
                } else {
                    null
                }
@@ -1,9 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.data.repository

 import com.zaneschepke.wireguardautotunnel.data.dao.SettingsDao
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import com.zaneschepke.wireguardautotunnel.data.mapper.SettingsMapper
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.flowOn
@@ -16,15 +17,15 @@ class RoomSettingsRepository(
 ) : AppSettingRepository {

    override suspend fun save(appSettings: AppSettings) {
-        withContext(ioDispatcher) { settingsDoa.save(Settings.from(appSettings)) }
+        withContext(ioDispatcher) { settingsDoa.save(SettingsMapper.toSettings(appSettings)) }
    }

    override val flow =
-        settingsDoa.getSettingsFlow().flowOn(ioDispatcher).map { it.toAppSettings() }
+        settingsDoa.getSettingsFlow().flowOn(ioDispatcher).map(SettingsMapper::toAppSettings)

    override suspend fun get(): AppSettings {
        return withContext(ioDispatcher) {
-            (settingsDoa.getAll().firstOrNull() ?: Settings()).toAppSettings()
+            SettingsMapper.toAppSettings(settingsDoa.getAll().firstOrNull() ?: Settings())
        }
    }
 }
@@ -1,9 +1,9 @@
 package com.zaneschepke.wireguardautotunnel.data.repository

 import com.zaneschepke.wireguardautotunnel.data.dao.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.mapper.TunnelConfigMapper
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
 import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
 import kotlinx.coroutines.CoroutineDispatcher
@@ -17,19 +17,25 @@ class RoomTunnelRepository(
 ) : TunnelRepository {

    override val flow =
-        tunnelConfigDao.getAllFlow().flowOn(ioDispatcher).map { it.map { it.toTunnel() } }
+        tunnelConfigDao.getAllFlow().flowOn(ioDispatcher).map {
+            it.map(TunnelConfigMapper::toTunnelConf)
+        }

    override suspend fun getAll(): Tunnels {
-        return withContext(ioDispatcher) { tunnelConfigDao.getAll().map { it.toTunnel() } }
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getAll().map(TunnelConfigMapper::toTunnelConf)
+        }
    }

    override suspend fun save(tunnelConf: TunnelConf) {
-        withContext(ioDispatcher) { tunnelConfigDao.save(TunnelConfig.from(tunnelConf)) }
+        withContext(ioDispatcher) {
+            tunnelConfigDao.save(TunnelConfigMapper.toTunnelConfig(tunnelConf))
+        }
    }

    override suspend fun saveAll(tunnelConfList: List<TunnelConf>) {
        withContext(ioDispatcher) {
-            tunnelConfigDao.saveAll(tunnelConfList.map(TunnelConfig::from))
+            tunnelConfigDao.saveAll(tunnelConfList.map(TunnelConfigMapper::toTunnelConfig))
        }
    }

@@ -55,15 +61,21 @@ class RoomTunnelRepository(
    }

    override suspend fun delete(tunnelConf: TunnelConf) {
-        withContext(ioDispatcher) { tunnelConfigDao.delete(TunnelConfig.from(tunnelConf)) }
+        withContext(ioDispatcher) {
+            tunnelConfigDao.delete(TunnelConfigMapper.toTunnelConfig(tunnelConf))
+        }
    }

    override suspend fun getById(id: Int): TunnelConf? {
-        return withContext(ioDispatcher) { tunnelConfigDao.getById(id.toLong())?.toTunnel() }
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getById(id.toLong())?.let(TunnelConfigMapper::toTunnelConf)
+        }
    }

    override suspend fun getActive(): Tunnels {
-        return withContext(ioDispatcher) { tunnelConfigDao.getActive().map { it.toTunnel() } }
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getActive().map(TunnelConfigMapper::toTunnelConf)
+        }
    }

    override suspend fun count(): Int {
@@ -71,22 +83,26 @@ class RoomTunnelRepository(
    }

    override suspend fun findByTunnelName(name: String): TunnelConf? {
-        return withContext(ioDispatcher) { tunnelConfigDao.getByName(name)?.toTunnel() }
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getByName(name)?.let(TunnelConfigMapper::toTunnelConf)
+        }
    }

    override suspend fun findByTunnelNetworksName(name: String): Tunnels {
        return withContext(ioDispatcher) {
-            tunnelConfigDao.findByTunnelNetworkName(name).map { it.toTunnel() }
+            tunnelConfigDao.findByTunnelNetworkName(name).map(TunnelConfigMapper::toTunnelConf)
        }
    }

    override suspend fun findByMobileDataTunnel(): Tunnels {
        return withContext(ioDispatcher) {
-            tunnelConfigDao.findByMobileDataTunnel().map { it.toTunnel() }
+            tunnelConfigDao.findByMobileDataTunnel().map(TunnelConfigMapper::toTunnelConf)
        }
    }

    override suspend fun findPrimary(): Tunnels {
-        return withContext(ioDispatcher) { tunnelConfigDao.findByPrimary().map { it.toTunnel() } }
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.findByPrimary().map(TunnelConfigMapper::toTunnelConf)
+        }
    }
 }
@@ -4,9 +4,12 @@ import android.content.Context
 import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.logcatter.LogcatReader
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
+import com.zaneschepke.wireguardautotunnel.core.notification.NotificationMonitor
 import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.core.shortcut.DynamicShortcutManager
 import com.zaneschepke.wireguardautotunnel.core.shortcut.ShortcutManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -47,4 +50,19 @@ class AppModule {
    ): ShortcutManager {
        return DynamicShortcutManager(context, ioDispatcher)
    }
+
+    @Singleton
+    @Provides
+    fun provideNetworkUtils(@IoDispatcher ioDispatcher: CoroutineDispatcher): NetworkUtils {
+        return NetworkUtils(ioDispatcher)
+    }
+
+    @Singleton
+    @Provides
+    fun provideNotificationMonitor(
+        tunnelManager: TunnelManager,
+        notificationManager: NotificationManager,
+    ): NotificationMonitor {
+        return NotificationMonitor(tunnelManager, notificationManager)
+    }
 }
@@ -11,22 +11,14 @@ import com.zaneschepke.wireguardautotunnel.data.dao.TunnelConfigDao
 import com.zaneschepke.wireguardautotunnel.data.network.GitHubApi
 import com.zaneschepke.wireguardautotunnel.data.network.KtorClient
 import com.zaneschepke.wireguardautotunnel.data.network.KtorGitHubApi
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRoomRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.DataStoreAppStateRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.GitHubUpdateRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.RoomSettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.RoomTunnelRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.UpdateRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.*
+import com.zaneschepke.wireguardautotunnel.domain.repository.*
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
-import io.ktor.client.HttpClient
+import io.ktor.client.*
 import javax.inject.Singleton
 import kotlinx.coroutines.CoroutineDispatcher

@@ -4,15 +4,15 @@ import android.content.Context
 import com.wireguard.android.backend.WgQuickBackend
 import com.wireguard.android.util.RootShell
 import com.wireguard.android.util.ToolsInstaller
+import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
 import com.zaneschepke.networkmonitor.NetworkMonitor
+import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
-import com.zaneschepke.wireguardautotunnel.core.tunnel.KernelTunnel
-import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
-import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelProvider
-import com.zaneschepke.wireguardautotunnel.core.tunnel.UserspaceTunnel
+import com.zaneschepke.wireguardautotunnel.core.tunnel.*
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
+import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -21,7 +21,9 @@ import dagger.hilt.components.SingletonComponent
 import javax.inject.Singleton
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChangedBy
+import kotlinx.coroutines.flow.map
 import org.amnezia.awg.backend.Backend
 import org.amnezia.awg.backend.GoBackend
 import org.amnezia.awg.backend.RootTunnelActionHandler
@@ -97,6 +99,7 @@ class TunnelModule {
        appDataRepository: AppDataRepository,
        @IoDispatcher ioDispatcher: CoroutineDispatcher,
        @ApplicationScope applicationScope: CoroutineScope,
+        notificationManager: NotificationManager,
    ): TunnelManager {
        return TunnelManager(
            kernelTunnel,
@@ -112,10 +115,23 @@ class TunnelModule {
    fun provideNetworkMonitor(
        @ApplicationContext context: Context,
        settingsRepository: AppSettingRepository,
+        @ApplicationScope applicationScope: CoroutineScope,
+        @AppShell appShell: RootShell,
    ): NetworkMonitor {
-        return AndroidNetworkMonitor(context) {
-            runBlocking { settingsRepository.get().isWifiNameByShellEnabled }
-        }
+        return AndroidNetworkMonitor(
+            context,
+            object : AndroidNetworkMonitor.ConfigurationListener {
+                override val detectionMethod: Flow<AndroidNetworkMonitor.WifiDetectionMethod>
+                    get() =
+                        settingsRepository.flow
+                            .distinctUntilChangedBy { it.wifiDetectionMethod }
+                            .map { it.wifiDetectionMethod }
+
+                override val rootShell: RootShell
+                    get() = appShell
+            },
+            applicationScope,
+        )
    }

    @Singleton
@@ -135,4 +151,23 @@ class TunnelModule {
            appDataRepository,
        )
    }
+
+    @Singleton
+    @Provides
+    fun provideTunnelMonitor(
+        @ApplicationContext context: Context,
+        tunnelManager: TunnelManager,
+        networkMonitor: NetworkMonitor,
+        networkUtils: NetworkUtils,
+        logReader: LogReader,
+        appDataRepository: AppDataRepository,
+    ): TunnelMonitor {
+        return TunnelMonitor(
+            appDataRepository,
+            tunnelManager,
+            networkMonitor,
+            networkUtils,
+            logReader,
+        )
+    }
 }
@@ -10,10 +10,12 @@ sealed class TunnelStatus {

    data object Starting : TunnelStatus()

-    enum class StopReason {
-        USER,
-        PING,
-        CONFIG_CHANGED,
+    sealed class StopReason {
+        data object User : StopReason()
+
+        data class Ping(val previouslyResolvedEndpoints: Map<String, String?>) : StopReason()
+
+        data object ConfigChanged : StopReason()
    }

    fun isDown(): Boolean {
@@ -1,11 +1,18 @@
 package com.zaneschepke.wireguardautotunnel.domain.events

-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf

 sealed class AutoTunnelEvent {
    data class Start(val tunnelConf: TunnelConf? = null) : AutoTunnelEvent()

+    data class Bounce(val configsPeerKeyResolvedMap: List<Pair<TunnelConf, Map<String, String?>>>) :
+        AutoTunnelEvent()
+
    data object Stop : AutoTunnelEvent()

    data object DoNothing : AutoTunnelEvent()
+
+    data class StartKillSwitch(val allowedIps: List<String>) : AutoTunnelEvent()
+
+    data object StopKillSwitch : AutoTunnelEvent()
 }
@@ -1,6 +1,7 @@
-package com.zaneschepke.wireguardautotunnel.domain.enums
+package com.zaneschepke.wireguardautotunnel.domain.events

 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.util.StringValue

 sealed class BackendError : Exception() {
    data object DNS : BackendError()
@@ -11,23 +12,37 @@ sealed class BackendError : Exception() {

    data object KernelModuleName : BackendError()

-    data object InvalidConfig : BackendError()
-
    data object NotAuthorized : BackendError()

    data object ServiceNotRunning : BackendError()

    data object Unknown : BackendError()

+    data object TunnelNameTooLong : BackendError()
+
+    data class BounceFailed(val error: BackendError) : BackendError()
+
    fun toStringRes() =
        when (this) {
            Config -> R.string.config_error
            DNS -> R.string.dns_resolve_error
-            InvalidConfig -> R.string.invalid_config_error
            KernelModuleName -> R.string.kernel_name_error
            NotAuthorized,
            Unauthorized -> R.string.auth_error
            ServiceNotRunning -> R.string.service_running_error
            Unknown -> R.string.unknown_error
+            TunnelNameTooLong -> R.string.error_tunnel_name
+            is BounceFailed -> R.string.bounce_failed_template
        }
+
+    fun toStringValue(): StringValue {
+        return when (val backendError = this) {
+            is BounceFailed ->
+                StringValue.StringResource(
+                    backendError.toStringRes(),
+                    backendError.error.toStringRes(),
+                )
+            else -> StringValue.StringResource(backendError.toStringRes())
+        }
+    }
 }
@@ -0,0 +1,19 @@
+package com.zaneschepke.wireguardautotunnel.domain.events
+
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+
+sealed class BackendMessage {
+
+    data object BounceSuccess : BackendMessage()
+
+    data object BounceRecovery : BackendMessage()
+
+    fun toStringRes() =
+        when (this) {
+            BounceRecovery -> R.string.pinger_bounce_recovery
+            BounceSuccess -> R.string.pinger_bounce_successful
+        }
+
+    fun toStringValue() = StringValue.StringResource(this.toStringRes())
+}
@@ -1,4 +1,6 @@
-package com.zaneschepke.wireguardautotunnel.domain.entity
+package com.zaneschepke.wireguardautotunnel.domain.model
+
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor

 data class AppSettings(
    val id: Int = 0,
@@ -15,18 +17,19 @@ data class AppSettings(
    val isPingEnabled: Boolean = false,
    val isAmneziaEnabled: Boolean = false,
    val isWildcardsEnabled: Boolean = false,
-    val isWifiNameByShellEnabled: Boolean = false,
    val isStopOnNoInternetEnabled: Boolean = false,
    val isVpnKillSwitchEnabled: Boolean = false,
    val isKernelKillSwitchEnabled: Boolean = false,
    val isLanOnKillSwitchEnabled: Boolean = false,
    val debounceDelaySeconds: Int = 3,
    val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
+    val isTunnelOnUnsecureEnabled: Boolean = false,
+    val wifiDetectionMethod: AndroidNetworkMonitor.WifiDetectionMethod =
+        AndroidNetworkMonitor.WifiDetectionMethod.DEFAULT,
+    val tunnelPingIntervalSeconds: Int = 30,
+    val tunnelPingAttempts: Int = 3,
+    val tunnelPingTimeoutSeconds: Int? = null,
 ) {
-    fun debounceDelayMillis(): Long {
-        return debounceDelaySeconds * 1000L
-    }
-
    fun toAutoTunnelStateString(): String {
        return """
            TunnelOnWifi: $isTunnelOnWifiEnabled
@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.domain.entity
+package com.zaneschepke.wireguardautotunnel.domain.model

 import com.zaneschepke.wireguardautotunnel.ui.theme.Theme

@@ -9,6 +9,7 @@ data class AppState(
    val expandedTunnelIds: List<Int>,
    val isLocalLogsEnabled: Boolean,
    val isRemoteControlEnabled: Boolean,
+    val showDetailedPingStats: Boolean,
    val remoteKey: String?,
    val locale: String?,
    val theme: Theme,
@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.domain.entity
+package com.zaneschepke.wireguardautotunnel.domain.model

 data class AppUpdate(
    val version: String,
@@ -1,15 +1,10 @@
-package com.zaneschepke.wireguardautotunnel.domain.entity
+package com.zaneschepke.wireguardautotunnel.domain.model

 import com.wireguard.android.backend.Tunnel
 import com.wireguard.config.Config
-import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.extensions.*
 import java.io.InputStream
-import java.net.InetAddress
 import java.nio.charset.StandardCharsets
-import kotlin.coroutines.CoroutineContext
-import kotlinx.coroutines.withContext
-import timber.log.Timber

 data class TunnelConf(
    val id: Int = 0,
@@ -20,15 +15,16 @@ data class TunnelConf(
    val isPrimaryTunnel: Boolean = false,
    val amQuick: String,
    val isActive: Boolean = false,
-    val isPingEnabled: Boolean = false,
-    val pingInterval: Long? = null,
-    val pingCooldown: Long? = null,
-    val pingIp: String? = null,
+    val pingTarget: String? = null,
+    val restartOnPingFailure: Boolean = false,
    val isEthernetTunnel: Boolean = false,
    val isIpv4Preferred: Boolean = true,
+    val position: Int = 0,
    @Transient private var stateChangeCallback: ((Any) -> Unit)? = null,
 ) : Tunnel, org.amnezia.awg.backend.Tunnel {

+    val isNameKernelCompatible: Boolean = (name.length <= 15)
+
    fun setStateChangeCallback(callback: (Any) -> Unit) {
        stateChangeCallback = callback
    }
@@ -43,10 +39,8 @@ data class TunnelConf(
            isPrimaryTunnel == other.isPrimaryTunnel &&
            isMobileDataTunnel == other.isMobileDataTunnel &&
            isEthernetTunnel == other.isEthernetTunnel &&
-            isPingEnabled == other.isPingEnabled &&
-            pingIp == other.pingIp &&
-            pingCooldown == other.pingCooldown &&
-            pingInterval == other.pingInterval &&
+            pingTarget == other.pingTarget &&
+            restartOnPingFailure == other.restartOnPingFailure &&
            tunnelNetworks == other.tunnelNetworks &&
            isIpv4Preferred == other.isIpv4Preferred
    }
@@ -72,10 +66,8 @@ data class TunnelConf(
        isPrimaryTunnel: Boolean = this.isPrimaryTunnel,
        amQuick: String = this.amQuick,
        isActive: Boolean = this.isActive,
-        isPingEnabled: Boolean = this.isPingEnabled,
-        pingInterval: Long? = this.pingInterval,
-        pingCooldown: Long? = this.pingCooldown,
-        pingIp: String? = this.pingIp,
+        restartOnPingFailure: Boolean = this.restartOnPingFailure,
+        pingIp: String? = this.pingTarget,
        isEthernetTunnel: Boolean = this.isEthernetTunnel,
        isIpv4Preferred: Boolean = this.isIpv4Preferred,
    ): TunnelConf {
@@ -88,12 +80,11 @@ data class TunnelConf(
                isPrimaryTunnel,
                amQuick,
                isActive,
-                isPingEnabled,
-                pingInterval,
-                pingCooldown,
                pingIp,
+                restartOnPingFailure,
                isEthernetTunnel,
                isIpv4Preferred,
+                position,
            )
            .apply { stateChangeCallback = this@TunnelConf.stateChangeCallback }
    }
@@ -134,21 +125,6 @@ data class TunnelConf(
        return tunnelName
    }

-    suspend fun isTunnelPingable(context: CoroutineContext): Boolean {
-        return withContext(context) {
-            val config = toWgConfig()
-            if (pingIp != null) {
-                return@withContext InetAddress.getByName(pingIp)
-                    .isReachable(Constants.PING_TIMEOUT.toInt())
-                    .also { Timber.i("Ping reachable $pingIp: $it") }
-            }
-            config.peers
-                .map { peer -> peer.isReachable() }
-                .all { true }
-                .also { Timber.i("Ping of all peers reachable: $it") }
-        }
-    }
-
    companion object {
        fun configFromWgQuick(wgQuick: String): Config {
            val inputStream: InputStream = wgQuick.byteInputStream()
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.domain.repository

-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf

 interface AppDataRepository {
    suspend fun getPrimaryOrFirstTunnel(): TunnelConf?
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.domain.repository

-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import kotlinx.coroutines.flow.Flow

 interface AppSettingRepository {
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.domain.repository

-import com.zaneschepke.wireguardautotunnel.domain.entity.AppState
+import com.zaneschepke.wireguardautotunnel.domain.model.AppState
 import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
 import kotlinx.coroutines.flow.Flow

@@ -41,5 +41,9 @@ interface AppStateRepository {

    suspend fun getRemoteKey(): String?

+    suspend fun setShowDetailedPingStats(showDetailedPing: Boolean)
+
+    suspend fun getShowDetailedPing(): Boolean
+
    val flow: Flow<AppState>
 }
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.domain.repository

-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
 import kotlinx.coroutines.flow.Flow

@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.domain.repository

-import com.zaneschepke.wireguardautotunnel.domain.entity.AppUpdate
+import com.zaneschepke.wireguardautotunnel.domain.model.AppUpdate
 import java.io.File

 interface UpdateRepository {
@@ -1,12 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.domain.state

-import com.zaneschepke.wireguardautotunnel.core.tunnel.allDown
-import com.zaneschepke.wireguardautotunnel.core.tunnel.hasActive
-import com.zaneschepke.wireguardautotunnel.core.tunnel.isUp
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.core.service.autotunnel.StateChange
 import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent
-import com.zaneschepke.wireguardautotunnel.domain.events.KillSwitchEvent
+import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent.*
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.util.extensions.isMatchingToWildcardList

 data class AutoTunnelState(
@@ -16,6 +14,68 @@ data class AutoTunnelState(
    val tunnels: List<TunnelConf> = emptyList(),
 ) {

+    fun determineAutoTunnelEvent(stateChange: StateChange): AutoTunnelEvent {
+        when (val change = stateChange) {
+            is StateChange.NetworkChange,
+            is StateChange.SettingsChange -> {
+                // Compute desired tunnel based on network conditions
+                var desiredTunnel: TunnelConf? = null
+                if (networkState.isEthernetConnected && settings.isTunnelOnEthernetEnabled) {
+                    desiredTunnel = preferredEthernetTunnel()
+                } else if (isMobileDataActive() && settings.isTunnelOnMobileDataEnabled) {
+                    desiredTunnel = preferredMobileDataTunnel()
+                } else if (
+                    isWifiActive() && settings.isTunnelOnWifiEnabled && !isCurrentSSIDTrusted()
+                ) {
+                    desiredTunnel = preferredWifiTunnel()
+                }
+
+                // Override for no connectivity if enabled
+                if (isNoConnectivity() && settings.isStopOnNoInternetEnabled) {
+                    desiredTunnel = null
+                }
+
+                // Determine current active tunnel (assuming only one can be active)
+                val currentTunnel = activeTunnels.entries.firstOrNull()?.key
+
+                // Handle tunnel start/stop/change
+                if (desiredTunnel != null) {
+                    if (currentTunnel != desiredTunnel) {
+                        // Start or switch to the desired tunnel (overrides any kill switch)
+                        return Start(desiredTunnel)
+                    }
+                    // If already active and matching, fall through to kill switch check (though
+                    // unlikely needed)
+                } else {
+                    if (currentTunnel != null) {
+                        // Stop the active tunnel (then next emission can handle kill switch if
+                        // needed)
+                        return AutoTunnelEvent.Stop
+                    }
+                }
+                // Handle kill switch only if no user tunnel is or will be active
+                if (stopKillSwitchOnTrusted()) {
+                    return AutoTunnelEvent.StopKillSwitch
+                }
+                if (startKillSwitch()) {
+                    val allowedIps =
+                        if (settings.isLanOnKillSwitchEnabled) TunnelConf.LAN_BYPASS_ALLOWED_IPS
+                        else emptyList()
+                    return StartKillSwitch(allowedIps)
+                }
+            }
+            is StateChange.MonitoringChange -> {
+                val bounceTunnels = bounceOnPingFailed()
+                if (bounceTunnels.isNotEmpty()) {
+                    return Bounce(bounceTunnels)
+                }
+            }
+
+            is StateChange.ActiveTunnelsChange -> Unit
+        }
+        return DoNothing
+    }
+
    // also need to check for Wi-Fi state as there is some overlap when they are both connected
    private fun isMobileDataActive(): Boolean {
        return !networkState.isEthernetConnected &&
@@ -23,32 +83,22 @@ data class AutoTunnelState(
            networkState.isMobileDataConnected
    }

-    private fun isMobileTunnelDataChangeNeeded(): Boolean {
-        val preferredTunnel = preferredMobileDataTunnel()
-        return preferredTunnel != null &&
-            activeTunnels.isNotEmpty() &&
-            !activeTunnels.isUp(preferredTunnel)
-    }
-
-    private fun isEthernetTunnelChangeNeeded(): Boolean {
-        val preferredTunnel = preferredEthernetTunnel()
-        return preferredTunnel != null &&
-            activeTunnels.isNotEmpty() &&
-            !activeTunnels.isUp(preferredTunnel)
-    }
-
    private fun preferredMobileDataTunnel(): TunnelConf? {
        return tunnels.firstOrNull { it.isMobileDataTunnel }
            ?: tunnels.firstOrNull { it.isPrimaryTunnel }
+            ?: tunnels.firstOrNull()
    }

    private fun preferredEthernetTunnel(): TunnelConf? {
        return tunnels.firstOrNull { it.isEthernetTunnel }
            ?: tunnels.firstOrNull { it.isPrimaryTunnel }
+            ?: tunnels.firstOrNull()
    }

    private fun preferredWifiTunnel(): TunnelConf? {
-        return getTunnelWithMatchingTunnelNetwork() ?: tunnels.firstOrNull { it.isPrimaryTunnel }
+        return getTunnelWithMatchingTunnelNetwork()
+            ?: tunnels.firstOrNull { it.isPrimaryTunnel }
+            ?: tunnels.firstOrNull()
    }

    // ignore cellular state as there is overlap where it may still be active, but not prioritized
@@ -56,19 +106,6 @@ data class AutoTunnelState(
        return !networkState.isEthernetConnected && networkState.isWifiConnected
    }

-    private fun startOnEthernet(): Boolean {
-        return networkState.isEthernetConnected &&
-            settings.isTunnelOnEthernetEnabled &&
-            activeTunnels.allDown()
-    }
-
-    private fun stopOnEthernet(): Boolean {
-        return networkState.isEthernetConnected &&
-            !settings.isTunnelOnEthernetEnabled &&
-            activeTunnels.hasActive()
-    }
-
-    // TODO test removed kill switch state check
    private fun stopKillSwitchOnTrusted(): Boolean {
        return networkState.isWifiConnected &&
            settings.isVpnKillSwitchEnabled &&
@@ -76,7 +113,6 @@ data class AutoTunnelState(
            isCurrentSSIDTrusted()
    }

-    // TODO test, removed kill switch state check
    private fun startKillSwitch(): Boolean {
        return settings.isVpnKillSwitchEnabled &&
            (!settings.isDisableKillSwitchOnTrustedEnabled || !isCurrentSSIDTrusted())
@@ -88,93 +124,21 @@ data class AutoTunnelState(
            !networkState.isMobileDataConnected
    }

-    private fun stopOnMobileData(): Boolean {
-        return isMobileDataActive() &&
-            !settings.isTunnelOnMobileDataEnabled &&
-            activeTunnels.hasActive()
-    }
-
-    private fun startOnMobileData(): Boolean {
-        return isMobileDataActive() &&
-            settings.isTunnelOnMobileDataEnabled &&
-            activeTunnels.allDown()
-    }
-
-    private fun changeOnMobileData(): Boolean {
-        return isMobileDataActive() &&
-            settings.isTunnelOnMobileDataEnabled &&
-            isMobileTunnelDataChangeNeeded()
-    }
-
-    private fun changeOnEthernet(): Boolean {
-        return networkState.isEthernetConnected &&
-            settings.isTunnelOnEthernetEnabled &&
-            isEthernetTunnelChangeNeeded()
-    }
-
-    private fun stopOnWifi(): Boolean {
-        return isWifiActive() && !settings.isTunnelOnWifiEnabled && activeTunnels.hasActive()
-    }
-
-    private fun stopOnTrustedWifi(): Boolean {
-        return isWifiActive() &&
-            settings.isTunnelOnWifiEnabled &&
-            activeTunnels.hasActive() &&
-            isCurrentSSIDTrusted()
-    }
-
-    private fun startOnUntrustedWifi(): Boolean {
-        return isWifiActive() &&
-            settings.isTunnelOnWifiEnabled &&
-            activeTunnels.allDown() &&
-            !isCurrentSSIDTrusted()
-    }
-
-    private fun changeOnUntrustedWifi(): Boolean {
-        return isWifiActive() &&
-            settings.isTunnelOnWifiEnabled &&
-            activeTunnels.hasActive() &&
-            !isCurrentSSIDTrusted() &&
-            !isWifiTunnelPreferred()
-    }
-
-    private fun isWifiTunnelPreferred(): Boolean {
-        val preferred = preferredWifiTunnel()
-        return preferred?.let { activeTunnels.isUp(it) } ?: true
-    }
-
-    fun asAutoTunnelEvent(): AutoTunnelEvent {
-        return when {
-            // ethernet scenarios
-            stopOnEthernet() -> AutoTunnelEvent.Stop
-            startOnEthernet() || changeOnEthernet() ->
-                AutoTunnelEvent.Start(preferredEthernetTunnel())
-            // mobile data scenarios
-            stopOnMobileData() -> AutoTunnelEvent.Stop
-            startOnMobileData() || changeOnMobileData() ->
-                AutoTunnelEvent.Start(preferredMobileDataTunnel())
-            // wifi scenarios
-            stopOnWifi() -> AutoTunnelEvent.Stop
-            stopOnTrustedWifi() -> AutoTunnelEvent.Stop
-            startOnUntrustedWifi() || changeOnUntrustedWifi() ->
-                AutoTunnelEvent.Start(preferredWifiTunnel())
-            // no connectivity
-            isNoConnectivity() && settings.isStopOnNoInternetEnabled -> AutoTunnelEvent.Stop
-            else -> AutoTunnelEvent.DoNothing
-        }
-    }
-
-    fun asKillSwitchEvent(): KillSwitchEvent {
-        return when {
-            stopKillSwitchOnTrusted() -> KillSwitchEvent.Stop
-            startKillSwitch() -> {
-                val allowedIps =
-                    if (settings.isLanOnKillSwitchEnabled) TunnelConf.LAN_BYPASS_ALLOWED_IPS
-                    else emptyList()
-                KillSwitchEvent.Start(allowedIps)
+    private fun bounceOnPingFailed(): List<Pair<TunnelConf, Map<String, String?>>> {
+        return activeTunnels.entries
+            .filter { (tunnel, state) ->
+                tunnel.restartOnPingFailure &&
+                    (state.pingStates?.any { (key, pingState) ->
+                        pingState.failureReason == FailureReason.PingFailed
+                    } ?: false)
+            }
+            .map { (tunnel, state) ->
+                val peerMap =
+                    (state.statistics?.getPeers()?.associate { peerKey ->
+                        peerKey.toBase64() to state.statistics.peerStats(peerKey)?.resolvedEndpoint
+                    } ?: emptyMap())
+                Pair(tunnel, peerMap)
            }
-            else -> KillSwitchEvent.DoNothing
-        }
    }

    private fun isCurrentSSIDTrusted(): Boolean {
@@ -1,12 +1,38 @@
 package com.zaneschepke.wireguardautotunnel.domain.state

+import com.zaneschepke.networkmonitor.ConnectivityState
+import com.zaneschepke.networkmonitor.util.WifiSecurityType
+
 data class NetworkState(
    val isWifiConnected: Boolean = false,
    val isMobileDataConnected: Boolean = false,
    val isEthernetConnected: Boolean = false,
    val wifiName: String? = null,
+    val isWifiSecure: Boolean? = null,
+    val locationServicesEnabled: Boolean? = null,
+    val locationPermissionGranted: Boolean? = null,
 ) {
    fun hasNoCapabilities(): Boolean {
        return !isWifiConnected && !isMobileDataConnected && !isEthernetConnected
    }
+
+    companion object {
+        fun from(connectivityState: ConnectivityState): NetworkState {
+            return NetworkState(
+                isWifiSecure =
+                    when (connectivityState.wifiState.securityType) {
+                        WifiSecurityType.OPEN,
+                        WifiSecurityType.UNKNOWN -> false
+                        null -> null
+                        else -> true
+                    },
+                isWifiConnected = connectivityState.wifiState.connected,
+                isMobileDataConnected = connectivityState.cellularConnected,
+                isEthernetConnected = connectivityState.ethernetConnected,
+                wifiName = connectivityState.wifiState.ssid,
+                locationPermissionGranted = connectivityState.wifiState.locationPermissionsGranted,
+                locationServicesEnabled = connectivityState.wifiState.locationServicesEnabled,
+            )
+        }
+    }
 }
@@ -0,0 +1,26 @@
+package com.zaneschepke.wireguardautotunnel.domain.state
+
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor.Companion.CLOUDFLARE_IPV4_IP
+
+enum class FailureReason {
+    NoConnectivity,
+    PingFailed,
+    NoResolvedEndpoint,
+    Timeout,
+    Unknown,
+}
+
+data class PingState(
+    val transmitted: Int = 0,
+    val received: Int = 0,
+    val packetLoss: Double = 0.0,
+    val rttMin: Double = 0.0,
+    val rttMax: Double = 0.0,
+    val rttAvg: Double = 0.0,
+    val rttStddev: Double = 0.0,
+    val isReachable: Boolean = false,
+    val lastSuccessfulPingMillis: Long? = null,
+    val lastPingAttemptMillis: Long? = null,
+    val failureReason: FailureReason? = null,
+    val pingTarget: String = CLOUDFLARE_IPV4_IP,
+)
@@ -2,9 +2,12 @@ package com.zaneschepke.wireguardautotunnel.domain.state

 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import org.amnezia.awg.crypto.Key

 data class TunnelState(
    val status: TunnelStatus = TunnelStatus.Down,
    val backendState: BackendState = BackendState.INACTIVE,
    val statistics: TunnelStatistics? = null,
+    val pingStates: Map<Key, PingState>? = null,
+    val handshakeSuccessLogs: Boolean? = null,
 )
@@ -3,13 +3,24 @@ package com.zaneschepke.wireguardautotunnel.domain.state
 import org.amnezia.awg.crypto.Key

 abstract class TunnelStatistics {
-    @JvmRecord
-    data class PeerStats(
+    open class PeerStats(
        val rxBytes: Long,
        val txBytes: Long,
        val latestHandshakeEpochMillis: Long,
        val resolvedEndpoint: String,
-    )
+    ) {
+        // mimic data class copy
+        open fun copy(
+            rxBytes: Long = this.rxBytes,
+            txBytes: Long = this.txBytes,
+            latestHandshakeEpochMillis: Long = this.latestHandshakeEpochMillis,
+            resolvedEndpoint: String = this.resolvedEndpoint,
+        ): PeerStats = PeerStats(rxBytes, txBytes, latestHandshakeEpochMillis, resolvedEndpoint)
+
+        // Manual toString: Format like data class
+        override fun toString(): String =
+            "PeerStats(rxBytes=$rxBytes, txBytes=$txBytes, latestHandshakeEpochMillis=$latestHandshakeEpochMillis, resolvedEndpoint=$resolvedEndpoint)"
+    }

    abstract fun peerStats(peer: Key): PeerStats?

@@ -13,6 +13,8 @@ sealed class Route {

    @Serializable data object AutoTunnelAdvanced : Route()

+    @Serializable data object WifiDetectionMethod : Route()
+
    @Serializable data object LocationDisclosure : Route()

    @Serializable data object Appearance : Route()
@@ -43,4 +45,8 @@ sealed class Route {
    @Serializable data class TunnelAutoTunnel(val id: Int) : Route()

    @Serializable data object Logs : Route()
+
+    @Serializable data object Sort : Route()
+
+    @Serializable data object TunnelMonitoring : Route()
 }
@@ -3,68 +3,41 @@ package com.zaneschepke.wireguardautotunnel.ui.common
 import androidx.compose.animation.animateContentSize
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.background
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.indication
-import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
-import androidx.compose.material3.ripple
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV

@OptIn(ExperimentalFoundationApi::class)
@Composable
 fun ExpandingRowListItem(
    leading: @Composable () -> Unit,
    text: String,
-    onHold: () -> Unit,
-    onClick: () -> Unit,
-    onDoubleClick: () -> Unit,
    trailing: @Composable () -> Unit,
    isSelected: Boolean,
-    expanded: (@Composable () -> Unit)?,
+    expanded: @Composable () -> Unit,
+    modifier: Modifier = Modifier,
 ) {
-    val isTv = LocalIsAndroidTV.current
-    val haptic = LocalHapticFeedback.current
-    val interactionSource = remember { MutableInteractionSource() }
-
    Box(
        modifier =
-            Modifier.animateContentSize()
+            modifier
+                .animateContentSize()
                .clip(RoundedCornerShape(8.dp))
                .background(
                    if (isSelected) MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
                    else Color.Transparent
                )
-                .then(
-                    if (!isTv) {
-                        Modifier.combinedClickable(
-                            interactionSource = interactionSource,
-                            indication = ripple(),
-                            onClick = onClick,
-                            onLongClick = {
-                                haptic.performHapticFeedback(HapticFeedbackType.LongPress)
-                                onHold()
-                            },
-                            onDoubleClick = onDoubleClick,
-                        )
-                    } else Modifier
-                )
    ) {
        Column {
            Row(
-                modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp),
+                modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp).height(48.dp),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.SpaceBetween,
            ) {
@@ -84,7 +57,7 @@ fun ExpandingRowListItem(
                }
                trailing()
            }
-            expanded?.invoke()
+            expanded()
        }
    }
 }
@@ -1,10 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.common.animation

-import androidx.compose.animation.core.LinearEasing
-import androidx.compose.animation.core.animateFloat
-import androidx.compose.animation.core.infiniteRepeatable
-import androidx.compose.animation.core.rememberInfiniteTransition
-import androidx.compose.animation.core.tween
+import androidx.compose.animation.core.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Modifier
@@ -0,0 +1,74 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.banner
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Warning
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.theme.Straw
+
+@Composable
+fun WarningBanner(
+    title: String,
+    visible: Boolean,
+    modifier: Modifier = Modifier,
+    trailing: (@Composable () -> Unit)? = null,
+) {
+    AnimatedVisibility(visible = visible, enter = expandVertically(), exit = shrinkVertically()) {
+        Surface(
+            color = MaterialTheme.colorScheme.secondary,
+            modifier = modifier.fillMaxWidth().clip(RoundedCornerShape(8.dp)),
+        ) {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp).padding(start = 2.dp),
+            ) {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(12.dp, Alignment.Start),
+                    modifier = Modifier.weight(4f, false).fillMaxWidth(),
+                ) {
+                    Icon(
+                        Icons.Outlined.Warning,
+                        stringResource(R.string.warning),
+                        Modifier.size(18.dp),
+                        tint = Straw,
+                    )
+                    Column(
+                        horizontalAlignment = Alignment.Start,
+                        verticalArrangement =
+                            Arrangement.spacedBy(2.dp, Alignment.CenterVertically),
+                        modifier = Modifier.fillMaxWidth().weight(1f).padding(start = 6.dp),
+                    ) {
+                        Text(
+                            title,
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurface,
+                        )
+                    }
+                }
+                trailing?.let {
+                    Box(
+                        contentAlignment = Alignment.CenterEnd,
+                        modifier = Modifier.padding(start = 16.dp),
+                    ) {
+                        it()
+                    }
+                }
+            }
+        }
+    }
+}
@@ -3,11 +3,7 @@ package com.zaneschepke.wireguardautotunnel.ui.common.button
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.size
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
+import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
@@ -2,34 +2,23 @@ package com.zaneschepke.wireguardautotunnel.ui.common.button

 import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.IntrinsicSize
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize

@androidx.compose.runtime.Composable
 fun IconSurfaceButton(
    title: String,
    onClick: () -> Unit,
    selected: Boolean,
-    leadingIcon: ImageVector? = null,
+    leading: (@Composable () -> Unit)? = null,
    description: String? = null,
 ) {
    val border: BorderStroke? =
@@ -64,16 +53,8 @@ fun IconSurfaceButton(
                        modifier =
                            Modifier.padding(vertical = if (description == null) 10.dp else 0.dp),
                    ) {
-                        leadingIcon?.let {
-                            Icon(
-                                leadingIcon,
-                                leadingIcon.name,
-                                Modifier.size(iconSize),
-                                if (selected) MaterialTheme.colorScheme.primary
-                                else MaterialTheme.colorScheme.onSurface,
-                            )
-                        }
-                        Column {
+                        leading?.invoke()
+                        Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
                            Text(title, style = MaterialTheme.typography.titleMedium)
                            description?.let {
                                Text(
@@ -2,18 +2,9 @@ package com.zaneschepke.wireguardautotunnel.ui.common.button

 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.material3.ripple
+import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
@@ -1,13 +1,15 @@
 package com.zaneschepke.wireguardautotunnel.ui.common.button.surface

+import androidx.compose.foundation.layout.height
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp

 data class SelectionItem(
-    val leadingIcon: ImageVector? = null,
+    val leading: (@Composable () -> Unit)? = null,
    val trailing: (@Composable () -> Unit)? = null,
    val title: (@Composable () -> Unit),
    val description: (@Composable () -> Unit)? = null,
    val onClick: (() -> Unit)? = null,
-    val height: Int = 64,
+    val modifier: Modifier = Modifier.height(64.dp),
 )
@@ -5,19 +5,18 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize

@Composable
-fun SurfaceSelectionGroupButton(items: List<SelectionItem>) {
+fun SurfaceSelectionGroupButton(items: List<SelectionItem>, modifier: Modifier = Modifier) {
+
    Card(
-        modifier = Modifier.fillMaxWidth(),
+        modifier = modifier.fillMaxWidth(),
        shape = RoundedCornerShape(8.dp),
        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
    ) {
@@ -25,9 +24,10 @@ fun SurfaceSelectionGroupButton(items: List<SelectionItem>) {
            Box(
                contentAlignment = Alignment.Center,
                modifier =
-                    Modifier.fillMaxWidth()
+                    modifier
+                        .fillMaxWidth()
                        .clip(RoundedCornerShape(8.dp))
-                        .then(item.onClick?.let { Modifier.clickable { it() } } ?: Modifier),
+                        .then(item.onClick?.let { modifier.clickable { it() } } ?: modifier),
            ) {
                Row(
                    verticalAlignment = Alignment.CenterVertically,
@@ -37,21 +37,14 @@ fun SurfaceSelectionGroupButton(items: List<SelectionItem>) {
                        verticalAlignment = Alignment.CenterVertically,
                        modifier = Modifier.weight(4f, false).fillMaxWidth(),
                    ) {
-                        item.leadingIcon?.let { icon ->
-                            Icon(
-                                icon,
-                                icon.name,
-                                modifier = Modifier.size(iconSize),
-                                tint = MaterialTheme.colorScheme.onSurface,
-                            )
-                        }
+                        item.leading?.invoke()
                        Column(
                            horizontalAlignment = Alignment.Start,
                            verticalArrangement =
                                Arrangement.spacedBy(2.dp, Alignment.CenterVertically),
                            modifier =
                                Modifier.fillMaxWidth()
-                                    .padding(start = if (item.leadingIcon != null) 16.dp else 0.dp)
+                                    .padding(start = if (item.leading != null) 16.dp else 0.dp)
                                    .weight(1f)
                                    .padding(
                                        vertical = if (item.description == null) 16.dp else 6.dp
@@ -12,11 +12,7 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
@@ -32,6 +28,7 @@ fun SubmitConfigurationTextBox(
    hint: String,
    isErrorValue: (value: String?) -> Boolean,
    onSubmit: (value: String) -> Unit,
+    supportingText: @Composable (() -> Unit)? = null,
    keyboardOptions: KeyboardOptions =
        KeyboardOptions(capitalization = KeyboardCapitalization.None, imeAction = ImeAction.Done),
 ) {
@@ -49,6 +46,7 @@ fun SubmitConfigurationTextBox(
        value = stateValue,
        onValueChange = { stateValue = it },
        interactionSource = interactionSource,
+        supportingText = supportingText,
        label = {
            Text(
                label,
@@ -1,10 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.common.dialog

-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
+import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -1,4 +1,4 @@
-package com.zaneschepke.wireguardautotunnel.ui.common
+package com.zaneschepke.wireguardautotunnel.ui.common.dropdown

 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -6,11 +6,7 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowDropDown
-import androidx.compose.material3.DropdownMenu
-import androidx.compose.material3.DropdownMenuItem
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
+import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -20,9 +16,9 @@ import com.zaneschepke.wireguardautotunnel.R

@Composable
 fun <T> DropdownSelector(
-    currentValue: T,
-    options: List<T>,
-    onValueSelected: (T) -> Unit,
+    currentValue: T?,
+    options: List<T?>,
+    onValueSelected: (T?) -> Unit,
    modifier: Modifier = Modifier,
    label: @Composable (() -> Unit)? = null,
    isExpanded: Boolean = false,
@@ -33,7 +29,10 @@ fun <T> DropdownSelector(
        verticalAlignment = Alignment.CenterVertically,
    ) {
        if (label != null) label()
-        Text(text = currentValue.toString(), style = MaterialTheme.typography.bodyMedium)
+        Text(
+            text = currentValue?.toString() ?: stringResource(R.string._default),
+            style = MaterialTheme.typography.bodyMedium,
+        )
        Icon(Icons.Default.ArrowDropDown, contentDescription = stringResource(R.string.dropdown))
    }
    DropdownMenu(
@@ -44,11 +43,20 @@ fun <T> DropdownSelector(
        onDismissRequest = onDismiss,
    ) {
        options.forEach { option ->
+            if (option == null) {
+                return@forEach DropdownMenuItem(
+                    text = { Text(text = stringResource(R.string._default)) },
+                    onClick = {
+                        onValueSelected(null)
+                        onDismiss()
+                    },
+                )
+            }
            DropdownMenuItem(
                text = { Text(text = option.toString()) },
                onClick = {
                    onValueSelected(option)
-                    onDismiss() // Close dropdown after selection
+                    onDismiss()
                },
            )
        }
@@ -0,0 +1,36 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.dropdown
+
+import androidx.compose.runtime.*
+import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
+import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
+
+@Composable
+fun LabelledNumberDropdown(
+    title: @Composable () -> Unit,
+    description: (@Composable () -> Unit)? = null,
+    leading: @Composable () -> Unit,
+    onSelected: (Int?) -> Unit,
+    options: List<Int?>,
+    currentValue: Int?,
+) {
+    var isDropDownExpanded by remember { mutableStateOf(false) }
+    SurfaceSelectionGroupButton(
+        listOf(
+            SelectionItem(
+                leading = leading,
+                title = title,
+                description = description,
+                onClick = { isDropDownExpanded = true },
+                trailing = {
+                    DropdownSelector(
+                        currentValue = currentValue,
+                        options = options,
+                        onValueSelected = { num -> onSelected(num) },
+                        isExpanded = isDropDownExpanded,
+                        onDismiss = { isDropDownExpanded = false },
+                    )
+                },
+            )
+        )
+    )
+}
@@ -1,12 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.common.snackbar

-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.IntrinsicSize
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Info
@@ -10,7 +10,6 @@ import androidx.compose.material.icons.rounded.QuestionMark
 import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
@@ -21,7 +20,6 @@ import androidx.navigation.compose.currentBackStackEntryAsState
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.navigation.BottomNavItem
-import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
 import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.navigation.isCurrentRoute
 import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
@@ -32,7 +30,6 @@ import com.zaneschepke.wireguardautotunnel.util.extensions.goFromRoot
@Composable
 fun BottomNavbar(appUiState: AppUiState) {
    val navController = LocalNavController.current
-    val isTv = LocalIsAndroidTV.current
    val navBackStackEntry by navController.currentBackStackEntryAsState()

    val items =
@@ -49,8 +46,9 @@ fun BottomNavbar(appUiState: AppUiState) {
                icon = Icons.Rounded.Bolt,
                onClick = {
                    val route =
-                        if (appUiState.appState.isLocationDisclosureShown) Route.AutoTunnel
-                        else Route.LocationDisclosure
+                        if (appUiState.appState.isLocationDisclosureShown) {
+                            Route.AutoTunnel
+                        } else Route.LocationDisclosure
                    navController.goFromRoot(route)
                },
                active = appUiState.isAutoTunnelActive,
@@ -68,53 +66,42 @@ fun BottomNavbar(appUiState: AppUiState) {
                onClick = { navController.goFromRoot(Route.Support) },
            ),
        )
-    // Define ripple configuration based on platform
-    val rippleConfiguration =
-        if (isTv) {
-            RippleConfiguration()
-        } else {
-            null
-        }

-    // Apply ripple configuration only if needed
-    CompositionLocalProvider(LocalRippleConfiguration provides rippleConfiguration) {
-        NavigationBar(containerColor = MaterialTheme.colorScheme.surface) {
-            items.forEach { item ->
-                val isSelected = navBackStackEntry.isCurrentRoute(item.route::class)
-                val interactionSource = remember { MutableInteractionSource() }
+    NavigationBar(containerColor = MaterialTheme.colorScheme.surface) {
+        items.forEach { item ->
+            val isSelected = navBackStackEntry.isCurrentRoute(item.route::class)
+            val interactionSource = remember { MutableInteractionSource() }

-                NavigationBarItem(
-                    icon = {
-                        if (item.active) {
-                            BadgedBox(
-                                badge = {
-                                    Badge(
-                                        modifier =
-                                            Modifier.offset(x = 8.dp, y = (-8).dp).size(6.dp),
-                                        containerColor = SilverTree,
-                                    )
-                                }
-                            ) {
-                                Icon(imageVector = item.icon, contentDescription = item.name)
+            NavigationBarItem(
+                icon = {
+                    if (item.active) {
+                        BadgedBox(
+                            badge = {
+                                Badge(
+                                    modifier = Modifier.offset(x = 8.dp, y = (-8).dp).size(6.dp),
+                                    containerColor = SilverTree,
+                                )
                            }
-                        } else {
+                        ) {
                            Icon(imageVector = item.icon, contentDescription = item.name)
                        }
-                    },
-                    onClick = { navController.goFromRoot(item.route) },
-                    selected = isSelected,
-                    enabled = true,
-                    label = null,
-                    alwaysShowLabel = false,
-                    colors =
-                        NavigationBarItemDefaults.colors(
-                            selectedIconColor = MaterialTheme.colorScheme.primary,
-                            unselectedIconColor = MaterialTheme.colorScheme.onBackground,
-                            indicatorColor = Color.Transparent,
-                        ),
-                    interactionSource = interactionSource,
-                )
-            }
+                    } else {
+                        Icon(imageVector = item.icon, contentDescription = item.name)
+                    }
+                },
+                onClick = item.onClick,
+                selected = isSelected,
+                enabled = true,
+                label = null,
+                alwaysShowLabel = false,
+                colors =
+                    NavigationBarItemDefaults.colors(
+                        selectedIconColor = MaterialTheme.colorScheme.primary,
+                        unselectedIconColor = MaterialTheme.colorScheme.onBackground,
+                        indicatorColor = Color.Transparent,
+                    ),
+                interactionSource = interactionSource,
+            )
        }
    }
 }
@@ -4,6 +4,7 @@ import android.os.Build
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.rounded.Sort
 import androidx.compose.material.icons.rounded.*
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -11,6 +12,7 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.State
 import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
@@ -23,11 +25,10 @@ import com.zaneschepke.wireguardautotunnel.ui.navigation.isCurrentRoute
 import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.ui.state.AppViewState
 import com.zaneschepke.wireguardautotunnel.ui.state.NavBarState
-import com.zaneschepke.wireguardautotunnel.ui.theme.Brick
-import com.zaneschepke.wireguardautotunnel.ui.theme.SilverTree
 import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
 import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
 import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.UiEvent

@Composable
 fun currentNavBackStackEntryAsNavBarState(
@@ -60,35 +61,40 @@ fun currentNavBackStackEntryAsNavBarState(

        Row {
            if (selectedCount == 0) {
+                val showSort = remember(uiState.tunnels) { uiState.tunnels.size > 1 }
+                if (showSort)
+                    ActionIconButton(Icons.AutoMirrored.Rounded.Sort, R.string.sort) {
+                        navController.navigate(Route.Sort)
+                    }
                ActionIconButton(Icons.Rounded.Add, R.string.add_tunnel) {
                    viewModel.handleEvent(
                        AppEvent.SetBottomSheet(AppViewState.BottomSheet.IMPORT_TUNNELS)
                    )
                }
-            } else {
-                ActionIconButton(Icons.Rounded.SelectAll, R.string.select_all) {
-                    viewModel.handleEvent(AppEvent.ToggleSelectAllTunnels)
-                }
-                // due to permissions, and SAF issues on TV, not support less than Android 10 on
-                // Android TV for file exports
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                    ActionIconButton(Icons.Rounded.Download, R.string.download) {
-                        viewModel.handleEvent(
-                            AppEvent.SetBottomSheet(AppViewState.BottomSheet.EXPORT_TUNNELS)
-                        )
-                    }
+                return@Row
+            }
+            ActionIconButton(Icons.Rounded.SelectAll, R.string.select_all) {
+                viewModel.handleEvent(AppEvent.ToggleSelectAllTunnels)
+            }
+            // due to permissions, and SAF issues on TV, not support less than Android 10 on
+            // Android TV for file exports
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                ActionIconButton(Icons.Rounded.Download, R.string.download) {
+                    viewModel.handleEvent(
+                        AppEvent.SetBottomSheet(AppViewState.BottomSheet.EXPORT_TUNNELS)
+                    )
                }
+            }

-                if (selectedCount == 1) {
-                    ActionIconButton(Icons.Rounded.CopyAll, R.string.copy) {
-                        viewModel.handleEvent(AppEvent.CopySelectedTunnel)
-                    }
+            if (selectedCount == 1) {
+                ActionIconButton(Icons.Rounded.CopyAll, R.string.copy) {
+                    viewModel.handleEvent(AppEvent.CopySelectedTunnel)
                }
+            }

-                if (showDelete) {
-                    ActionIconButton(Icons.Rounded.Delete, R.string.delete_tunnel) {
-                        viewModel.handleEvent(AppEvent.SetShowModal(AppViewState.ModalType.DELETE))
-                    }
+            if (showDelete) {
+                ActionIconButton(Icons.Rounded.Delete, R.string.delete_tunnel) {
+                    viewModel.handleEvent(AppEvent.SetShowModal(AppViewState.ModalType.DELETE))
                }
            }
        }
@@ -104,8 +110,6 @@ fun currentNavBackStackEntryAsNavBarState(
            when {
                backStackEntry.isCurrentRoute(Route.Main::class) -> {
                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.tunnels)) },
                        topTrailing = { TunnelActionBar() },
                        route = Route.Main,
@@ -113,36 +117,15 @@ fun currentNavBackStackEntryAsNavBarState(
                }

                backStackEntry.isCurrentRoute(Route.AutoTunnel::class) -> {
-                    val (icon, label, tint) =
-                        if (uiState.appSettings.isAutoTunnelEnabled) {
-                            Triple(Icons.Rounded.Stop, R.string.stop_auto, Brick)
-                        } else {
-                            Triple(Icons.Rounded.PlayArrow, R.string.start_auto, SilverTree)
-                        }

                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.auto_tunnel)) },
-                        topTrailing = {
-                            IconButton(
-                                onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnel) }
-                            ) {
-                                Icon(
-                                    icon,
-                                    stringResource(label),
-                                    tint = tint,
-                                    modifier = Modifier.size(iconSize),
-                                )
-                            }
-                        },
                        route = Route.AutoTunnel,
                    )
                }

                backStackEntry.isCurrentRoute(Route.Logs::class) -> {
                    NavBarState(
-                        showTop = true,
                        showBottom = false,
                        topTitle = { Text(stringResource(R.string.logs)) },
                        topTrailing = {
@@ -158,52 +141,80 @@ fun currentNavBackStackEntryAsNavBarState(

                backStackEntry.isCurrentRoute(Route.Settings::class) ->
                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.settings)) },
                        route = Route.Settings,
+                        topTrailing = {
+                            ActionIconButton(Icons.Rounded.Menu, R.string.quick_actions) {
+                                viewModel.handleEvent(
+                                    AppEvent.SetBottomSheet(
+                                        AppViewState.BottomSheet.BACKUP_AND_RESTORE
+                                    )
+                                )
+                            }
+                        },
                    )

                backStackEntry.isCurrentRoute(Route.Appearance::class) ->
                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.appearance)) },
                        route = Route.Appearance,
                    )

                backStackEntry.isCurrentRoute(Route.Language::class) ->
                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.language)) },
                        route = Route.Language,
                    )

                backStackEntry.isCurrentRoute(Route.Display::class) ->
                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.display_theme)) },
                        route = Route.Display,
                    )

+                backStackEntry.isCurrentRoute(Route.TunnelMonitoring::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.tunnel_monitoring)) },
+                        route = Route.TunnelMonitoring,
+                    )
+
+                backStackEntry.isCurrentRoute(Route.WifiDetectionMethod::class) ->
+                    NavBarState(
+                        topTitle = { Text(stringResource(R.string.wifi_detection_method)) },
+                        route = Route.WifiDetectionMethod,
+                    )
+
                backStackEntry.isCurrentRoute(Route.KillSwitch::class) ->
                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.kill_switch)) },
                        route = Route.KillSwitch,
                    )

                backStackEntry.isCurrentRoute(Route.Support::class) ->
                    NavBarState(
-                        showTop = true,
-                        showBottom = true,
                        topTitle = { Text(stringResource(R.string.support)) },
                        route = Route.Support,
                    )

+                backStackEntry.isCurrentRoute(Route.Sort::class) -> {
+                    NavBarState(
+                        showTop = true,
+                        showBottom = true,
+                        topTitle = { Text(stringResource(R.string.sort)) },
+                        topTrailing = {
+                            Row {
+                                ActionIconButton(Icons.Rounded.SortByAlpha, R.string.sort) {
+                                    viewModel.handleUiEvent(UiEvent.SortTunnels)
+                                }
+                                ActionIconButton(Icons.Rounded.Save, R.string.save) {
+                                    viewModel.handleEvent(AppEvent.InvokeScreenAction)
+                                }
+                            }
+                        },
+                        route = Route.Sort,
+                    )
+                }
+
                backStackEntry.isCurrentRoute(Route.License::class) -> {
                    NavBarState(
                        showTop = true,
@@ -1,93 +1,89 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel

-import android.Manifest
-import android.os.Build
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CheckCircle
+import androidx.compose.material.icons.outlined.Info
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
-import com.google.accompanist.permissions.isGranted
-import com.google.accompanist.permissions.rememberPermissionState
+import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.SectionDivider
+import com.zaneschepke.wireguardautotunnel.ui.common.banner.WarningBanner
+import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
-import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
 import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.AdvancedSettingsItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.NetworkTunnelingItems
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components.WifiTunnelingItems
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.BackgroundLocationDialog
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.LocationServicesDialog
 import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
-import com.zaneschepke.wireguardautotunnel.util.extensions.isLocationServicesEnabled
+import com.zaneschepke.wireguardautotunnel.util.extensions.launchAppSettings
+import com.zaneschepke.wireguardautotunnel.util.extensions.launchLocationServicesSettings
 import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent

@OptIn(ExperimentalPermissionsApi::class)
@Composable
 fun AutoTunnelScreen(uiState: AppUiState, viewModel: AppViewModel) {
-    val context = LocalContext.current
    val navController = LocalNavController.current
-    val isTv = LocalIsAndroidTV.current
-    val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
+    val context = LocalContext.current
+
    var currentText by remember { mutableStateOf("") }
-    var isBackgroundLocationGranted by remember { mutableStateOf(true) }
-    var showLocationServicesAlertDialog by remember { mutableStateOf(false) }
    var showLocationDialog by remember { mutableStateOf(false) }

-    fun checkFineLocationGranted() {
-        isBackgroundLocationGranted = fineLocationState.status.isGranted
-    }
-
-    fun isWifiNameReadable(): Boolean {
-        return when {
-            !isBackgroundLocationGranted || !fineLocationState.status.isGranted -> {
-                showLocationDialog = true
-                false
+    val showLocationServicesWarning by
+        remember(
+            uiState.connectivityState?.wifiState,
+            uiState.appSettings.trustedNetworkSSIDs,
+            uiState.appSettings.wifiDetectionMethod,
+        ) {
+            derivedStateOf {
+                uiState.connectivityState?.wifiState?.locationServicesEnabled == false &&
+                    uiState.appSettings.wifiDetectionMethod.needsLocationPermissions() &&
+                    uiState.appSettings.trustedNetworkSSIDs.isNotEmpty()
            }
-            !context.isLocationServicesEnabled() -> {
-                showLocationServicesAlertDialog = true
-                false
-            }
-            else -> true
        }
-    }

-    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) checkFineLocationGranted()
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-        if (isTv && Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {
-            checkFineLocationGranted()
-        } else {
-            val backgroundLocationState =
-                rememberPermissionState(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+    val showLocationPermissionsWarning by
+        remember(
+            uiState.connectivityState?.wifiState,
+            uiState.appSettings.trustedNetworkSSIDs,
+            uiState.appSettings.wifiDetectionMethod,
+        ) {
+            derivedStateOf {
+                uiState.connectivityState?.wifiState?.locationPermissionsGranted == false &&
+                    uiState.appSettings.wifiDetectionMethod.needsLocationPermissions() &&
+                    uiState.appSettings.trustedNetworkSSIDs.isNotEmpty()
+            }
        }
-    }

    LaunchedEffect(uiState.appSettings.trustedNetworkSSIDs) { currentText = "" }

-    LocationServicesDialog(
-        showLocationServicesAlertDialog,
-        onDismiss = { showLocationServicesAlertDialog = false },
-        onAttest = { showLocationServicesAlertDialog = false },
-    )
-
-    BackgroundLocationDialog(
-        showLocationDialog,
-        onDismiss = { showLocationDialog = false },
-        onAttest = { showLocationDialog = false },
-    )
+    if (showLocationDialog) {
+        InfoDialog(
+            onAttest = {
+                context.launchAppSettings()
+                showLocationDialog = false
+            },
+            onDismiss = { showLocationDialog = false },
+            title = { Text(stringResource(R.string.location_permissions)) },
+            body = { Text(stringResource(R.string.location_justification)) },
+            confirmText = { Text(stringResource(R.string.open_settings)) },
+        )
+    }

    Column(
        horizontalAlignment = Alignment.Start,
@@ -98,16 +94,66 @@ fun AutoTunnelScreen(uiState: AppUiState, viewModel: AppViewModel) {
                .padding(vertical = 24.dp)
                .padding(horizontal = 12.dp),
    ) {
+        WarningBanner(
+            stringResource(R.string.location_services_not_detected),
+            showLocationServicesWarning,
+            trailing = {
+                TextButton({ context.launchLocationServicesSettings() }) {
+                    Text(
+                        stringResource(R.string.fix),
+                        color = MaterialTheme.colorScheme.primary,
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+            },
+        )
+        WarningBanner(
+            stringResource(R.string.location_permissions_missing),
+            showLocationPermissionsWarning,
+            trailing = {
+                TextButton({ showLocationDialog = true }) {
+                    Text(
+                        stringResource(R.string.fix),
+                        color = MaterialTheme.colorScheme.primary,
+                        style = MaterialTheme.typography.bodyMedium,
+                    )
+                }
+            },
+        )
+        val (title, buttonText, icon) =
+            remember(uiState.isAutoTunnelActive) {
+                when (uiState.isAutoTunnelActive) {
+                    true ->
+                        Triple(
+                            context.getString(R.string.auto_tunnel_running),
+                            context.getString(R.string.stop),
+                            Icons.Outlined.CheckCircle,
+                        )
+                    false ->
+                        Triple(
+                            context.getString(R.string.auto_tunnel_not_running),
+                            context.getString(R.string.start),
+                            Icons.Outlined.Info,
+                        )
+                }
+            }
        SurfaceSelectionGroupButton(
            items =
-                WifiTunnelingItems(
-                    uiState,
-                    viewModel,
-                    currentText,
-                    { currentText = it },
-                    { isWifiNameReadable() },
+                listOf(
+                    SelectionItem(
+                        leading = { Icon(icon, null) },
+                        title = { Text(title) },
+                        trailing = {
+                            Button({ viewModel.handleEvent(AppEvent.ToggleAutoTunnel) }) {
+                                Text(buttonText, fontWeight = FontWeight.Bold)
+                            }
+                        },
+                    )
                )
        )
+        SurfaceSelectionGroupButton(
+            items = WifiTunnelingItems(uiState, viewModel, currentText) { currentText = it }
+        )
        SectionDivider()
        SurfaceSelectionGroupButton(items = NetworkTunnelingItems(uiState, viewModel))
        SectionDivider()
@@ -6,13 +6,21 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.PauseCircle
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.advanced.components.DebounceDelaySelector
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.common.dropdown.LabelledNumberDropdown
 import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent

@Composable
 fun AutoTunnelAdvancedScreen(appUiState: AppUiState, viewModel: AppViewModel) {
@@ -25,9 +33,22 @@ fun AutoTunnelAdvancedScreen(appUiState: AppUiState, viewModel: AppViewModel) {
                .padding(vertical = 24.dp)
                .padding(horizontal = 12.dp),
    ) {
-        DebounceDelaySelector(
-            currentDelay = appUiState.appSettings.debounceDelaySeconds,
-            onEvent = viewModel::handleEvent,
+        LabelledNumberDropdown(
+            title = {
+                Text(
+                    stringResource(R.string.debounce_delay),
+                    style =
+                        MaterialTheme.typography.bodyMedium.copy(
+                            color = MaterialTheme.colorScheme.onSurface
+                        ),
+                )
+            },
+            leading = { Icon(Icons.Outlined.PauseCircle, null) },
+            onSelected = { selected ->
+                viewModel.handleEvent(AppEvent.SetDebounceDelay(selected!!))
+            },
+            options = (0..10).toList(),
+            currentValue = appUiState.appSettings.debounceDelaySeconds,
        )
    }
 }
@@ -1,49 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.advanced.components
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.PauseCircle
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.res.stringResource
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.common.DropdownSelector
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
-import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
-import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
-
-@Composable
-fun DebounceDelaySelector(currentDelay: Int, onEvent: (AppEvent) -> Unit) {
-    var isDropDownExpanded by remember { mutableStateOf(false) }
-
-    SurfaceSelectionGroupButton(
-        listOf(
-            SelectionItem(
-                leadingIcon = Icons.Outlined.PauseCircle,
-                title = {
-                    Text(
-                        stringResource(R.string.debounce_delay),
-                        style =
-                            MaterialTheme.typography.bodyMedium.copy(
-                                color = MaterialTheme.colorScheme.onSurface
-                            ),
-                    )
-                },
-                onClick = { isDropDownExpanded = true },
-                trailing = {
-                    DropdownSelector(
-                        currentValue = currentDelay,
-                        options = (0..10).toList(),
-                        onValueSelected = { num -> onEvent(AppEvent.SetDebounceDelay(num)) },
-                        isExpanded = isDropDownExpanded,
-                        onDismiss = { isDropDownExpanded = false },
-                    )
-                },
-            )
-        )
-    )
-}
@@ -2,6 +2,7 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components

 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Settings
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -13,7 +14,7 @@ import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionIte
@Composable
 fun AdvancedSettingsItem(onClick: () -> Unit): SelectionItem {
    return SelectionItem(
-        leadingIcon = Icons.Outlined.Settings,
+        leading = { Icon(Icons.Outlined.Settings, contentDescription = null) },
        title = {
            Text(
                stringResource(R.string.advanced_settings),
@@ -4,6 +4,7 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.PublicOff
 import androidx.compose.material.icons.outlined.SettingsEthernet
 import androidx.compose.material.icons.outlined.SignalCellular4Bar
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -21,7 +22,7 @@ import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 fun NetworkTunnelingItems(uiState: AppUiState, viewModel: AppViewModel): List<SelectionItem> {
    return listOf(
        SelectionItem(
-            leadingIcon = Icons.Outlined.SignalCellular4Bar,
+            leading = { Icon(Icons.Outlined.SignalCellular4Bar, contentDescription = null) },
            title = {
                Text(
                    stringResource(R.string.tunnel_mobile_data),
@@ -40,8 +41,8 @@ fun NetworkTunnelingItems(uiState: AppUiState, viewModel: AppViewModel): List<Se
            },
            description = {
                val cellularActive =
-                    remember(uiState.networkStatus) {
-                        uiState.networkStatus?.cellularConnected ?: false
+                    remember(uiState.connectivityState) {
+                        uiState.connectivityState?.cellularConnected ?: false
                    }
                Text(
                    text =
@@ -58,7 +59,7 @@ fun NetworkTunnelingItems(uiState: AppUiState, viewModel: AppViewModel): List<Se
            onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnCellular) },
        ),
        SelectionItem(
-            leadingIcon = Icons.Outlined.SettingsEthernet,
+            leading = { Icon(Icons.Outlined.SettingsEthernet, contentDescription = null) },
            title = {
                Text(
                    stringResource(R.string.tunnel_on_ethernet),
@@ -77,8 +78,8 @@ fun NetworkTunnelingItems(uiState: AppUiState, viewModel: AppViewModel): List<Se
            },
            description = {
                val ethernetActive =
-                    remember(uiState.networkStatus) {
-                        uiState.networkStatus?.ethernetConnected ?: false
+                    remember(uiState.connectivityState) {
+                        uiState.connectivityState?.ethernetConnected ?: false
                    }
                Text(
                    text =
@@ -95,7 +96,7 @@ fun NetworkTunnelingItems(uiState: AppUiState, viewModel: AppViewModel): List<Se
            onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnEthernet) },
        ),
        SelectionItem(
-            leadingIcon = Icons.Outlined.PublicOff,
+            leading = { Icon(Icons.Outlined.PublicOff, contentDescription = null) },
            title = {
                Text(
                    stringResource(R.string.stop_on_no_internet),
@@ -1,12 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components

 import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.FlowRow
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
@@ -1,18 +1,9 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.components

 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Code
-import androidx.compose.material.icons.outlined.Filter1
-import androidx.compose.material.icons.outlined.Security
-import androidx.compose.material.icons.outlined.VpnKeyOff
-import androidx.compose.material.icons.outlined.Wifi
+import androidx.compose.material.icons.outlined.*
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -26,14 +17,17 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.networkmonitor.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.Route
+import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ScaledSwitch
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberClipboardHelper
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.LearnMoreLinkLabel
 import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
 import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+import com.zaneschepke.wireguardautotunnel.util.extensions.asString
 import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
 import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
 import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
@@ -44,15 +38,15 @@ fun WifiTunnelingItems(
    viewModel: AppViewModel,
    currentText: String,
    onTextChange: (String) -> Unit,
-    isWifiNameReadable: () -> Boolean,
 ): List<SelectionItem> {
    val context = LocalContext.current
+    val navController = LocalNavController.current
    val clipboardHelper = rememberClipboardHelper()

    val baseItems =
        listOf(
            SelectionItem(
-                leadingIcon = Icons.Outlined.Wifi,
+                leading = { Icon(Icons.Outlined.Wifi, contentDescription = null) },
                title = {
                    Text(
                        stringResource(R.string.tunnel_on_wifi),
@@ -71,11 +65,12 @@ fun WifiTunnelingItems(
                },
                description = {
                    val wifiInfo by
-                        remember(uiState.networkStatus) {
+                        remember(uiState.connectivityState) {
                            derivedStateOf {
-                                (uiState.networkStatus as? NetworkStatus.Connected)
-                                    ?.takeIf { it.wifiConnected }
-                                    .let { Pair(it?.wifiSsid, it?.securityType) }
+                                uiState.connectivityState
+                                    ?.wifiState
+                                    ?.takeIf { it.connected }
+                                    .let { Pair(it?.ssid, it?.securityType) }
                            }
                        }
                    val (wifiName, securityType) = wifiInfo
@@ -107,42 +102,42 @@ fun WifiTunnelingItems(
                    }
                },
                onClick = { viewModel.handleEvent(AppEvent.ToggleAutoTunnelOnWifi) },
-            ),
-            SelectionItem(
-                leadingIcon = Icons.Outlined.Code,
-                title = {
-                    Text(
-                        stringResource(R.string.wifi_name_via_shell),
-                        style =
-                            MaterialTheme.typography.bodyMedium.copy(
-                                MaterialTheme.colorScheme.onSurface
-                            ),
-                    )
-                },
-                description = {
-                    Text(
-                        stringResource(R.string.use_root_shell_for_wifi),
-                        style =
-                            MaterialTheme.typography.bodySmall.copy(
-                                MaterialTheme.colorScheme.outline
-                            ),
-                    )
-                },
-                trailing = {
-                    ScaledSwitch(
-                        checked = uiState.appSettings.isWifiNameByShellEnabled,
-                        onClick = { viewModel.handleEvent(AppEvent.ToggleRootShellWifi) },
-                    )
-                },
-                onClick = { viewModel.handleEvent(AppEvent.ToggleRootShellWifi) },
-            ),
+            )
        )

    return if (uiState.appSettings.isTunnelOnWifiEnabled) {
        baseItems +
            listOf(
                SelectionItem(
-                    leadingIcon = Icons.Outlined.Filter1,
+                    leading = { Icon(Icons.Outlined.WifiFind, contentDescription = null) },
+                    title = {
+                        Text(
+                            stringResource(R.string.wifi_detection_method),
+                            style =
+                                MaterialTheme.typography.bodyMedium.copy(
+                                    MaterialTheme.colorScheme.onSurface
+                                ),
+                        )
+                    },
+                    description = {
+                        Text(
+                            stringResource(
+                                R.string.current_template,
+                                uiState.appSettings.wifiDetectionMethod.asString(context),
+                            ),
+                            style =
+                                MaterialTheme.typography.bodySmall.copy(
+                                    MaterialTheme.colorScheme.outline
+                                ),
+                        )
+                    },
+                    trailing = {
+                        ForwardButton { navController.navigate(Route.WifiDetectionMethod) }
+                    },
+                    onClick = { navController.navigate(Route.WifiDetectionMethod) },
+                ),
+                SelectionItem(
+                    leading = { Icon(Icons.Outlined.Filter1, contentDescription = null) },
                    title = {
                        Text(
                            stringResource(R.string.use_wildcards),
@@ -204,12 +199,7 @@ fun WifiTunnelingItems(
                            onDelete = { viewModel.handleEvent(AppEvent.DeleteTrustedSSID(it)) },
                            currentText = currentText,
                            onSave = { ssid ->
-                                if (
-                                    uiState.appSettings.isWifiNameByShellEnabled ||
-                                        isWifiNameReadable()
-                                ) {
-                                    viewModel.handleEvent(AppEvent.SaveTrustedSSID(ssid))
-                                }
+                                viewModel.handleEvent(AppEvent.SaveTrustedSSID(ssid))
                            },
                            onValueChange = onTextChange,
                            supporting = {
@@ -219,7 +209,7 @@ fun WifiTunnelingItems(
                    },
                ),
                SelectionItem(
-                    leadingIcon = Icons.Outlined.VpnKeyOff,
+                    leading = { Icon(Icons.Outlined.VpnKeyOff, contentDescription = null) },
                    title = {
                        Text(
                            stringResource(R.string.kill_switch_off),
@@ -0,0 +1,39 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.detection
+
+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.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
+import com.zaneschepke.wireguardautotunnel.ui.common.button.IconSurfaceButton
+import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
+import com.zaneschepke.wireguardautotunnel.util.extensions.asDescriptionString
+import com.zaneschepke.wireguardautotunnel.util.extensions.asString
+import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
+
+@Composable
+fun WifiDetectionMethodScreen(uiState: AppUiState, viewModel: AppViewModel) {
+    val context = LocalContext.current
+    Column(
+        horizontalAlignment = Alignment.Start,
+        verticalArrangement = Arrangement.spacedBy(24.dp, Alignment.Top),
+        modifier = Modifier.fillMaxSize().padding(top = 24.dp).padding(horizontal = 24.dp),
+    ) {
+        enumValues<AndroidNetworkMonitor.WifiDetectionMethod>().forEach {
+            val title = it.asString(context)
+            val description = it.asDescriptionString(context)
+            IconSurfaceButton(
+                title = title,
+                onClick = { viewModel.handleEvent(AppEvent.SetDetectionMethod(it)) },
+                selected = uiState.appSettings.wifiDetectionMethod == it,
+                description = description,
+            )
+        }
+    }
+}
@@ -9,24 +9,17 @@ import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.ui.Route
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SurfaceSelectionGroupButton
-import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
-import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.AppSettingsItem
 import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.LocationDisclosureHeader
-import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.SkipItem
-import com.zaneschepke.wireguardautotunnel.ui.state.AppUiState
-import com.zaneschepke.wireguardautotunnel.util.extensions.goFromRoot
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.appSettingsItem
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.components.skipItem
 import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
+import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent

@Composable
-fun LocationDisclosureScreen(appUiState: AppUiState, viewModel: AppViewModel) {
-    val navController = LocalNavController.current
+fun LocationDisclosureScreen(viewModel: AppViewModel) {

-    LaunchedEffect(Unit, appUiState) {
-        if (appUiState.appState.isLocationDisclosureShown)
-            navController.goFromRoot(Route.AutoTunnel)
-    }
+    LaunchedEffect(Unit) { viewModel.handleEvent(AppEvent.SetLocationDisclosureShown) }

    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
@@ -34,7 +27,7 @@ fun LocationDisclosureScreen(appUiState: AppUiState, viewModel: AppViewModel) {
        modifier = Modifier.fillMaxSize().padding(top = 18.dp).padding(horizontal = 24.dp),
    ) {
        LocationDisclosureHeader()
-        SurfaceSelectionGroupButton(items = listOf(AppSettingsItem(viewModel)))
-        SurfaceSelectionGroupButton(items = listOf(SkipItem(viewModel)))
+        SurfaceSelectionGroupButton(items = listOf(appSettingsItem()))
+        SurfaceSelectionGroupButton(items = listOf(skipItem()))
    }
 }
@@ -2,6 +2,7 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.com

 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.LocationOn
+import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -11,31 +12,20 @@ import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.common.button.ForwardButton
 import com.zaneschepke.wireguardautotunnel.ui.common.button.surface.SelectionItem
 import com.zaneschepke.wireguardautotunnel.util.extensions.launchAppSettings
-import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
-import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent

@Composable
-fun AppSettingsItem(viewModel: AppViewModel): SelectionItem {
+fun appSettingsItem(): SelectionItem {
    val context = LocalContext.current
+
    return SelectionItem(
-        leadingIcon = Icons.Outlined.LocationOn,
+        leading = { Icon(Icons.Outlined.LocationOn, contentDescription = null) },
        title = {
            Text(
                text = stringResource(R.string.launch_app_settings),
                style = MaterialTheme.typography.bodyLarge.copy(MaterialTheme.colorScheme.onSurface),
            )
        },
-        trailing = {
-            ForwardButton {
-                context.launchAppSettings().also {
-                    viewModel.handleEvent(AppEvent.SetLocationDisclosureShown)
-                }
-            }
-        },
-        onClick = {
-            context.launchAppSettings().also {
-                viewModel.handleEvent(AppEvent.SetLocationDisclosureShown)
-            }
-        },
+        trailing = { ForwardButton { context.launchAppSettings() } },
+        onClick = { context.launchAppSettings() },
    )
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Zane Schepke	c8634c71a3	fix checksum	2025-08-08 15:08:11 -04:00
Zane Schepke	3894efa066	fix checksum	2025-08-08 15:05:11 -04:00
Zane Schepke	3c60913917	revert amnezia tun version bump	2025-08-08 14:43:23 -04:00
Zane Schepke	78b419dc6e	chore: bump deps	2025-08-08 04:46:32 -04:00
Zane Schepke	e8681af273	feat: app database backup and restore closes #541	2025-08-08 04:07:04 -04:00
Zane Schepke	cb92c9605f	fix: startup splash bug	2025-08-08 02:35:58 -04:00
Zane Schepke	38ecb0b66b	feat!: tun monitoring, move ping restarts to auto-tunnel w/recovery (#885 ) This is a big one.. oops. Main changes: - Make ping monitor more robust and global, with ping target overrides of the default cloudflare fallback target per tunnel (for full tunnels, otherwise we ping the internal tun ip) - Include ping restart recovery to prevent tun being down if dns failures happen after a bounce - Ping monitoring itself remains per tunnel and works without auto tunnel active, but moves the restart feature back to be managed by and integrated with auto tunnel to prevent inconsistencies and conflicts - Ping statistics can be optionally included to be displayed with tun statistics - Adds the beginnings of monitoring logs for handshake and data packet failures for userspace tuns (to be incorporated with restarts/tun status later) - Improve tun error notifications, adds ping restart notifications - Major refactor of auto tunnel logic to make it more modular and extensible for new auto tunnel conditions - A bunch of other stuff..	2025-08-07 18:19:36 -04:00
Zane Schepke	230cd0adb8	refactor: remove prelease build, change icon color for nightly	2025-08-01 11:41:17 -04:00
Zane Schepke	33b51823ab	chore: deprecation, warnings	2025-08-01 08:56:09 -04:00
Zane Schepke	f333319576	feat: auto-tunnel warning notifications for location permissions and services	2025-08-01 02:06:53 -04:00
Zane Schepke	e6ad1531c9	fix: improve permission flow, location permission detection, accessibility, tunnel notifications Minor changes to Auto-tunnel ui to make starting auto tunnel more intuitive. Better monitoring of location services and location permission changes to be immediately reflected in network monitor, with warnings displayed on auto tunnel screen if necessary depending on wifi detection method. Improved detection of when app is backgrounded so we notify user of tunnel errors in notifications vs ui. Fixes bug where prominent location screen was not showing properly.	2025-07-31 18:45:27 -04:00
Zane Schepke	030082df34	fix: miui segmented button color issue #875	2025-07-26 07:58:25 -04:00
Zane Schepke	a825a2f2a4	fix: tunnel position bug after toggle	2025-07-26 01:13:01 -04:00
Zane Schepke	aa1a344bb2	chore: fix short description vi	2025-07-25 23:57:18 -04:00
Zane Schepke	3aa03c1896	chore: fix fastlane missing full descriptions	2025-07-25 21:36:54 -04:00
Zane Schepke	21e56cda80	chore: bump app version with notes	2025-07-25 14:58:37 -04:00
Zane Schepke	b5196fbf01	fix: android tv sorting bug, improve hover visibility	2025-07-23 02:09:34 -04:00
Zane Schepke	e46fe93ae0	fix: improve network detection reliability, permission change detection #848	2025-07-22 17:28:18 -04:00
Zane Schepke	872ff83a12	feat!: tunnel sorting #847 closes #846 closes #299	2025-07-17 11:45:46 -04:00
Zane Schepke	5563292a87	build(deps): bump upstream libraries to latest versions after sync	2025-07-13 13:29:26 -04:00
Zane Schepke	8ba760a5ff	refactor: auto expand tunnel stats on active	2025-07-11 17:09:52 -04:00
Zane Schepke	d431c2d39f	chore: bump deps, fix localization sync duplicates	2025-07-11 14:07:05 -04:00
Zane Schepke	33437ab237	chore: fix weblate sync	2025-07-11 13:38:03 -04:00
Zane Schepke	4a432d2bb7	refactor: remove rudundant pt	2025-07-11 13:22:08 -04:00
Zane Schepke	3df972d031	feat(lang): weblate localization changes (#857 ) Co-authored-by: Matthaiks <kitynska@gmail.com> Co-authored-by: kometchtech <kometch@gmail.com> Co-authored-by: 翻譯得真好下次別翻了 <x86_64-pc-linux-gnu@proton.me> Co-authored-by: solokot <solokot@gmail.com> Co-authored-by: Kachelkaiser <kachelkaiser@htpst.de> Co-authored-by: catelixor <catelixor+weblate@proton.me> Co-authored-by: 大王叫我来巡山 <hamburger2048@users.noreply.hosted.weblate.org> Co-authored-by: Faisal Gull <mail.faisalrehman.345@gmail.com> Co-authored-by: vm <varga.m007@gmail.com> Co-authored-by: தமிழ்நேரம் <anishprabu.t@gmail.com> Co-authored-by: sgauthiertremblay <info@sgauthiertremblay.dev> Co-authored-by: ssantos <ssantos@web.de> Co-authored-by: Valentin <velentin.s@yandex.ru> Co-authored-by: adkostatt <adkostatt@gmail.com> Co-authored-by: VertekPlus <vertekplus@users.noreply.hosted.weblate.org> Co-authored-by: Jasper <jasper@ennik.com> Co-authored-by: Tommaso <mrduckhunt@users.noreply.hosted.weblate.org> Co-authored-by: dct <dct@trnh.org> Co-authored-by: Languages add-on <noreply-addon-languages@weblate.org> Co-authored-by: angrybb <lijadolija@gmail.com> Co-authored-by: Saratoga79 <ordizi79@gmail.com> Co-authored-by: Deleted User <noreply+48943@weblate.org> Co-authored-by: François-Xavier Choinière <fx@efficks.com> Co-authored-by: Noureddine <noureddinex@protonmail.com> Co-authored-by: Hamed Ap <hamed.ap1366@gmail.com> Co-authored-by: igor <igor.lachaud@aol.fr> Co-authored-by: EESF-2 <eesf-2@users.noreply.hosted.weblate.org> Co-authored-by: Priit Jõerüüt <hwlate@joeruut.com> Co-authored-by: Jan-Erik Moen <jemoen@gmail.com> Co-authored-by: teemue <eemil.koivula@gmail.com> Co-authored-by: Priit Jõerüüt <jrthwlate@users.noreply.hosted.weblate.org> Co-authored-by: Andras <andras0602@hotmail.com>	2025-07-11 13:00:24 -04:00
Zane Schepke	8b828cca55	fix: nightly installer permission bug	2025-07-06 04:13:59 -04:00
Zane Schepke	a223289949	feat: add shizuku support (#852 )	2025-07-05 20:49:02 -04:00
Zane Schepke	c8b65fb7fa	ci: fix token	2025-06-19 00:58:34 -04:00
Zane Schepke	feec7f0ffc	chore: bump version	2025-06-17 15:43:46 -04:00
Zane Schepke	b63c6a9b73	fix: simplify update check dialog ui	2025-06-17 15:34:24 -04:00
Zane Schepke	46975607c4	fix: version check name change	2025-06-17 14:04:00 -04:00
Zane Schepke	0c7bcb5453	fix: nightly version check	2025-06-14 16:59:40 -04:00
Zane Schepke	599bf9c9e0	fix: wifi name surrounding quotes, prevent multiple auto-tunnel jobs #768 #797	2025-06-14 15:39:22 -04:00
Zane Schepke	03345bdf86	fix!: deprecated wifi info api, add detection option selection This will break for users who have selected get tunnel name via root shell. They will need to select the new option on update. Also, this will cause more location pings. Users who want less location pings will have to enable the legacy api option manually. #768 #797	2025-06-12 21:49:48 -04:00
Zane Schepke	b07e604003	chore: bump deps	2025-06-11 07:16:24 -04:00