feat: add amneziawg support

Update ic_channel.xml
Update translation files
2026-07-03 14:07:49 +02:00 · 2024-04-27 21:44:41 -04:00 · 2024-04-26 01:50:08 -04:00 · 2024-04-26 01:50:08 -04:00 · 2024-04-26 01:49:49 -04:00 · 2024-04-26 01:49:08 -04:00
164 changed files with 4452 additions and 1793 deletions
@@ -0,0 +1,22 @@
+# Contributor Code of Conduct
+
+## Pledge
+
+We as individuals involved in this project, pledge to participate in this
+community in a respectful, constructive, and civil manner as we work towards a common goal
+of delivering free, open source, and value adding software for all. 
+
+## Standard
+
+The standard for this community is the Golden Rule.
+
+> “Do unto others as you would have them do unto you.”
+
+## Scope
+
+This Code of Conduct applies to all spaces related to WG Tunnel.
+
+## Incidents or Concerns
+
+For any incidents or concerns, reach out to Zane at
+<support@zaneschepke.com>.
@@ -78,7 +78,7 @@ jobs:
          name: wgtunnel
      - name: Create Release with Fastlane changelog notes
        id: create_release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
@@ -89,6 +89,32 @@ jobs:
          draft: false
          prerelease: true
          files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
+
+      - name: Install apksigner
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y apksigner
+
+      - name: Get checksum
+        id: checksum
+        run: echo "checksum=$(apksigner verify -print-certs ${{ steps.apk-path.outputs.path }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
+
+      - name: Append checksum
+        id: append_checksum
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          body: |
+            
+            SHA256 fingerprint:
+            ```${{ steps.checksum.outputs.checksum }}```
+          tag_name: ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
+          draft: false
+          prerelease: true
+          append_body: true
+
      - name: Deploy with fastlane
        uses: ruby/setup-ruby@v1
        with:
@@ -85,17 +85,42 @@ jobs:
          event-type: fdroid-update
      - name: Create Release with Fastlane changelog notes
        id: create_release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
-          # fix hardcode changelog file name
          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt
          tag_name: ${{ github.ref_name }}
          name: ${{ github.ref_name }}
          draft: false
          prerelease: false
          files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
+
+      - name: Install apksigner
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y apksigner
+
+      - name: Get checksum
+        id: checksum
+        run: echo "checksum=$(apksigner verify -print-certs ${{ steps.apk-path.outputs.path }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
+
+      - name: Append checksum
+        id: append_checksum
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          body: |
+            
+            SHA256 fingerprint:
+            ```${{ steps.checksum.outputs.checksum }}```
+          tag_name: ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
+          draft: false
+          prerelease: false
+          append_body: true
+
      - name: Deploy with fastlane
        uses: ruby/setup-ruby@v1
        with:
@@ -4,8 +4,9 @@ WG Tunnel

 <div align="center">

-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Discord Chat](https://img.shields.io/discord/1108285024631001111.svg)](https://discord.gg/rbRRNh6H7V)
+[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/rbRRNh6H7V)
+[![X Community](https://img.shields.io/badge/X-000000?style=for-the-badge&logo=x&logoColor=white)](https://twitter.com/i/communities/1780655267685736818)
+[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/wgtunnel)

 </div>

@@ -49,23 +50,40 @@ and on while on different networks. This app was created to offer a free solutio
 ## Features

 * Add tunnels via .conf file, zip, manual entry, or QR code
-* Auto connect to VPN based on Wi-Fi SSID, ethernet, or mobile data
+* Auto connect to tunnels based on Wi-Fi SSID, ethernet, or mobile data
 * Split tunneling by application with search
 * WireGuard support for kernel and userspace modes
 * Always-On VPN support
 * Export tunnels to zip
-* Quick tile support for VPN toggling
-* Static shortcuts support for primary tunnel for automation integration
+* Quick tile support for tunnel toggling, auto-tunneling
+* Static shortcuts support for tunnel toggling, auto-tunneling
 * Intent automation support for all tunnels
-* Automatic service restart after reboot
+* Automatic auto-tunneling service restart after reboot
+* Automatic tunnel restart after reboot
 * Battery preservation measures
+* Restart tunnel on ping failure (beta)

-## Docs (WIP)
+## Docs

-Basic documentation of the feature and behaviors of this app can be found [here](https://zaneschepke.com/wgtunnel-docs/overview.html).
+Basic documentation of the feature and behaviors of this app can be
+found [here](https://zaneschepke.com/wgtunnel-docs/overview.html).

 The repository for these docs can be found [here](https://github.com/zaneschepke/wgtunnel-docs).

+## Contributing
+
+Any contributions in the form of feedback, issues, code, or translations are welcome and much appreciated!
+
+Please read the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct) before contributing.
+
+## Translation
+
+This app is using [Weblate](https://weblate.org) to assist with translations. 
+
+Help translate WG Tunnel into your language at [Hosted Weblate](https://hosted.weblate.org/engage/wg-tunnel/).\
+[![Translation status](https://hosted.weblate.org/widgets/wg-tunnel/-/multi-auto.svg)](https://hosted.weblate.org/engage/wg-tunnel/)
+
+
 ## Building

 ```
@@ -73,28 +91,8 @@ $ git clone https://github.com/zaneschepke/wgtunnel
 $ cd wgtunnel
 ```

-Create a personal access token (classic) in GitHuv to be able to pull the wireguard-android github dependencies from GitHub packages
-as documented [here](https://docs.github.com/en/packages/learn-github-packages/introduction-to-github-packages#authenticating-to-github-packages).
-
-Alternatively, you can clone [wireguard-android](https://github.com/zaneschepke/wireguard-android) and run the following command to publish the dependency to your local maven repository (requires you have maven installed). This is the ideal approach
-if you intent to make changes to this lib.
-
-```
-$ git clone https://github.com/zaneschepke/wireguard-android
-$ cd wireguard-android
-$ brew install maven
-$ ./gradlew publishToMavenLocal
-```
-
-The [wireguard-android](https://github.com/zaneschepke/wireguard-android) dependency is a fork of the official [wireguard-android](https://github.com/WireGuard/wireguard-android) library. 
-
-Add the following lines to local.properties file:
-```
-GH_USER=<your github username>
-GH_TOKEN=<the personal access token with read package permission you just created>
-```
-
 And then build the app:
+
 ```
 $ ./gradlew assembleDebug
 ```
@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security issues to `support@zaneschepke.com`
@@ -4,7 +4,7 @@ plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.hilt.android)
-    id("org.jetbrains.kotlin.plugin.serialization")
+    alias(libs.plugins.kotlinxSerialization)
    alias(libs.plugins.ksp)
 }

@@ -12,6 +12,10 @@ android {
    namespace = Constants.APP_ID
    compileSdk = Constants.TARGET_SDK

+    androidResources {
+        generateLocaleConfig = true
+    }
+
    defaultConfig {
        applicationId = Constants.APP_ID
        minSdk = Constants.MIN_SDK
@@ -25,8 +29,6 @@ android {
            getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
        }

-        resourceConfigurations.addAll(listOf("en"))
-
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables { useSupportLibrary = true }
    }
@@ -111,8 +113,7 @@ android {
        create("general") {
            dimension = Constants.TYPE
            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
-                apply(plugin = "com.google.gms.google-services")
-                apply(plugin = "com.google.firebase.crashlytics")
+                //any plugins general specific
            }
        }
    }
@@ -133,9 +134,12 @@ android {
 val generalImplementation by configurations

 dependencies {
+
+    implementation(project(":logcatter"))
+
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
-    // optional - helpers for implementing LifecycleOwner in a Service
+    // helpers for implementing LifecycleOwner in a Service
    implementation(libs.androidx.lifecycle.service)
    implementation(libs.androidx.activity.compose)
    implementation(platform(libs.androidx.compose.bom))
@@ -156,8 +160,8 @@ dependencies {
    debugImplementation(libs.androidx.compose.ui.tooling)
    debugImplementation(libs.androidx.compose.manifest)

-    // get tunnel lib from github packages or mavenLocal
-    implementation(libs.tunnel)
+    // tunnel
+    implementation(libs.amneziawg.android)
    coreLibraryDesugaring(libs.desugar.jdk.libs)

    // logging
@@ -193,17 +197,13 @@ dependencies {
    // serialization
    implementation(libs.kotlinx.serialization.json)

-    // firebase crashlytics
-    generalImplementation(platform(libs.firebase.bom))
-    generalImplementation(libs.google.firebase.crashlytics.ktx)
-    generalImplementation(libs.google.firebase.analytics.ktx)
-
    // barcode scanning
    implementation(libs.zxing.android.embedded)
    implementation(libs.zxing.core)

    // bio
    implementation(libs.androidx.biometric.ktx)
+    implementation(libs.pin.lock.compose)

    // shortcuts
    implementation(libs.androidx.core)
@@ -1,39 +0,0 @@
-{
-  "project_info": {
-    "project_number": "328300975830",
-    "project_id": "wireguard-auto-tunnel",
-    "storage_bucket": "wireguard-auto-tunnel.appspot.com"
-  },
-  "client": [
-    {
-      "client_info": {
-        "mobilesdk_app_id": "1:328300975830:android:82cd774598ccb7234b1b77",
-        "android_client_info": {
-          "package_name": "com.zaneschepke.wireguardautotunnel"
-        }
-      },
-      "oauth_client": [
-        {
-          "client_id": "328300975830-m72lc3hr69ddhdqh9ngr27rvc8o0jb2d.apps.googleusercontent.com",
-          "client_type": 3
-        }
-      ],
-      "api_key": [
-        {
-          "current_key": "AIzaSyBsSMY0LlckizXDnuYBy7nXWGSdl8zZedI"
-        }
-      ],
-      "services": {
-        "appinvite_service": {
-          "other_platform_oauth_client": [
-            {
-              "client_id": "328300975830-m72lc3hr69ddhdqh9ngr27rvc8o0jb2d.apps.googleusercontent.com",
-              "client_type": 3
-            }
-          ]
-        }
-      }
-    }
-  ],
-  "configuration_version": "1"
-}
@@ -0,0 +1,168 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 6,
+    "identityHash": "625820076477aca948536f7bccccc7ca",
+    "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, `default_tunnel` TEXT, `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_battery_saver_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_auto_tunnel_paused` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "defaultTunnel",
+            "columnName": "default_tunnel",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "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": "isBatterySaverEnabled",
+            "columnName": "is_battery_saver_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": "isAutoTunnelPaused",
+            "columnName": "is_auto_tunnel_paused",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPingEnabled",
+            "columnName": "is_ping_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL)",
+        "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
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '625820076477aca948536f7bccccc7ca')"
+    ]
+  }
+}
@@ -0,0 +1,176 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 7,
+    "identityHash": "e65e4e7cf01f50fb03196d47b54288b1",
+    "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_auto_tunnel_paused` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnWifiEnabled",
+            "columnName": "is_tunnel_on_wifi_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelEnabled",
+            "columnName": "is_kernel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isRestoreOnBootEnabled",
+            "columnName": "is_restore_on_boot_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isMultiTunnelEnabled",
+            "columnName": "is_multi_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isAutoTunnelPaused",
+            "columnName": "is_auto_tunnel_paused",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPingEnabled",
+            "columnName": "is_ping_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false)",
+        "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"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'e65e4e7cf01f50fb03196d47b54288b1')"
+    ]
+  }
+}
@@ -23,13 +23,13 @@ class MigrationTest {

    @Test
    @Throws(IOException::class)
-    fun migrate4To5() {
-        helper.createDatabase(dbName, 4).apply {
+    fun migrate6To7() {
+        helper.createDatabase(dbName, 6).apply {
            // Database has schema version 1. Insert some data using SQL queries.
            // You can't use DAO classes because they expect the latest schema.
            execSQL(Queries.createDefaultSettings())
            execSQL(
-                "INSERT INTO TunnelConfig (name, wg_quick)" + " VALUES ('hello', 'hello')",
+                Queries.createTunnelConfig(),
            )
            // Prepare for the next version.
            close()
@@ -37,7 +37,7 @@ class MigrationTest {

        // Re-open the database with version 2 and provide
        // MIGRATION_1_2 as the migration process.
-        helper.runMigrationsAndValidate(dbName, 5, true)
+        helper.runMigrationsAndValidate(dbName, 7, true)
        // MigrationTestHelper automatically verifies the schema changes,
        // but you need to validate that the data was migrated properly.
    }
@@ -23,7 +23,6 @@
    <!--foreground service exempt android 14-->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED" />
    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />

    <!--foreground service permissions-->
    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
@@ -53,7 +52,7 @@
    <application
        android:name=".WireGuardAutoTunnel"
        android:allowBackup="true"
-        android:banner="@mipmap/ic_banner"
+        android:banner="@drawable/ic_banner"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:enableOnBackInvokedCallback="true"
        android:fullBackupContent="@xml/backup_rules"
@@ -84,7 +83,8 @@
            android:screenOrientation="fullSensor"
            android:stateNotNeeded="true"
            android:theme="@style/zxing_CaptureTheme"
-            android:windowSoftInputMode="stateAlwaysHidden" />
+            android:windowSoftInputMode="stateAlwaysHidden"
+            tools:ignore="DiscouragedApi" />
        <activity
            android:name=".service.shortcut.ShortcutsActivity"
            android:enabled="true"
@@ -96,13 +96,30 @@
            android:name=".service.foreground.ForegroundService"
            android:enabled="true"
            android:exported="false"
-            android:foregroundServiceType="systemExempted|specialUse"
+            android:foregroundServiceType="systemExempted"
            tools:node="merge" />
        <service
            android:name=".service.tile.TunnelControlTile"
            android:exported="true"
            android:icon="@drawable/ic_launcher"
-            android:label="WG Tunnel"
+            android:label="Tunnel control"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+            <meta-data
+                android:name="android.service.quicksettings.ACTIVE_TILE"
+                android:value="true" />
+            <meta-data
+                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
+                android:value="true" />
+
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
+        <service
+            android:name=".service.tile.AutoTunnelControlTile"
+            android:exported="true"
+            android:icon="@drawable/ic_launcher"
+            android:label="Auto-tunnel"
            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
            <meta-data
                android:name="android.service.quicksettings.ACTIVE_TILE"
@@ -119,7 +136,7 @@
            android:name=".service.foreground.WireGuardTunnelService"
            android:enabled="true"
            android:exported="false"
-            android:foregroundServiceType="systemExempted|specialUse"
+            android:foregroundServiceType="systemExempted"
            android:permission="android.permission.BIND_VPN_SERVICE"
            android:persistent="true"
            tools:node="merge">
@@ -134,7 +151,7 @@
            android:name=".service.foreground.WireGuardConnectivityWatcherService"
            android:enabled="true"
            android:exported="false"
-            android:foregroundServiceType="systemExempted|specialUse"
+            android:foregroundServiceType="systemExempted"
            android:persistent="true"
            android:stopWithTask="false"
            tools:node="merge" />
@@ -2,18 +2,23 @@ package com.zaneschepke.wireguardautotunnel

 import android.app.Application
 import android.content.ComponentName
+import android.content.Context
 import android.content.pm.PackageManager
 import android.service.quicksettings.TileService
+import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
 import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
+import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
 import dagger.hilt.android.HiltAndroidApp
 import timber.log.Timber
+import xyz.teamgravity.pin_lock_compose.PinManager

@HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
    override fun onCreate() {
        super.onCreate()
        instance = this
-        if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree())
+        if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree()) else Timber.plant(ReleaseTree())
+        PinManager.initialize(this)
    }

    companion object {
@@ -24,11 +29,18 @@ class WireGuardAutoTunnel : Application() {
            return instance.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
        }

-        fun requestTileServiceStateUpdate() {
+        fun requestTunnelTileServiceStateUpdate(context: Context) {
            TileService.requestListeningState(
-                instance,
+                context,
                ComponentName(instance, TunnelControlTile::class.java),
            )
        }
+
+        fun requestAutoTunnelTileServiceUpdate(context: Context) {
+            TileService.requestListeningState(
+                context,
+                ComponentName(instance, AutoTunnelControlTile::class.java),
+            )
+        }
    }
 }
@@ -2,27 +2,38 @@ 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.migration.AutoMigrationSpec
 import com.zaneschepke.wireguardautotunnel.data.model.Settings
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig

@Database(
    entities = [Settings::class, TunnelConfig::class],
-    version = 5,
+    version = 7,
    autoMigrations =
-        [
-            AutoMigration(from = 1, to = 2),
-            AutoMigration(from = 2, to = 3),
-            AutoMigration(
-                from = 3,
-                to = 4,
-            ),
-            AutoMigration(
-                from = 4,
-                to = 5,
-            ),
-        ],
+    [
+        AutoMigration(from = 1, to = 2),
+        AutoMigration(from = 2, to = 3),
+        AutoMigration(
+            from = 3,
+            to = 4,
+        ),
+        AutoMigration(
+            from = 4,
+            to = 5,
+        ),
+        AutoMigration(
+            from = 5,
+            to = 6,
+        ),
+        AutoMigration(
+            from = 6,
+            to = 7,
+            spec = RemoveLegacySettingColumnsMigration::class,
+        ),
+    ],
    exportSchema = true,
 )
@TypeConverters(DatabaseListConverters::class)
@@ -31,3 +42,13 @@ abstract class AppDatabase : RoomDatabase() {

    abstract fun tunnelConfigDoa(): TunnelConfigDao
 }
+
+@DeleteColumn(
+    tableName = "Settings",
+    columnName = "default_tunnel",
+)
+@DeleteColumn(
+    tableName = "Settings",
+    columnName = "is_battery_saver_enabled",
+)
+class RemoveLegacySettingColumnsMigration : AutoMigrationSpec
@@ -12,7 +12,7 @@ class DatabaseCallback : RoomDatabase.Callback() {
            execSQL(Queries.createDefaultSettings())
            Timber.i("Bootstrapping settings data")
            setTransactionSuccessful()
-        } catch (e : Exception) {
+        } catch (e: Exception) {
            Timber.e(e)
        } finally {
            endTransaction()
@@ -12,7 +12,7 @@ class DatabaseListConverters {

    @TypeConverter
    fun stringToList(value: String): MutableList<String> {
-        if (value.isEmpty()) return mutableListOf()
+        if (value.isBlank() || value.isEmpty()) return mutableListOf()
        return try {
            Json.decodeFromString<MutableList<String>>(value)
        } catch (e: Exception) {
@@ -1,16 +1,14 @@
 package com.zaneschepke.wireguardautotunnel.data

 object Queries {
-    fun createDefaultSettings() : String {
+    fun createDefaultSettings(): String {
        return """
            INSERT INTO Settings (is_tunnel_enabled,
                    is_tunnel_on_mobile_data_enabled,
                    trusted_network_ssids,
-                    default_tunnel,
                    is_always_on_vpn_enabled,
                    is_tunnel_on_ethernet_enabled,
                    is_shortcuts_enabled,
-                    is_battery_saver_enabled,
                    is_tunnel_on_wifi_enabled,
                    is_kernel_enabled,
                    is_restore_on_boot_enabled,
@@ -18,9 +16,7 @@ object Queries {
                    VALUES
                    ('false',
                    'false',
-                    '[trustedSSID1,trustedSSID2]',
-                     NULL,
-                    'false',
+                    'sampleSSID1,sampleSSID2',
                    'false',
                    'false',
                    'false',
@@ -30,4 +26,10 @@ object Queries {
                    'false')
        """.trimIndent()
    }
+
+    fun createTunnelConfig(): String {
+        return """
+            INSERT INTO TunnelConfig (name, wg_quick) VALUES ('test', 'test')
+        """.trimIndent()
+    }
 }
@@ -10,19 +10,27 @@ import kotlinx.coroutines.flow.Flow

@Dao
 interface SettingsDao {
-    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun save(t: Settings)
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun save(t: Settings)

-    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun saveAll(t: List<Settings>)
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun saveAll(t: List<Settings>)

-    @Query("SELECT * FROM settings WHERE id=:id") suspend fun getById(id: Long): Settings?
+    @Query("SELECT * FROM settings WHERE id=:id")
+    suspend fun getById(id: Long): Settings?

-    @Query("SELECT * FROM settings") suspend fun getAll(): List<Settings>
+    @Query("SELECT * FROM settings")
+    suspend fun getAll(): List<Settings>

-    @Query("SELECT * FROM settings LIMIT 1") fun getSettingsFlow(): Flow<Settings>
+    @Query("SELECT * FROM settings LIMIT 1")
+    fun getSettingsFlow(): Flow<Settings>

-    @Query("SELECT * FROM settings") fun getAllFlow(): Flow<MutableList<Settings>>
+    @Query("SELECT * FROM settings")
+    fun getAllFlow(): Flow<MutableList<Settings>>

-    @Delete suspend fun delete(t: Settings)
+    @Delete
+    suspend fun delete(t: Settings)

-    @Query("SELECT COUNT('id') FROM settings") suspend fun count(): Long
+    @Query("SELECT COUNT('id') FROM settings")
+    suspend fun count(): Long
 }
@@ -6,21 +6,44 @@ import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 import kotlinx.coroutines.flow.Flow

@Dao
 interface TunnelConfigDao {
-    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun save(t: TunnelConfig)
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun save(t: TunnelConfig)

-    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun saveAll(t: List<TunnelConfig>)
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun saveAll(t: TunnelConfigs)

-    @Query("SELECT * FROM TunnelConfig WHERE id=:id") suspend fun getById(id: Long): TunnelConfig?
+    @Query("SELECT * FROM TunnelConfig WHERE id=:id")
+    suspend fun getById(id: Long): TunnelConfig?

-    @Query("SELECT * FROM TunnelConfig") suspend fun getAll(): List<TunnelConfig>
+    @Query("SELECT * FROM TunnelConfig")
+    suspend fun getAll(): TunnelConfigs

-    @Delete suspend fun delete(t: TunnelConfig)
+    @Delete
+    suspend fun delete(t: TunnelConfig)

-    @Query("SELECT COUNT('id') FROM TunnelConfig") suspend fun count(): Long
+    @Query("SELECT COUNT('id') FROM TunnelConfig")
+    suspend fun count(): Long

-    @Query("SELECT * FROM tunnelconfig") fun getAllFlow(): Flow<MutableList<TunnelConfig>>
+    @Query("SELECT * FROM TunnelConfig WHERE tunnel_networks LIKE '%' || :name || '%'")
+    suspend fun findByTunnelNetworkName(name: String): TunnelConfigs
+
+    @Query("UPDATE TunnelConfig SET is_primary_tunnel = 0 WHERE is_primary_tunnel =1")
+    fun resetPrimaryTunnel()
+
+    @Query("UPDATE TunnelConfig SET is_mobile_data_tunnel = 0 WHERE is_mobile_data_tunnel =1")
+    fun resetMobileDataTunnel()
+
+    @Query("SELECT * FROM TUNNELCONFIG WHERE is_primary_tunnel=1")
+    suspend fun findByPrimary(): TunnelConfigs
+
+    @Query("SELECT * FROM TUNNELCONFIG WHERE is_mobile_data_tunnel=1")
+    suspend fun findByMobileDataTunnel(): TunnelConfigs
+
+    @Query("SELECT * FROM tunnelconfig")
+    fun getAllFlow(): Flow<MutableList<TunnelConfig>>
 }
@@ -4,35 +4,67 @@ import android.content.Context
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.runBlocking
+import timber.log.Timber
+import java.io.IOException

 class DataStoreManager(private val context: Context) {
    companion object {
        val LOCATION_DISCLOSURE_SHOWN = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
        val BATTERY_OPTIMIZE_DISABLE_SHOWN = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
+        val TUNNEL_RUNNING_FROM_MANUAL_START =
+            booleanPreferencesKey("TUNNEL_RUNNING_FROM_MANUAL_START")
+        val ACTIVE_TUNNEL = intPreferencesKey("ACTIVE_TUNNEL")
+        val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
    }

    // preferences
    private val preferencesKey = "preferences"
    private val Context.dataStore by
-        preferencesDataStore(
-            name = preferencesKey,
-        )
+    preferencesDataStore(
+        name = preferencesKey,
+    )

    suspend fun init() {
-        context.dataStore.data.first()
+        try {
+            context.dataStore.data.first()
+        } catch (e: IOException) {
+            Timber.e(e)
+        }
+    }
+
+    suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) {
+        try {
+            context.dataStore.edit { it[key] = value }
+        } catch (e: IOException) {
+            Timber.e(e)
+        } catch (e: Exception) {
+            Timber.e(e)
+        }
    }

-    suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) =
-        context.dataStore.edit { it[key] = value }

    fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map { it[key] }

-    suspend fun <T> getFromStore(key: Preferences.Key<T>) =
-        context.dataStore.data.first { it.contains(key) }[key]
+    suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
+        return try {
+            context.dataStore.data.map { it[key] }.first()
+        } catch (e: IOException) {
+            Timber.e(e)
+            null
+        }
+    }
+
+
+    fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
+        context.dataStore.data.map { it[key] }.first()
+    }

    val preferencesFlow: Flow<Preferences?> = context.dataStore.data
 }
@@ -0,0 +1,14 @@
+package com.zaneschepke.wireguardautotunnel.data.model
+
+data class GeneralState(
+    val locationDisclosureShown: Boolean = LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+    val batteryOptimizationDisableShown: Boolean = BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+    val tunnelRunningFromManualStart: Boolean = TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
+    val activeTunnelId: Int? = null
+) {
+    companion object {
+        const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
+        const val BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT = false
+        const val TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT = false
+    }
+}
@@ -7,57 +7,47 @@ import androidx.room.PrimaryKey
@Entity
 data class Settings(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "is_tunnel_enabled") var isAutoTunnelEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_enabled") val isAutoTunnelEnabled: Boolean = false,
    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled")
-    var isTunnelOnMobileDataEnabled: Boolean = false,
+    val isTunnelOnMobileDataEnabled: Boolean = false,
    @ColumnInfo(name = "trusted_network_ssids")
-    var trustedNetworkSSIDs: MutableList<String> = mutableListOf(),
-    @ColumnInfo(name = "default_tunnel") var defaultTunnel: String? = null,
-    @ColumnInfo(name = "is_always_on_vpn_enabled") var isAlwaysOnVpnEnabled: Boolean = false,
+    val trustedNetworkSSIDs: MutableList<String> = mutableListOf(),
+    @ColumnInfo(name = "is_always_on_vpn_enabled") val isAlwaysOnVpnEnabled: Boolean = false,
    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled")
-    var isTunnelOnEthernetEnabled: Boolean = false,
+    val isTunnelOnEthernetEnabled: Boolean = false,
    @ColumnInfo(
        name = "is_shortcuts_enabled",
        defaultValue = "false",
    )
-    var isShortcutsEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_battery_saver_enabled",
-        defaultValue = "false",
-    )
-    var isBatterySaverEnabled: Boolean = false,
+    val isShortcutsEnabled: Boolean = false,
    @ColumnInfo(
        name = "is_tunnel_on_wifi_enabled",
        defaultValue = "false",
    )
-    var isTunnelOnWifiEnabled: Boolean = false,
+    val isTunnelOnWifiEnabled: Boolean = false,
    @ColumnInfo(
        name = "is_kernel_enabled",
        defaultValue = "false",
    )
-    var isKernelEnabled: Boolean = false,
+    val isKernelEnabled: Boolean = false,
    @ColumnInfo(
        name = "is_restore_on_boot_enabled",
        defaultValue = "false",
    )
-    var isRestoreOnBootEnabled: Boolean = false,
+    val isRestoreOnBootEnabled: Boolean = false,
    @ColumnInfo(
        name = "is_multi_tunnel_enabled",
        defaultValue = "false",
    )
-    var isMultiTunnelEnabled: Boolean = false,
+    val isMultiTunnelEnabled: Boolean = false,
    @ColumnInfo(
        name = "is_auto_tunnel_paused",
        defaultValue = "false",
    )
-    var isAutoTunnelPaused: Boolean = false,
-) {
-    fun isTunnelConfigDefault(tunnelConfig: TunnelConfig): Boolean {
-        return if (defaultTunnel != null) {
-            val defaultConfig = TunnelConfig.from(defaultTunnel!!)
-            (tunnelConfig.id == defaultConfig.id)
-        } else {
-            false
-        }
-    }
-}
+    val isAutoTunnelPaused: Boolean = false,
+    @ColumnInfo(
+        name = "is_ping_enabled",
+        defaultValue = "false",
+    )
+    val isPingEnabled: Boolean = false,
+)
@@ -4,27 +4,31 @@ import androidx.room.ColumnInfo
 import androidx.room.Entity
 import androidx.room.Index
 import androidx.room.PrimaryKey
-import com.wireguard.config.Config
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
+import org.amnezia.awg.config.Config
 import java.io.InputStream

@Entity(indices = [Index(value = ["name"], unique = true)])
-@Serializable
 data class TunnelConfig(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "name") var name: String,
-    @ColumnInfo(name = "wg_quick") var wgQuick: String
+    @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,
 ) {
-    override fun toString(): String {
-        return Json.encodeToString(serializer(), this)
-    }
-
    companion object {
-        fun from(string: String): TunnelConfig {
-            return Json.decodeFromString<TunnelConfig>(string)
-        }
-
        fun configFromQuick(wgQuick: String): Config {
            val inputStream: InputStream = wgQuick.byteInputStream()
            val reader = inputStream.bufferedReader(Charsets.UTF_8)
@@ -0,0 +1,14 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+
+interface AppDataRepository {
+    suspend fun getPrimaryOrFirstTunnel(): TunnelConfig?
+    suspend fun getStartTunnelConfig(): TunnelConfig?
+
+    suspend fun toggleWatcherServicePause()
+
+    val settings: SettingsRepository
+    val tunnels: TunnelConfigRepository
+    val appState: AppStateRepository
+}
@@ -0,0 +1,34 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import javax.inject.Inject
+
+class AppDataRoomRepository @Inject constructor(
+    override val settings: SettingsRepository,
+    override val tunnels: TunnelConfigRepository,
+    override val appState: AppStateRepository
+) : AppDataRepository {
+    override suspend fun getPrimaryOrFirstTunnel(): TunnelConfig? {
+        return tunnels.findPrimary().firstOrNull() ?: tunnels.getAll().firstOrNull()
+    }
+
+    override suspend fun getStartTunnelConfig(): TunnelConfig? {
+        return if (appState.isTunnelRunningFromManualStart()) {
+            appState.getActiveTunnelId()?.let {
+                tunnels.getById(it)
+            }
+        } else null
+    }
+
+    override suspend fun toggleWatcherServicePause() {
+        val settings = settings.getSettings()
+        if (settings.isAutoTunnelEnabled) {
+            val pauseAutoTunnel = !settings.isAutoTunnelPaused
+            this.settings.save(
+                settings.copy(
+                    isAutoTunnelPaused = pauseAutoTunnel,
+                ),
+            )
+        }
+    }
+}
@@ -0,0 +1,26 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.model.GeneralState
+import kotlinx.coroutines.flow.Flow
+
+interface AppStateRepository {
+    suspend fun isLocationDisclosureShown(): Boolean
+    suspend fun setLocationDisclosureShown(shown: Boolean)
+
+    suspend fun isBatteryOptimizationDisableShown(): Boolean
+    suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
+
+    suspend fun isTunnelRunningFromManualStart(): Boolean
+    suspend fun setTunnelRunningFromManualStart(id: Int)
+
+    suspend fun setManualStop()
+
+    suspend fun getActiveTunnelId(): Int?
+
+    suspend fun getCurrentSsid(): String?
+
+    suspend fun setCurrentSsid(ssid: String)
+
+    val generalStateFlow: Flow<GeneralState>
+
+}
@@ -0,0 +1,81 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.model.GeneralState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import timber.log.Timber
+
+class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager) :
+    AppStateRepository {
+    override suspend fun isLocationDisclosureShown(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN)
+            ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
+    }
+
+    override suspend fun setLocationDisclosureShown(shown: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown)
+    }
+
+    override suspend fun isBatteryOptimizationDisableShown(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
+            ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
+    }
+
+    override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN, shown)
+    }
+
+    override suspend fun isTunnelRunningFromManualStart(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START)
+            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT
+    }
+
+    override suspend fun setTunnelRunningFromManualStart(id: Int) {
+        setTunnelRunningFromManualStart(true)
+        setActiveTunnelId(id)
+    }
+
+    override suspend fun setManualStop() {
+        setTunnelRunningFromManualStart(false)
+    }
+
+    private suspend fun setTunnelRunningFromManualStart(running: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START, running)
+    }
+
+    override suspend fun getActiveTunnelId(): Int? {
+        return dataStoreManager.getFromStore(DataStoreManager.ACTIVE_TUNNEL)
+    }
+
+    private suspend fun setActiveTunnelId(id: Int) {
+        dataStoreManager.saveToDataStore(DataStoreManager.ACTIVE_TUNNEL, id)
+    }
+
+    override suspend fun getCurrentSsid(): String? {
+        return dataStoreManager.getFromStore(DataStoreManager.CURRENT_SSID)
+    }
+
+    override suspend fun setCurrentSsid(ssid: String) {
+        dataStoreManager.saveToDataStore(DataStoreManager.CURRENT_SSID, ssid)
+    }
+
+    override val generalStateFlow: Flow<GeneralState> =
+        dataStoreManager.preferencesFlow.map { prefs ->
+            prefs?.let { pref ->
+                try {
+                    GeneralState(
+                        locationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
+                            ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+                        batteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
+                            ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+                        tunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
+                            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
+                    )
+                } catch (e: IllegalArgumentException) {
+                    Timber.e(e)
+                    GeneralState()
+                }
+            } ?: GeneralState()
+        }
+}
@@ -4,7 +4,7 @@ import com.zaneschepke.wireguardautotunnel.data.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.model.Settings
 import kotlinx.coroutines.flow.Flow

-class SettingsRepositoryImpl(private val settingsDoa: SettingsDao) : SettingsRepository {
+class RoomSettingsRepository(private val settingsDoa: SettingsDao) : SettingsRepository {

    override suspend fun save(settings: Settings) {
        settingsDoa.save(settings)
@@ -0,0 +1,68 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import kotlinx.coroutines.flow.Flow
+
+class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
+    TunnelConfigRepository {
+    override fun getTunnelConfigsFlow(): Flow<TunnelConfigs> {
+        return tunnelConfigDao.getAllFlow()
+    }
+
+    override suspend fun getAll(): TunnelConfigs {
+        return tunnelConfigDao.getAll()
+    }
+
+    override suspend fun save(tunnelConfig: TunnelConfig) {
+        tunnelConfigDao.save(tunnelConfig)
+    }
+
+    override suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?) {
+        tunnelConfigDao.resetPrimaryTunnel()
+        tunnelConfig?.let {
+            save(
+                it.copy(
+                    isPrimaryTunnel = true,
+                ),
+            )
+        }
+
+    }
+
+    override suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?) {
+        tunnelConfigDao.resetMobileDataTunnel()
+        tunnelConfig?.let {
+            save(
+                it.copy(
+                    isMobileDataTunnel = true,
+                ),
+            )
+        }
+    }
+
+    override suspend fun delete(tunnelConfig: TunnelConfig) {
+        tunnelConfigDao.delete(tunnelConfig)
+    }
+
+    override suspend fun getById(id: Int): TunnelConfig? {
+        return tunnelConfigDao.getById(id.toLong())
+    }
+
+    override suspend fun count(): Int {
+        return tunnelConfigDao.count().toInt()
+    }
+
+    override suspend fun findByTunnelNetworksName(name: String): TunnelConfigs {
+        return tunnelConfigDao.findByTunnelNetworkName(name)
+    }
+
+    override suspend fun findByMobileDataTunnel(): TunnelConfigs {
+        return tunnelConfigDao.findByMobileDataTunnel()
+    }
+
+    override suspend fun findPrimary(): TunnelConfigs {
+        return tunnelConfigDao.findByPrimary()
+    }
+}
@@ -12,7 +12,19 @@ interface TunnelConfigRepository {

    suspend fun save(tunnelConfig: TunnelConfig)

+    suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?)
+
+    suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?)
+
    suspend fun delete(tunnelConfig: TunnelConfig)

+    suspend fun getById(id: Int): TunnelConfig?
+
    suspend fun count(): Int
+
+    suspend fun findByTunnelNetworksName(name: String): TunnelConfigs
+
+    suspend fun findByMobileDataTunnel(): TunnelConfigs
+
+    suspend fun findPrimary(): TunnelConfigs
 }
@@ -1,29 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.repository
-
-import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
-import kotlinx.coroutines.flow.Flow
-
-class TunnelConfigRepositoryImpl(private val tunnelConfigDao: TunnelConfigDao) :
-    TunnelConfigRepository {
-    override fun getTunnelConfigsFlow(): Flow<TunnelConfigs> {
-        return tunnelConfigDao.getAllFlow()
-    }
-
-    override suspend fun getAll(): TunnelConfigs {
-        return tunnelConfigDao.getAll()
-    }
-
-    override suspend fun save(tunnelConfig: TunnelConfig) {
-        tunnelConfigDao.save(tunnelConfig)
-    }
-
-    override suspend fun delete(tunnelConfig: TunnelConfig) {
-        tunnelConfigDao.delete(tunnelConfig)
-    }
-
-    override suspend fun count(): Int {
-        return tunnelConfigDao.count().toInt()
-    }
-}
@@ -19,10 +19,10 @@ class DatabaseModule {
    @Singleton
    fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
        return Room.databaseBuilder(
-                context,
-                AppDatabase::class.java,
-                context.getString(R.string.db_name),
-            )
+            context,
+            AppDatabase::class.java,
+            context.getString(R.string.db_name),
+        )
            .fallbackToDestructiveMigration()
            .addCallback(DatabaseCallback())
            .build()
@@ -2,4 +2,6 @@ package com.zaneschepke.wireguardautotunnel.module

 import javax.inject.Qualifier

-@Qualifier @Retention(AnnotationRetention.BINARY) annotation class Kernel
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class Kernel
@@ -5,10 +5,14 @@ import com.zaneschepke.wireguardautotunnel.data.AppDatabase
 import com.zaneschepke.wireguardautotunnel.data.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
 import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRoomRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.DataStoreAppStateRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.RoomSettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.RoomTunnelConfigRepository
 import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepositoryImpl
 import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepositoryImpl
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -34,13 +38,13 @@ class RepositoryModule {
    @Singleton
    @Provides
    fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao): TunnelConfigRepository {
-        return TunnelConfigRepositoryImpl(tunnelConfigDao)
+        return RoomTunnelConfigRepository(tunnelConfigDao)
    }

    @Singleton
    @Provides
    fun provideSettingsRepository(settingsDao: SettingsDao): SettingsRepository {
-        return SettingsRepositoryImpl(settingsDao)
+        return RoomSettingsRepository(settingsDao)
    }

    @Singleton
@@ -48,4 +52,22 @@ class RepositoryModule {
    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStoreManager {
        return DataStoreManager(context)
    }
+
+    @Provides
+    @Singleton
+    fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
+        return DataStoreAppStateRepository(dataStoreManager)
+    }
+
+    @Provides
+    @Singleton
+    fun provideAppDataRepository(
+        settingsRepository: SettingsRepository,
+        tunnelConfigRepository: TunnelConfigRepository,
+        appStateRepository: AppStateRepository
+    ): AppDataRepository {
+        return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
+    }
+
+
 }
@@ -1,12 +1,8 @@
 package com.zaneschepke.wireguardautotunnel.module

 import android.content.Context
-import com.wireguard.android.backend.Backend
-import com.wireguard.android.backend.GoBackend
-import com.wireguard.android.backend.WgQuickBackend
-import com.wireguard.android.util.RootShell
-import com.wireguard.android.util.ToolsInstaller
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
@@ -14,6 +10,11 @@ import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import org.amnezia.awg.backend.AwgQuickBackend
+import org.amnezia.awg.backend.Backend
+import org.amnezia.awg.backend.GoBackend
+import org.amnezia.awg.util.RootShell
+import org.amnezia.awg.util.ToolsInstaller
 import javax.inject.Singleton

@Module
@@ -36,7 +37,7 @@ class TunnelModule {
    @Singleton
    @Kernel
    fun provideKernelBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
-        return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
+        return AwgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
    }

    @Provides
@@ -44,8 +45,14 @@ class TunnelModule {
    fun provideVpnService(
        @Userspace userspaceBackend: Backend,
        @Kernel kernelBackend: Backend,
-        settingsRepository: SettingsRepository
+        appDataRepository: AppDataRepository
    ): VpnService {
-        return WireGuardTunnel(userspaceBackend, kernelBackend, settingsRepository)
+        return WireGuardTunnel(userspaceBackend, kernelBackend, appDataRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideServiceManager(appDataRepository: AppDataRepository): ServiceManager {
+        return ServiceManager(appDataRepository)
    }
 }
@@ -2,4 +2,6 @@ package com.zaneschepke.wireguardautotunnel.module

 import javax.inject.Qualifier

-@Qualifier @Retention(AnnotationRetention.BINARY) annotation class Userspace
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class Userspace
@@ -3,8 +3,7 @@ package com.zaneschepke.wireguardautotunnel.receiver
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
@@ -14,19 +13,33 @@ import javax.inject.Inject
@AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {

-    @Inject lateinit var settingsRepository: SettingsRepository
+    @Inject
+    lateinit var appDataRepository: AppDataRepository

-    @Inject lateinit var tunnelConfigRepository: TunnelConfigRepository
+    @Inject
+    lateinit var serviceManager: ServiceManager

    override fun onReceive(context: Context?, intent: Intent?) = goAsync {
        if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return@goAsync
-        val settings = settingsRepository.getSettings()
-        if (settings.isAutoTunnelEnabled) {
-            Timber.i("Starting watcher service from boot")
-            ServiceManager.startWatcherServiceForeground(context!!)
-        } else if(settings.isAlwaysOnVpnEnabled) {
-            Timber.i("Starting tunnel from boot")
-            ServiceManager.startVpnServicePrimaryTunnel(context!!, settings, tunnelConfigRepository.getAll().firstOrNull())
+        context?.run {
+            val settings = appDataRepository.settings.getSettings()
+            if (settings.isAutoTunnelEnabled) {
+                Timber.i("Starting watcher service from boot")
+                serviceManager.startWatcherServiceForeground(context)
+            }
+            if (appDataRepository.appState.isTunnelRunningFromManualStart()) {
+                appDataRepository.appState.getActiveTunnelId()?.let {
+                    Timber.i("Starting tunnel that was active before reboot")
+                    serviceManager.startVpnServiceForeground(
+                        context,
+                        appDataRepository.tunnels.getById(it)?.id,
+                    )
+                }
+            }
+            if (settings.isAlwaysOnVpnEnabled) {
+                Timber.i("Starting vpn service from boot AOVPN")
+                serviceManager.startVpnServiceForeground(context)
+            }
        }
    }
 }
@@ -10,20 +10,25 @@ import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
+import timber.log.Timber
 import javax.inject.Inject

@AndroidEntryPoint
 class NotificationActionReceiver : BroadcastReceiver() {
-    @Inject lateinit var settingsRepository: SettingsRepository
+    @Inject
+    lateinit var settingsRepository: SettingsRepository
+
+    @Inject
+    lateinit var serviceManager: ServiceManager

    override fun onReceive(context: Context, intent: Intent?) = goAsync {
        try {
-            val settings = settingsRepository.getSettings()
-            if (settings.defaultTunnel != null) {
-                ServiceManager.stopVpnService(context)
-                delay(Constants.TOGGLE_TUNNEL_DELAY)
-                ServiceManager.startVpnServiceForeground(context, settings.defaultTunnel.toString())
-            }
+            //TODO fix for manual start changes when enabled
+            serviceManager.stopVpnServiceForeground(context)
+            delay(Constants.TOGGLE_TUNNEL_DELAY)
+            serviceManager.startVpnServiceForeground(context)
+        } catch (e: Exception) {
+            Timber.e(e)
        } finally {
            cancel()
        }
@@ -3,5 +3,6 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 enum class Action {
    START,
    START_FOREGROUND,
-    STOP
+    STOP,
+    STOP_FOREGROUND
 }
@@ -4,6 +4,7 @@ import android.content.Intent
 import android.os.Bundle
 import android.os.IBinder
 import androidx.lifecycle.LifecycleService
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import timber.log.Timber

 open class ForegroundService : LifecycleService() {
@@ -23,11 +24,12 @@ open class ForegroundService : LifecycleService() {
            when (action) {
                Action.START.name,
                Action.START_FOREGROUND.name -> startService(intent.extras)
-                Action.STOP.name -> stopService(intent.extras)
-                "android.net.VpnService" -> {
-                    Timber.d("Always-on VPN starting service")
+                Action.STOP.name, Action.STOP_FOREGROUND.name -> stopService()
+                Constants.ALWAYS_ON_VPN_ACTION -> {
+                    Timber.i("Always-on VPN starting service")
                    startService(intent.extras)
                }
+
                else -> Timber.d("This should never happen. No action in the received intent")
            }
        } else {
@@ -35,29 +37,19 @@ open class ForegroundService : LifecycleService() {
                "with a null intent. It has been probably restarted by the system.",
            )
        }
-        // by returning this we make sure the service is restarted if the system kills the service
        return START_STICKY
    }

-    override fun onDestroy() {
-        super.onDestroy()
-        Timber.d("The service has been destroyed")
-    }
-
    protected open fun startService(extras: Bundle?) {
        if (isServiceStarted) return
        Timber.d("Starting ${this.javaClass.simpleName}")
        isServiceStarted = true
    }

-    protected open fun stopService(extras: Bundle?) {
+    protected open fun stopService() {
        Timber.d("Stopping ${this.javaClass.simpleName}")
-        try {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-            stopSelf()
-        } catch (e: Exception) {
-            Timber.d("Service stopped without being started: ${e.message}")
-        }
+        stopForeground(STOP_FOREGROUND_REMOVE)
+        stopSelf()
        isServiceStarted = false
    }
 }
@@ -3,33 +3,17 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 import android.app.Service
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import timber.log.Timber

-object ServiceManager {
-
-    //    private
-    //    fun <T> Context.isServiceRunning(service: Class<T>) =
-    //        (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
-    //            .runningAppProcesses.any {
-    //                it.processName == service.name
-    //            }
-    //
-    //    fun <T : Service> getServiceState(
-    //        context: Context,
-    //        cls: Class<T>
-    //    ): ServiceState {
-    //        val isServiceRunning = context.isServiceRunning(cls)
-    //        return if (isServiceRunning) ServiceState.STARTED else ServiceState.STOPPED
-    //    }
+class ServiceManager(private val appDataRepository: AppDataRepository) {

    private fun <T : Service> actionOnService(
        action: Action,
        context: Context,
        cls: Class<T>,
-        extras: Map<String, String>? = null
+        extras: Map<String, Int>? = null
    ) {
        val intent =
            Intent(context, cls).also {
@@ -39,30 +23,41 @@ object ServiceManager {
        intent.component?.javaClass
        try {
            when (action) {
-                Action.START_FOREGROUND -> {
-                    context.startForegroundService(intent)
-                }
-                Action.START -> {
-                    context.startService(intent)
-                }
-                Action.STOP -> context.startService(intent)
+                Action.START_FOREGROUND, Action.STOP_FOREGROUND -> context.startForegroundService(intent)
+                Action.START, Action.STOP -> context.startService(intent)
            }
        } catch (e: Exception) {
            Timber.e(e.message)
        }
    }

-    fun startVpnService(context: Context, tunnelConfig: String) {
+    suspend fun startVpnService(
+        context: Context,
+        tunnelId: Int? = null,
+        isManualStart: Boolean = false
+    ) {
+        if (isManualStart) onManualStart(tunnelId)
        actionOnService(
            Action.START,
            context,
            WireGuardTunnelService::class.java,
-            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig),
+            tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
        )
    }

-    fun stopVpnService(context: Context) {
-        Timber.d("Stopping vpn service action")
+    suspend fun stopVpnServiceForeground(context: Context, isManualStop: Boolean = false) {
+        if (isManualStop) onManualStop()
+        Timber.i("Stopping vpn service")
+        actionOnService(
+            Action.STOP_FOREGROUND,
+            context,
+            WireGuardTunnelService::class.java,
+        )
+    }
+
+    suspend fun stopVpnService(context: Context, isManualStop: Boolean = false) {
+        if (isManualStop) onManualStop()
+        Timber.i("Stopping vpn service")
        actionOnService(
            Action.STOP,
            context,
@@ -70,24 +65,30 @@ object ServiceManager {
        )
    }

-    fun startVpnServiceForeground(context: Context, tunnelConfig: String) {
+    private suspend fun onManualStop() {
+        appDataRepository.appState.setManualStop()
+    }
+
+    private suspend fun onManualStart(tunnelId: Int?) {
+        tunnelId?.let {
+            appDataRepository.appState.setTunnelRunningFromManualStart(it)
+        }
+    }
+
+    suspend fun startVpnServiceForeground(
+        context: Context,
+        tunnelId: Int? = null,
+        isManualStart: Boolean = false
+    ) {
+        if (isManualStart) onManualStart(tunnelId)
        actionOnService(
            Action.START_FOREGROUND,
            context,
            WireGuardTunnelService::class.java,
-            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig),
+            tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
        )
    }

-    fun startVpnServicePrimaryTunnel(context: Context, settings: Settings, fallbackTunnel: TunnelConfig? = null) {
-        if(settings.defaultTunnel != null) {
-            return startVpnServiceForeground(context, settings.defaultTunnel!!)
-        }
-        if(fallbackTunnel != null) {
-            startVpnServiceForeground(context, fallbackTunnel.toString())
-        }
-    }
-
    fun startWatcherServiceForeground(
        context: Context,
    ) {
@@ -1,6 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-enum class ServiceState {
-    STARTED,
-    STOPPED,
-}
@@ -0,0 +1,84 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import org.amnezia.awg.backend.Tunnel
+
+data class WatcherState(
+    val isWifiConnected: Boolean = false,
+    val config: TunnelConfig? = null,
+    val vpnStatus: Tunnel.State = Tunnel.State.DOWN,
+    val isEthernetConnected: Boolean = false,
+    val isMobileDataConnected: Boolean = false,
+    val currentNetworkSSID: String = "",
+    val settings: Settings = Settings()
+) {
+
+    private fun isVpnConnected() = vpnStatus == Tunnel.State.UP
+    fun isEthernetConditionMet(): Boolean {
+        return (isEthernetConnected &&
+            settings.isTunnelOnEthernetEnabled &&
+            !isVpnConnected())
+    }
+
+    fun isMobileDataConditionMet(): Boolean {
+        return (!isEthernetConnected &&
+            settings.isTunnelOnMobileDataEnabled &&
+            !isWifiConnected &&
+            isMobileDataConnected &&
+            !isVpnConnected())
+    }
+
+    fun isTunnelNotMobileDataPreferredConditionMet(): Boolean {
+        return (!isEthernetConnected &&
+            settings.isTunnelOnMobileDataEnabled &&
+            !isWifiConnected &&
+            isMobileDataConnected &&
+            config?.isMobileDataTunnel == false && isVpnConnected())
+    }
+
+    fun isTunnelOffOnMobileDataConditionMet(): Boolean {
+        return (!isEthernetConnected &&
+            !settings.isTunnelOnMobileDataEnabled &&
+            isMobileDataConnected &&
+            !isWifiConnected &&
+            isVpnConnected())
+    }
+
+    fun isUntrustedWifiConditionMet(): Boolean {
+        return (!isEthernetConnected &&
+            isWifiConnected &&
+            !settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
+            settings.isTunnelOnWifiEnabled
+            && !isVpnConnected())
+    }
+
+    fun isTunnelNotWifiNamePreferredMet(ssid: String): Boolean {
+        return (!isEthernetConnected &&
+            isWifiConnected &&
+            !settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
+            settings.isTunnelOnWifiEnabled && config?.tunnelNetworks?.contains(ssid) == false && isVpnConnected())
+    }
+
+    fun isTrustedWifiConditionMet(): Boolean {
+        return (!isEthernetConnected &&
+            (isWifiConnected &&
+                settings.trustedNetworkSSIDs.contains(currentNetworkSSID)) &&
+            (isVpnConnected()))
+    }
+
+    fun isTunnelOffOnWifiConditionMet(): Boolean {
+        return (!isEthernetConnected &&
+            (isWifiConnected &&
+                !settings.isTunnelOnWifiEnabled &&
+                (isVpnConnected())))
+    }
+
+    fun isTunnelOffOnNoConnectivityMet(): Boolean {
+        return (!isEthernetConnected &&
+            !isWifiConnected &&
+            !isMobileDataConnected &&
+            (isVpnConnected()))
+    }
+}
+
@@ -1,18 +1,13 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground

-import android.app.AlarmManager
-import android.app.PendingIntent
 import android.content.Context
-import android.content.Intent
 import android.os.Bundle
 import android.os.PowerManager
-import android.os.SystemClock
 import androidx.core.app.ServiceCompat
 import androidx.lifecycle.lifecycleScope
-import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
@@ -22,44 +17,47 @@ import com.zaneschepke.wireguardautotunnel.service.notification.NotificationServ
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
+import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
+import java.net.InetAddress
 import javax.inject.Inject

+
@AndroidEntryPoint
 class WireGuardConnectivityWatcherService : ForegroundService() {
    private val foregroundId = 122

-    @Inject lateinit var wifiService: NetworkService<WifiService>
+    @Inject
+    lateinit var wifiService: NetworkService<WifiService>

-    @Inject lateinit var mobileDataService: NetworkService<MobileDataService>
+    @Inject
+    lateinit var mobileDataService: NetworkService<MobileDataService>

-    @Inject lateinit var ethernetService: NetworkService<EthernetService>
+    @Inject
+    lateinit var ethernetService: NetworkService<EthernetService>

-    @Inject lateinit var settingsRepository: SettingsRepository
+    @Inject
+    lateinit var appDataRepository: AppDataRepository

-    @Inject lateinit var notificationService: NotificationService
+    @Inject
+    lateinit var notificationService: NotificationService

-    @Inject lateinit var vpnService: VpnService
+    @Inject
+    lateinit var vpnService: VpnService
+
+    @Inject
+    lateinit var serviceManager: ServiceManager

    private val networkEventsFlow = MutableStateFlow(WatcherState())

-    data class WatcherState(
-        val isWifiConnected: Boolean = false,
-        val isVpnConnected: Boolean = false,
-        val isEthernetConnected: Boolean = false,
-        val isMobileDataConnected: Boolean = false,
-        val currentNetworkSSID: String = "",
-        val settings: Settings = Settings()
-    )
-
-    private lateinit var watcherJob: Job
+    private var watcherJob: Job? = null

    private var wakeLock: PowerManager.WakeLock? = null
    private val tag = this.javaClass.name
@@ -68,7 +66,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
        super.onCreate()
        lifecycleScope.launch(Dispatchers.Main) {
            try {
-                if (settingsRepository.getSettings().isAutoTunnelPaused) {
+                if (appDataRepository.settings.getSettings().isAutoTunnelPaused) {
                    launchWatcherPausedNotification()
                } else launchWatcherNotification()
            } catch (e: Exception) {
@@ -89,8 +87,8 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
        }
    }

-    override fun stopService(extras: Bundle?) {
-        super.stopService(extras)
+    override fun stopService() {
+        super.stopService()
        wakeLock?.let {
            if (it.isHeld) {
                it.release()
@@ -122,44 +120,13 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
        launchWatcherNotification(getString(R.string.watcher_notification_text_paused))
    }

-    // TODO could this be restarting service in a bad state?
-    // try to start task again if killed
-    override fun onTaskRemoved(rootIntent: Intent) {
-        Timber.d("Task Removed called")
-        val restartServiceIntent = Intent(rootIntent)
-        val restartServicePendingIntent: PendingIntent =
-            PendingIntent.getService(
-                this,
-                1,
-                restartServiceIntent,
-                PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE,
-            )
-        applicationContext.getSystemService(Context.ALARM_SERVICE)
-        val alarmService: AlarmManager =
-            applicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
-        alarmService.set(
-            AlarmManager.ELAPSED_REALTIME,
-            SystemClock.elapsedRealtime() + 1000,
-            restartServicePendingIntent,
-        )
-    }
-
-    private suspend fun initWakeLock() {
-        val isBatterySaverOn =
-            withContext(lifecycleScope.coroutineContext) {
-                settingsRepository.getSettings().isBatterySaverEnabled
-            }
+    private fun initWakeLock() {
        wakeLock =
            (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
                newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
                    try {
-                        if (isBatterySaverOn) {
-                            Timber.d("Initiating wakelock with timeout")
-                            acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
-                        } else {
-                            Timber.d("Initiating wakelock with zero timeout")
-                            acquire(Constants.DEFAULT_WATCHER_WAKE_LOCK_TIMEOUT)
-                        }
+                        Timber.i("Initiating wakelock with 10 min timeout")
+                        acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
                    } finally {
                        release()
                    }
@@ -168,43 +135,52 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
    }

    private fun cancelWatcherJob() {
-        if (this::watcherJob.isInitialized) {
-            watcherJob.cancel()
+        try {
+            watcherJob?.cancel()
+        } catch (e : CancellationException) {
+            Timber.i("Watcher job cancelled")
        }
    }

    private fun startWatcherJob() {
        watcherJob =
            lifecycleScope.launch(Dispatchers.IO) {
-                val setting = settingsRepository.getSettings()
+                val setting = appDataRepository.settings.getSettings()
                launch {
-                    Timber.d("Starting wifi watcher")
+                    Timber.i("Starting wifi watcher")
                    watchForWifiConnectivityChanges()
                }
                if (setting.isTunnelOnMobileDataEnabled) {
                    launch {
-                        Timber.d("Starting mobile data watcher")
+                        Timber.i("Starting mobile data watcher")
                        watchForMobileDataConnectivityChanges()
                    }
                }
                if (setting.isTunnelOnEthernetEnabled) {
                    launch {
-                        Timber.d("Starting ethernet data watcher")
+                        Timber.i("Starting ethernet data watcher")
                        watchForEthernetConnectivityChanges()
                    }
                }
                launch {
-                    Timber.d("Starting vpn state watcher")
+                    Timber.i("Starting vpn state watcher")
                    watchForVpnConnectivityChanges()
                }
                launch {
-                    Timber.d("Starting settings watcher")
+                    Timber.i("Starting settings watcher")
                    watchForSettingsChanges()
                }
+                if (setting.isPingEnabled) {
+                    launch {
+                        Timber.i("Starting ping watcher")
+                        watchForPingFailure()
+                    }
+                }
                launch {
-                    Timber.d("Starting management watcher")
+                    Timber.i("Starting management watcher")
                    manageVpn()
                }
+
            }
    }

@@ -212,32 +188,68 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
        mobileDataService.networkStatus.collect {
            when (it) {
                is NetworkStatus.Available -> {
-                    Timber.d("Gained Mobile data connection")
+                    Timber.i("Gained Mobile data connection")
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isMobileDataConnected = true,
                        )
                }
+
                is NetworkStatus.CapabilitiesChanged -> {
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isMobileDataConnected = true,
                        )
-                    Timber.d("Mobile data capabilities changed")
+                    Timber.i("Mobile data capabilities changed")
                }
+
                is NetworkStatus.Unavailable -> {
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isMobileDataConnected = false,
                        )
-                    Timber.d("Lost mobile data connection")
+                    Timber.i("Lost mobile data connection")
                }
            }
        }
    }

+    private suspend fun watchForPingFailure() {
+        try {
+            do {
+                if (vpnService.vpnState.value.status == Tunnel.State.UP) {
+                    val tunnelConfig = vpnService.vpnState.value.tunnelConfig
+                    tunnelConfig?.let {
+                        val config = TunnelConfig.configFromQuick(it.wgQuick)
+                        val results = config.peers.map { peer ->
+                            val host = if (peer.endpoint.isPresent &&
+                                peer.endpoint.get().resolved.isPresent)
+                                peer.endpoint.get().resolved.get().host
+                            else Constants.BACKUP_PING_HOST
+                            Timber.i("Checking reachability of: $host")
+                            val reachable = InetAddress.getByName(host)
+                                .isReachable(Constants.PING_TIMEOUT.toInt())
+                            Timber.i("Result: reachable - $reachable")
+                            reachable
+                        }
+                        if (results.contains(false)) {
+                            Timber.i("Restarting VPN for ping failure")
+                            serviceManager.stopVpnServiceForeground(this)
+                            delay(Constants.VPN_RESTART_DELAY)
+                            serviceManager.startVpnServiceForeground(this)
+                            delay(Constants.PING_COOLDOWN)
+                        }
+                    }
+                }
+                delay(Constants.PING_INTERVAL)
+            } while (true)
+        } catch (e: Exception) {
+            Timber.e(e)
+        }
+    }
+
    private suspend fun watchForSettingsChanges() {
-        settingsRepository.getSettingsFlow().collect {
+        appDataRepository.settings.getSettingsFlow().collect {
            if (networkEventsFlow.value.settings.isAutoTunnelPaused != it.isAutoTunnelPaused) {
                when (it.isAutoTunnelPaused) {
                    true -> launchWatcherPausedNotification()
@@ -253,19 +265,11 @@ class WireGuardConnectivityWatcherService : ForegroundService() {

    private suspend fun watchForVpnConnectivityChanges() {
        vpnService.vpnState.collect {
-            when (it.status) {
-                Tunnel.State.DOWN ->
-                    networkEventsFlow.value =
-                        networkEventsFlow.value.copy(
-                            isVpnConnected = false,
-                        )
-                Tunnel.State.UP ->
-                    networkEventsFlow.value =
-                        networkEventsFlow.value.copy(
-                            isVpnConnected = true,
-                        )
-                else -> {}
-            }
+            networkEventsFlow.value =
+                networkEventsFlow.value.copy(
+                    vpnStatus = it.status,
+                    config = it.tunnelConfig,
+                )
        }
    }

@@ -273,25 +277,27 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
        ethernetService.networkStatus.collect {
            when (it) {
                is NetworkStatus.Available -> {
-                    Timber.d("Gained Ethernet connection")
+                    Timber.i("Gained Ethernet connection")
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isEthernetConnected = true,
                        )
                }
+
                is NetworkStatus.CapabilitiesChanged -> {
-                    Timber.d("Ethernet capabilities changed")
+                    Timber.i("Ethernet capabilities changed")
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isEthernetConnected = true,
                        )
                }
+
                is NetworkStatus.Unavailable -> {
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isEthernetConnected = false,
                        )
-                    Timber.d("Lost Ethernet connection")
+                    Timber.i("Lost Ethernet connection")
                }
            }
        }
@@ -301,95 +307,121 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
        wifiService.networkStatus.collect {
            when (it) {
                is NetworkStatus.Available -> {
-                    Timber.d("Gained Wi-Fi connection")
+                    Timber.i("Gained Wi-Fi connection")
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isWifiConnected = true,
                        )
                }
+
                is NetworkStatus.CapabilitiesChanged -> {
-                    Timber.d("Wifi capabilities changed")
+                    Timber.i("Wifi capabilities changed")
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isWifiConnected = true,
                        )
-                    val ssid = wifiService.getNetworkName(it.networkCapabilities) ?: ""
-                    Timber.d("Detected SSID: $ssid")
-                    networkEventsFlow.value =
-                        networkEventsFlow.value.copy(
-                            currentNetworkSSID = ssid,
-                        )
+                    val ssid = wifiService.getNetworkName(it.networkCapabilities)
+                    ssid?.let {
+                        if(it.contains(Constants.UNREADABLE_SSID)) {
+                            Timber.w("SSID unreadable: missing permissions")
+                        } else Timber.i("Detected valid SSID")
+                        appDataRepository.appState.setCurrentSsid(ssid)
+                        networkEventsFlow.value =
+                            networkEventsFlow.value.copy(
+                                currentNetworkSSID = ssid,
+                            )
+                    } ?: Timber.w("Failed to read ssid")
                }
+
                is NetworkStatus.Unavailable -> {
                    networkEventsFlow.value =
                        networkEventsFlow.value.copy(
                            isWifiConnected = false,
                        )
-                    Timber.d("Lost Wi-Fi connection")
+                    Timber.i("Lost Wi-Fi connection")
                }
            }
        }
    }

-    // TODO clean this up
+    private suspend fun getMobileDataTunnel(): TunnelConfig? {
+        return appDataRepository.tunnels.findByMobileDataTunnel().firstOrNull()
+    }
+
+    private suspend fun getSsidTunnel(ssid: String): TunnelConfig? {
+        return appDataRepository.tunnels.findByTunnelNetworksName(ssid).firstOrNull()
+    }
+
    private suspend fun manageVpn() {
-        networkEventsFlow.collectLatest {
-            Timber.i("New watcher state: $it")
-            if (!it.settings.isAutoTunnelPaused && it.settings.defaultTunnel != null) {
-                delay(Constants.TOGGLE_TUNNEL_DELAY)
+        networkEventsFlow.collectLatest { watcherState ->
+            val autoTunnel = "Auto-tunnel watcher"
+            if (!watcherState.settings.isAutoTunnelPaused) {
+                //delay for rapid network state changes and then collect latest
+                delay(Constants.WATCHER_COLLECTION_DELAY)
                when {
-                    ((it.isEthernetConnected &&
-                        it.settings.isTunnelOnEthernetEnabled &&
-                        !it.isVpnConnected)) -> {
-                        ServiceManager.startVpnServiceForeground(this, it.settings.defaultTunnel!!)
-                        Timber.i("Condition 1 met")
+                    watcherState.isEthernetConditionMet() -> {
+                        Timber.i("$autoTunnel - tunnel on on ethernet condition met")
+                        serviceManager.startVpnServiceForeground(this)
                    }
-                    (!it.isEthernetConnected &&
-                        it.settings.isTunnelOnMobileDataEnabled &&
-                        !it.isWifiConnected &&
-                        it.isMobileDataConnected &&
-                        !it.isVpnConnected) -> {
-                        ServiceManager.startVpnServiceForeground(this, it.settings.defaultTunnel!!)
-                        Timber.i("Condition 2 met")
+
+                    watcherState.isMobileDataConditionMet() -> {
+                        Timber.i("$autoTunnel - tunnel on on mobile data condition met")
+                        serviceManager.startVpnServiceForeground(this, getMobileDataTunnel()?.id)
                    }
-                    (!it.isEthernetConnected &&
-                        !it.settings.isTunnelOnMobileDataEnabled &&
-                        !it.isWifiConnected &&
-                        it.isVpnConnected) -> {
-                        ServiceManager.stopVpnService(this)
-                        Timber.i("Condition 3 met")
+
+                    watcherState.isTunnelNotMobileDataPreferredConditionMet() -> {
+                        getMobileDataTunnel()?.let {
+                            Timber.i("$autoTunnel - tunnel connected on mobile data is not preferred condition met, switching to preferred")
+                            serviceManager.startVpnServiceForeground(
+                                this,
+                                getMobileDataTunnel()?.id,
+                            )
+                        }
                    }
-                    (!it.isEthernetConnected &&
-                        it.isWifiConnected &&
-                        !it.settings.trustedNetworkSSIDs.contains(it.currentNetworkSSID) &&
-                        it.settings.isTunnelOnWifiEnabled &&
-                        (!it.isVpnConnected)) -> {
-                        ServiceManager.startVpnServiceForeground(this, it.settings.defaultTunnel!!)
-                        Timber.i("Condition 4 met")
+
+                    watcherState.isTunnelOffOnMobileDataConditionMet() -> {
+                        Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
+                        serviceManager.stopVpnServiceForeground(this)
                    }
-                    (!it.isEthernetConnected &&
-                        (it.isWifiConnected &&
-                            it.settings.trustedNetworkSSIDs.contains(it.currentNetworkSSID)) &&
-                        (it.isVpnConnected)) -> {
-                        ServiceManager.stopVpnService(this)
-                        Timber.i("Condition 5 met")
+
+                    watcherState.isTunnelNotWifiNamePreferredMet(watcherState.currentNetworkSSID) -> {
+                        Timber.i("$autoTunnel - tunnel on ssid not associated with current tunnel condition met")
+                        getSsidTunnel(watcherState.currentNetworkSSID)?.let {
+                            Timber.i("Found tunnel associated with this SSID, bringing tunnel up")
+                            serviceManager.startVpnServiceForeground(this, it.id)
+                        } ?: suspend {
+                            Timber.i("No tunnel associated with this SSID, using defaults")
+                            if (appDataRepository.getPrimaryOrFirstTunnel()?.name != vpnService.name) {
+                                serviceManager.startVpnServiceForeground(this)
+                            }
+                        }.invoke()
                    }
-                    (!it.isEthernetConnected &&
-                        (it.isWifiConnected &&
-                            !it.settings.isTunnelOnWifiEnabled &&
-                            (it.isVpnConnected))) -> {
-                        ServiceManager.stopVpnService(this)
-                        Timber.i("Condition 6 met")
+
+                    watcherState.isUntrustedWifiConditionMet() -> {
+                        Timber.i("$autoTunnel - tunnel on untrusted wifi condition met")
+                        serviceManager.startVpnServiceForeground(
+                            this,
+                            getSsidTunnel(watcherState.currentNetworkSSID)?.id,
+                        )
                    }
-                    (!it.isEthernetConnected &&
-                        !it.isWifiConnected &&
-                        !it.isMobileDataConnected &&
-                        (it.isVpnConnected)) -> {
-                        ServiceManager.stopVpnService(this)
-                        Timber.i("Condition 7 met")
+
+                    watcherState.isTrustedWifiConditionMet() -> {
+                        Timber.i("$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off")
+                        serviceManager.stopVpnServiceForeground(this)
                    }
+
+                    watcherState.isTunnelOffOnWifiConditionMet() -> {
+                        Timber.i("$autoTunnel - tunnel off on wifi condition met, turning vpn off")
+                        serviceManager.stopVpnServiceForeground(this)
+                    }
+
+                    watcherState.isTunnelOffOnNoConnectivityMet() -> {
+                        Timber.i("$autoTunnel - tunnel off on no connectivity met, turning vpn off")
+                        serviceManager.stopVpnServiceForeground(this)
+                    }
+
                    else -> {
-                        Timber.i("No condition met")
+                        Timber.i("$autoTunnel - no condition met")
                    }
                }
            }
@@ -6,9 +6,7 @@ import android.os.Bundle
 import androidx.core.app.ServiceCompat
 import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
@@ -17,10 +15,12 @@ import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
 import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
 import javax.inject.Inject

@@ -28,23 +28,24 @@ import javax.inject.Inject
 class WireGuardTunnelService : ForegroundService() {
    private val foregroundId = 123

-    @Inject lateinit var vpnService: VpnService
+    @Inject
+    lateinit var vpnService: VpnService

-    @Inject lateinit var settingsRepository: SettingsRepository
+    @Inject
+    lateinit var appDataRepository: AppDataRepository

-    @Inject lateinit var tunnelConfigRepository: TunnelConfigRepository
+    @Inject
+    lateinit var notificationService: NotificationService

-    @Inject lateinit var notificationService: NotificationService
+    private var job: Job? = null

-    private lateinit var job: Job
-
-    private var tunnelName: String = ""
    private var didShowConnected = false

    override fun onCreate() {
        super.onCreate()
        lifecycleScope.launch(Dispatchers.Main) {
-            if (tunnelConfigRepository.getAll().isNotEmpty()) {
+            //TODO fix this to not launch if AOVPN
+            if (appDataRepository.tunnels.count() != 0) {
                launchVpnNotification()
            }
        }
@@ -53,71 +54,73 @@ class WireGuardTunnelService : ForegroundService() {
    override fun startService(extras: Bundle?) {
        super.startService(extras)
        cancelJob()
-        val tunnelConfigString = extras?.getString(getString(R.string.tunnel_extras_key))
-        val tunnelConfig = tunnelConfigString?.let { TunnelConfig.from(it) }
-        tunnelName = tunnelConfig?.name ?: ""
        job =
            lifecycleScope.launch(Dispatchers.IO) {
                launch {
-                    if (tunnelConfig != null) {
-                        try {
-                            tunnelName = tunnelConfig.name
-                            vpnService.startTunnel(tunnelConfig)
-                        } catch (e: Exception) {
-                            Timber.e("Problem starting tunnel: ${e.message}")
-                            stopService(extras)
-                        }
-                    } else {
-                        Timber.d("Tunnel config null, starting default tunnel or first")
-                        val settings = settingsRepository.getSettings()
-                        val tunnels = tunnelConfigRepository.getAll()
-                        if (settings.isAlwaysOnVpnEnabled) {
-                            val tunnel =
-                                if (settings.defaultTunnel != null) {
-                                    TunnelConfig.from(settings.defaultTunnel!!)
-                                } else if (tunnels.isNotEmpty()) {
-                                    tunnels.first()
-                                } else {
-                                    null
-                                }
-                            if (tunnel != null) {
-                                tunnelName = tunnel.name
-                                vpnService.startTunnel(tunnel)
-                            }
-                        }
+                    val tunnelId = extras?.getInt(Constants.TUNNEL_EXTRA_KEY)
+                    if (vpnService.getState() == Tunnel.State.UP) {
+                        vpnService.stopTunnel()
                    }
+                    vpnService.startTunnel(
+                        tunnelId?.let {
+                            appDataRepository.tunnels.getById(it)
+                        },
+                    )
                }
-                // TODO add failed to connect notification
                launch {
-                    vpnService.vpnState.collect { state ->
-                        state.statistics
-                            ?.mapPeerStats()
-                            ?.map { it.value?.handshakeStatus() }
-                            .let { statuses ->
-                                when {
-                                    statuses?.all { it == HandshakeStatus.HEALTHY } == true -> {
-                                        if (!didShowConnected) {
-                                            delay(Constants.VPN_CONNECTED_NOTIFICATION_DELAY)
-                                            launchVpnNotification(
-                                                getString(R.string.tunnel_start_title),
-                                                "${getString(R.string.tunnel_start_text)} $tunnelName",
-                                            )
-                                            didShowConnected = true
-                                        }
-                                    }
-                                    statuses?.any { it == HandshakeStatus.STALE } == true -> {}
-                                    statuses?.all { it == HandshakeStatus.NOT_STARTED } ==
-                                        true -> {}
-                                    else -> {}
-                                }
-                            }
-                    }
+                    handshakeNotifications()
                }
            }
    }

-    override fun stopService(extras: Bundle?) {
-        super.stopService(extras)
+    //TODO improve tunnel notifications
+    private suspend fun handshakeNotifications() {
+        var tunnelName: String? = null
+        vpnService.vpnState.collect { state ->
+            state.statistics
+                ?.mapPeerStats()
+                ?.map { it.value?.handshakeStatus() }
+                .let { statuses ->
+                    when {
+                        statuses?.all { it == HandshakeStatus.HEALTHY } == true -> {
+                            if (!didShowConnected) {
+                                delay(Constants.VPN_CONNECTED_NOTIFICATION_DELAY)
+                                tunnelName = state.tunnelConfig?.name
+                                launchVpnNotification(
+                                    getString(R.string.tunnel_start_title),
+                                    "${getString(R.string.tunnel_start_text)} - $tunnelName",
+                                )
+                                didShowConnected = true
+                            }
+                        }
+
+                        statuses?.any { it == HandshakeStatus.STALE } == true -> {}
+                        statuses?.all { it == HandshakeStatus.NOT_STARTED } ==
+                            true -> {
+                        }
+
+                        else -> {}
+                    }
+                }
+            if (state.status == Tunnel.State.UP && state.tunnelConfig?.name != tunnelName) {
+                tunnelName = state.tunnelConfig?.name
+                launchVpnNotification(
+                    getString(R.string.tunnel_start_title),
+                    "${getString(R.string.tunnel_start_text)} - $tunnelName",
+                )
+            }
+        }
+    }
+
+    private fun launchAlwaysOnDisabledNotification() {
+        launchVpnNotification(
+            title = this.getString(R.string.vpn_connection_failed),
+            description = this.getString(R.string.always_on_disabled),
+        )
+    }
+
+    override fun stopService() {
+        super.stopService()
        lifecycleScope.launch(Dispatchers.IO) {
            vpnService.stopTunnel()
            didShowConnected = false
@@ -154,12 +157,12 @@ class WireGuardTunnelService : ForegroundService() {
                channelId = getString(R.string.vpn_channel_id),
                channelName = getString(R.string.vpn_channel_name),
                action =
-                    PendingIntent.getBroadcast(
-                        this,
-                        0,
-                        Intent(this, NotificationActionReceiver::class.java),
-                        PendingIntent.FLAG_IMMUTABLE,
-                    ),
+                PendingIntent.getBroadcast(
+                    this,
+                    0,
+                    Intent(this, NotificationActionReceiver::class.java),
+                    PendingIntent.FLAG_IMMUTABLE,
+                ),
                actionText = getString(R.string.restart),
                title = getString(R.string.vpn_connection_failed),
                onGoing = false,
@@ -176,8 +179,10 @@ class WireGuardTunnelService : ForegroundService() {
    }

    private fun cancelJob() {
-        if (this::job.isInitialized) {
-            job.cancel()
+        try {
+            job?.cancel()
+        } catch (e : CancellationException) {
+            Timber.i("Tunnel job cancelled")
        }
    }
 }
@@ -53,6 +53,7 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
                        }
                    }
                }
+
                else -> {
                    object : ConnectivityManager.NetworkCallback() {
                        override fun onAvailable(network: Network) {
@@ -117,7 +118,7 @@ inline fun <Result> Flow<NetworkStatus>.map(
    crossinline onUnavailable: suspend (network: Network) -> Result,
    crossinline onAvailable: suspend (network: Network) -> Result,
    crossinline onCapabilitiesChanged:
-        suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result
+    suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result
 ): Flow<Result> = map { status ->
    when (status) {
        is NetworkStatus.Unavailable -> onUnavailable(status.network)
@@ -45,10 +45,10 @@ class WireGuardNotification @Inject constructor(@ApplicationContext private val
    ): Notification {
        val channel =
            NotificationChannel(
-                    channelId,
-                    channelName,
-                    importance,
-                )
+                channelId,
+                channelName,
+                importance,
+            )
                .let {
                    it.description = title
                    it.enableLights(lights)
@@ -1,80 +1,66 @@
 package com.zaneschepke.wireguardautotunnel.service.shortcut

 import android.os.Bundle
-import android.view.View
 import androidx.activity.ComponentActivity
 import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.Action
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardConnectivityWatcherService
 import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import timber.log.Timber
 import javax.inject.Inject

@AndroidEntryPoint
 class ShortcutsActivity : ComponentActivity() {
-    @Inject lateinit var settingsRepository: SettingsRepository

-    @Inject lateinit var tunnelConfigRepository: TunnelConfigRepository
+    @Inject
+    lateinit var appDataRepository: AppDataRepository

-    private suspend fun toggleWatcherServicePause() {
-        val settings = settingsRepository.getSettings()
-        if (settings.isAutoTunnelEnabled) {
-            val pauseAutoTunnel = !settings.isAutoTunnelPaused
-            settingsRepository.save(
-                settings.copy(
-                    isAutoTunnelPaused = pauseAutoTunnel,
-                ),
-            )
-        }
-    }
+    @Inject
+    lateinit var serviceManager: ServiceManager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
-        setContentView(View(this))
-        if (
-            intent
-                .getStringExtra(CLASS_NAME_EXTRA_KEY)
-                .equals(WireGuardTunnelService::class.java.simpleName)
-        ) {
-            lifecycleScope.launch(Dispatchers.Main) {
-                val settings = settingsRepository.getSettings()
-                if (settings.isShortcutsEnabled) {
-                    try {
+        lifecycleScope.launch(Dispatchers.Main) {
+            val settings = appDataRepository.settings.getSettings()
+            if (settings.isShortcutsEnabled) {
+                when (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)) {
+                    WireGuardTunnelService::class.java.simpleName -> {
                        val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
-                        val tunnelConfig =
-                            if (tunnelName != null) {
-                                tunnelConfigRepository.getAll().firstOrNull {
-                                    it.name == tunnelName
-                                }
-                            } else {
-                                if (settings.defaultTunnel == null) {
-                                    tunnelConfigRepository.getAll().first()
-                                } else {
-                                    TunnelConfig.from(settings.defaultTunnel!!)
-                                }
+                        val tunnelConfig = tunnelName?.let {
+                            appDataRepository.tunnels.getAll().firstOrNull {
+                                it.name == tunnelName
                            }
-                        tunnelConfig ?: return@launch
-                        toggleWatcherServicePause()
-                        when (intent.action) {
-                            Action.STOP.name ->
-                                ServiceManager.stopVpnService(
-                                    this@ShortcutsActivity,
-                                )
-                            Action.START.name ->
-                                ServiceManager.startVpnServiceForeground(
-                                    this@ShortcutsActivity,
-                                    tunnelConfig.toString(),
-                                )
                        }
-                    } catch (e: Exception) {
-                        Timber.e(e.message)
-                        finish()
+                        when (intent.action) {
+                            Action.START.name -> serviceManager.startVpnServiceForeground(
+                                this@ShortcutsActivity, tunnelConfig?.id, isManualStart = true,
+                            )
+
+                            Action.STOP.name -> serviceManager.stopVpnServiceForeground(
+                                this@ShortcutsActivity,
+                                isManualStop = true,
+                            )
+                        }
+                    }
+
+                    WireGuardConnectivityWatcherService::class.java.simpleName -> {
+                        when (intent.action) {
+                            Action.START.name -> appDataRepository.settings.save(
+                                settings.copy(
+                                    isAutoTunnelPaused = false,
+                                ),
+                            )
+
+                            Action.STOP.name -> appDataRepository.settings.save(
+                                settings.copy(
+                                    isAutoTunnelPaused = true,
+                                ),
+                            )
+                        }
                    }
                }
            }
@@ -0,0 +1,111 @@
+package com.zaneschepke.wireguardautotunnel.service.tile
+
+import android.os.Build
+import android.service.quicksettings.Tile
+import android.service.quicksettings.TileService
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class AutoTunnelControlTile : TileService() {
+
+    @Inject
+    lateinit var appDataRepository: AppDataRepository
+
+    @Inject
+    lateinit var serviceManager: ServiceManager
+
+    private val scope = CoroutineScope(Dispatchers.IO)
+
+    private var manualStartConfig: TunnelConfig? = null
+
+    override fun onStartListening() {
+        super.onStartListening()
+        scope.launch {
+            appDataRepository.settings.getSettingsFlow().collectLatest {
+                when (it.isAutoTunnelEnabled) {
+                    true -> {
+                        if (it.isAutoTunnelPaused) {
+                            setInactive()
+                            setTileDescription(this@AutoTunnelControlTile.getString(R.string.paused))
+                        } else {
+                            setActive()
+                            setTileDescription(this@AutoTunnelControlTile.getString(R.string.active))
+                        }
+                    }
+
+                    false -> {
+                        setTileDescription(this@AutoTunnelControlTile.getString(R.string.disabled))
+                        setUnavailable()
+                    }
+                }
+            }
+        }
+    }
+
+    override fun onTileAdded() {
+        super.onTileAdded()
+        onStartListening()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        scope.cancel()
+    }
+
+    override fun onTileRemoved() {
+        super.onTileRemoved()
+        scope.cancel()
+    }
+
+    override fun onClick() {
+        super.onClick()
+        unlockAndRun {
+            scope.launch {
+                try {
+                    appDataRepository.toggleWatcherServicePause()
+                } catch (e: Exception) {
+                    Timber.e(e.message)
+                } finally {
+                    cancel()
+                }
+            }
+        }
+    }
+
+    private fun setActive() {
+        qsTile.state = Tile.STATE_ACTIVE
+        qsTile.updateTile()
+    }
+
+    private fun setInactive() {
+        qsTile.state = Tile.STATE_INACTIVE
+        qsTile.updateTile()
+    }
+
+    private fun setUnavailable() {
+        manualStartConfig = null
+        qsTile.state = Tile.STATE_UNAVAILABLE
+        qsTile.updateTile()
+    }
+
+    private fun setTileDescription(description: String) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            qsTile.subtitle = description
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            qsTile.stateDescription = description
+        }
+        qsTile.updateTile()
+    }
+}
@@ -3,10 +3,8 @@ package com.zaneschepke.wireguardautotunnel.service.tile
 import android.os.Build
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
-import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import dagger.hilt.android.AndroidEntryPoint
@@ -14,45 +12,49 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
 import javax.inject.Inject

@AndroidEntryPoint
-class TunnelControlTile() : TileService() {
+class TunnelControlTile : TileService() {

-    @Inject lateinit var tunnelConfigRepository: TunnelConfigRepository
+    @Inject
+    lateinit var appDataRepository: AppDataRepository

-    @Inject lateinit var settingsRepository: SettingsRepository
+    @Inject
+    lateinit var vpnService: VpnService

-    @Inject lateinit var vpnService: VpnService
+    @Inject
+    lateinit var serviceManager: ServiceManager

    private val scope = CoroutineScope(Dispatchers.IO)

-    private var tunnelName: String? = null
+    private var manualStartConfig: TunnelConfig? = null

    override fun onStartListening() {
        super.onStartListening()
        Timber.d("On start listening called")
        scope.launch {
-            vpnService.vpnState.collect {
+            vpnService.vpnState.collect { it ->
                when (it.status) {
-                    Tunnel.State.UP -> setActive()
-                    Tunnel.State.DOWN -> setInactive()
+                    Tunnel.State.UP -> {
+                        setActive()
+                        it.tunnelConfig?.name?.let { name -> setTileDescription(name) }
+                    }
+
+                    Tunnel.State.DOWN -> {
+                        setInactive()
+                        val config = appDataRepository.getStartTunnelConfig()?.also { config ->
+                            manualStartConfig = config
+                        } ?: appDataRepository.getPrimaryOrFirstTunnel()
+                        config?.let {
+                            setTileDescription(it.name)
+                        } ?: setUnavailable()
+                    }
+
                    else -> setInactive()
                }
-                val tunnels = tunnelConfigRepository.getAll()
-                if (tunnels.isEmpty()) {
-                    setUnavailable()
-                    return@collect
-                }
-                tunnelName =
-                    it.name.ifBlank {
-                        val settings = settingsRepository.getSettings()
-                        if (settings.defaultTunnel != null) {
-                            TunnelConfig.from(settings.defaultTunnel!!).name
-                        } else tunnels.firstOrNull()?.name
-                    }
-                setTileDescription(tunnelName ?: "")
            }
        }
    }
@@ -67,20 +69,24 @@ class TunnelControlTile() : TileService() {
        scope.cancel()
    }

+    override fun onTileAdded() {
+        super.onTileAdded()
+        onStartListening()
+    }
+
    override fun onClick() {
        super.onClick()
        unlockAndRun {
            scope.launch {
                try {
-                    val tunnelConfig =
-                        tunnelConfigRepository.getAll().first { it.name == tunnelName }
-                    toggleWatcherServicePause()
                    if (vpnService.getState() == Tunnel.State.UP) {
-                        ServiceManager.stopVpnService(this@TunnelControlTile)
-                    } else {
-                        ServiceManager.startVpnServiceForeground(
+                        serviceManager.stopVpnServiceForeground(
                            this@TunnelControlTile,
-                            tunnelConfig.toString(),
+                            isManualStop = true,
+                        )
+                    } else {
+                        serviceManager.startVpnServiceForeground(
+                            this@TunnelControlTile, manualStartConfig?.id, isManualStart = true,
                        )
                    }
                } catch (e: Exception) {
@@ -92,20 +98,6 @@ class TunnelControlTile() : TileService() {
        }
    }

-    private fun toggleWatcherServicePause() {
-        scope.launch {
-            val settings = settingsRepository.getSettings()
-            if (settings.isAutoTunnelEnabled) {
-                val pauseAutoTunnel = !settings.isAutoTunnelPaused
-                settingsRepository.save(
-                    settings.copy(
-                        isAutoTunnelPaused = pauseAutoTunnel,
-                    ),
-                )
-            }
-        }
-    }
-
    private fun setActive() {
        qsTile.state = Tile.STATE_ACTIVE
        qsTile.updateTile()
@@ -117,6 +109,7 @@ class TunnelControlTile() : TileService() {
    }

    private fun setUnavailable() {
+        manualStartConfig = null
        qsTile.state = Tile.STATE_UNAVAILABLE
        qsTile.updateTile()
    }
@@ -1,11 +1,11 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel

-import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import kotlinx.coroutines.flow.StateFlow
+import org.amnezia.awg.backend.Tunnel

 interface VpnService : Tunnel {
-    suspend fun startTunnel(tunnelConfig: TunnelConfig): Tunnel.State
+    suspend fun startTunnel(tunnelConfig: TunnelConfig? = null): Tunnel.State

    suspend fun stopTunnel()

@@ -1,10 +1,11 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel

-import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Tunnel
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import org.amnezia.awg.backend.Statistics
+import org.amnezia.awg.backend.Tunnel

 data class VpnState(
    val status: Tunnel.State = Tunnel.State.DOWN,
-    val name: String = "",
+    val tunnelConfig: TunnelConfig? = null,
    val statistics: Statistics? = null
 )
@@ -1,16 +1,12 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel

-import com.wireguard.android.backend.Backend
-import com.wireguard.android.backend.BackendException
-import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Tunnel.State
-import com.wireguard.config.Config
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.Kernel
 import com.zaneschepke.wireguardautotunnel.module.Userspace
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -19,24 +15,26 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.Backend
+import org.amnezia.awg.backend.BackendException
+import org.amnezia.awg.backend.Statistics
+import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
 import javax.inject.Inject

 class WireGuardTunnel
@Inject
 constructor(
-    @Userspace private val userspaceBackend : Backend,
+    @Userspace private val userspaceBackend: Backend,
    @Kernel private val kernelBackend: Backend,
-    private val settingsRepository: SettingsRepository
+    private val appDataRepository: AppDataRepository,
 ) : VpnService {
    private val _vpnState = MutableStateFlow(VpnState())
    override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()

    private val scope = CoroutineScope(Dispatchers.IO)

-    private lateinit var statsJob: Job
-
-    private var config: Config? = null
+    private var statsJob: Job? = null

    private var backend: Backend = userspaceBackend

@@ -44,7 +42,7 @@ constructor(

    init {
        scope.launch {
-            settingsRepository.getSettingsFlow().collect {
+            appDataRepository.settings.getSettingsFlow().collect {
                if (it.isKernelEnabled && backendIsUserspace) {
                    Timber.d("Setting kernel backend")
                    backend = kernelBackend
@@ -58,26 +56,28 @@ constructor(
        }
    }

-    override suspend fun startTunnel(tunnelConfig: TunnelConfig): State {
+    override suspend fun startTunnel(tunnelConfig: TunnelConfig?): Tunnel.State {
        return try {
-            stopTunnelOnConfigChange(tunnelConfig)
-            emitTunnelName(tunnelConfig.name)
-            config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val state =
-                backend.setState(
-                    this,
-                    State.UP,
-                    config,
-                )
-            emitTunnelState(state)
-            state
-        } catch (e: Exception) {
+            //TODO we need better error handling here
+            val config = tunnelConfig ?: appDataRepository.getPrimaryOrFirstTunnel()
+            if (config != null) {
+                emitTunnelConfig(config)
+                val wgConfig = TunnelConfig.configFromQuick(config.wgQuick)
+                val state =
+                    backend.setState(
+                        this,
+                        Tunnel.State.UP,
+                        wgConfig,
+                    )
+                state
+            } else throw Exception("No tunnels")
+        } catch (e: BackendException) {
            Timber.e("Failed to start tunnel with error: ${e.message}")
-            State.DOWN
+            Tunnel.State.DOWN
        }
    }

-    private fun emitTunnelState(state: State) {
+    private fun emitTunnelState(state: Tunnel.State) {
        _vpnState.tryEmit(
            _vpnState.value.copy(
                status = state,
@@ -93,28 +93,18 @@ constructor(
        )
    }

-    private suspend fun emitTunnelName(name: String) {
+    private suspend fun emitTunnelConfig(tunnelConfig: TunnelConfig?) {
        _vpnState.emit(
            _vpnState.value.copy(
-                name = name,
+                tunnelConfig = tunnelConfig,
            ),
        )
    }

-    private suspend fun stopTunnelOnConfigChange(tunnelConfig: TunnelConfig) {
-        if (getState() == State.UP && _vpnState.value.name != tunnelConfig.name) {
-            stopTunnel()
-        }
-    }
-
-    override fun getName(): String {
-        return _vpnState.value.name
-    }
-
    override suspend fun stopTunnel() {
        try {
-            if (getState() == State.UP) {
-                val state = backend.setState(this, State.DOWN, null)
+            if (getState() == Tunnel.State.UP) {
+                val state = backend.setState(this, Tunnel.State.DOWN, null)
                emitTunnelState(state)
            }
        } catch (e: BackendException) {
@@ -122,15 +112,19 @@ constructor(
        }
    }

-    override fun getState(): State {
+    override fun getState(): Tunnel.State {
        return backend.getState(this)
    }

-    override fun onStateChange(state: State) {
+    override fun getName(): String {
+        return _vpnState.value.tunnelConfig?.name ?: ""
+    }
+
+    override fun onStateChange(state: Tunnel.State) {
        val tunnel = this
        emitTunnelState(state)
-        WireGuardAutoTunnel.requestTileServiceStateUpdate()
-        if (state == State.UP) {
+        WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(WireGuardAutoTunnel.instance)
+        if (state == Tunnel.State.UP) {
            statsJob =
                scope.launch {
                    while (true) {
@@ -140,9 +134,11 @@ constructor(
                    }
                }
        }
-        if (state == State.DOWN) {
-            if (this::statsJob.isInitialized) {
-                statsJob.cancel()
+        if (state == Tunnel.State.DOWN) {
+            try {
+                statsJob?.cancel()
+            } catch (e : CancellationException) {
+                Timber.i("Stats job cancelled")
            }
        }
    }
@@ -1,12 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import androidx.lifecycle.ViewModel
-import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
-
-@HiltViewModel
-class ActivityViewModel
-@Inject
-constructor() : ViewModel() {
-
-}
@@ -0,0 +1,9 @@
+package com.zaneschepke.wireguardautotunnel.ui
+
+data class AppUiState(
+    val snackbarMessage: String = "",
+    val snackbarMessageConsumed: Boolean = true,
+    val vpnPermissionAccepted: Boolean = false,
+    val notificationPermissionAccepted: Boolean = false,
+    val requestPermissions: Boolean = false
+)
@@ -0,0 +1,148 @@
+package com.zaneschepke.wireguardautotunnel.ui
+
+import android.app.Application
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.net.Uri
+import android.widget.Toast
+import androidx.compose.runtime.mutableStateListOf
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.zaneschepke.logcatter.Logcatter
+import com.zaneschepke.logcatter.model.LogMessage
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.FileUtils
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.GoBackend
+import timber.log.Timber
+import java.time.Instant
+import javax.inject.Inject
+
+@HiltViewModel
+class AppViewModel
+@Inject
+constructor(
+    private val application: Application,
+) : ViewModel() {
+
+    val vpnIntent: Intent? = GoBackend.VpnService.prepare(WireGuardAutoTunnel.instance)
+
+    private val _appUiState = MutableStateFlow(
+        AppUiState(
+            vpnPermissionAccepted = vpnIntent == null,
+        ),
+    )
+    val appUiState = _appUiState.asStateFlow()
+
+
+    fun isRequiredPermissionGranted(): Boolean {
+        val allAccepted =
+            (_appUiState.value.vpnPermissionAccepted && _appUiState.value.vpnPermissionAccepted)
+        if (!allAccepted) requestPermissions()
+        return allAccepted
+    }
+
+    private fun requestPermissions() {
+        _appUiState.value = _appUiState.value.copy(
+            requestPermissions = true,
+        )
+    }
+
+    fun permissionsRequested() {
+        _appUiState.value = _appUiState.value.copy(
+            requestPermissions = false,
+        )
+    }
+
+    fun openWebPage(url: String) {
+        try {
+            val webpage: Uri = Uri.parse(url)
+            val intent = Intent(Intent.ACTION_VIEW, webpage).apply {
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            }
+            application.startActivity(intent)
+        } catch (e: ActivityNotFoundException) {
+            Timber.e(e)
+            showSnackbarMessage(application.getString(R.string.no_browser_detected))
+        }
+    }
+
+    fun onVpnPermissionAccepted() {
+        _appUiState.value = _appUiState.value.copy(
+            vpnPermissionAccepted = true,
+        )
+    }
+
+    fun launchEmail() {
+        try {
+            val intent =
+                Intent(Intent.ACTION_SENDTO).apply {
+                    type = Constants.EMAIL_MIME_TYPE
+                    putExtra(Intent.EXTRA_EMAIL, arrayOf(application.getString(R.string.my_email)))
+                    putExtra(Intent.EXTRA_SUBJECT, application.getString(R.string.email_subject))
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                }
+            application.startActivity(
+                Intent.createChooser(intent, application.getString(R.string.email_chooser)).apply {
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                },
+            )
+        } catch (e: ActivityNotFoundException) {
+            Timber.e(e)
+            showSnackbarMessage(application.getString(R.string.no_email_detected))
+        }
+    }
+
+    fun showSnackbarMessage(message: String) {
+        _appUiState.value = _appUiState.value.copy(
+            snackbarMessage = message,
+            snackbarMessageConsumed = false,
+        )
+    }
+
+    fun snackbarMessageConsumed() {
+        _appUiState.value = _appUiState.value.copy(
+            snackbarMessage = "",
+            snackbarMessageConsumed = true,
+        )
+    }
+
+    val logs = mutableStateListOf<LogMessage>()
+
+    fun readLogCatOutput() =
+        viewModelScope.launch(viewModelScope.coroutineContext + Dispatchers.IO) {
+            launch {
+                Logcatter.logs(callback = {
+                    logs.add(it)
+                    if (logs.size > Constants.LOG_BUFFER_SIZE) {
+                        logs.removeRange(0, (logs.size - Constants.LOG_BUFFER_SIZE).toInt())
+                    }
+                })
+            }
+        }
+
+    fun clearLogs() {
+        logs.clear()
+        Logcatter.clear()
+    }
+
+    fun saveLogsToFile() {
+        val fileName = "${Constants.BASE_LOG_FILE_NAME}-${Instant.now().epochSecond}.txt"
+        val content = logs.joinToString(separator = "\n")
+        FileUtils.saveFileToDownloads(application.applicationContext, content, fileName)
+        Toast.makeText(application, application.getString(R.string.logs_saved), Toast.LENGTH_SHORT)
+            .show()
+    }
+
+    fun setNotificationPermissionAccepted(accepted: Boolean) {
+        _appUiState.value = _appUiState.value.copy(
+            notificationPermissionAccepted = accepted,
+        )
+    }
+}
@@ -1,17 +1,16 @@
 package com.zaneschepke.wireguardautotunnel.ui

 import android.Manifest
-import android.content.Intent
-import android.net.Uri
 import android.os.Build
 import android.os.Bundle
-import android.provider.Settings
 import androidx.activity.SystemBarStyle
+import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.focusable
-import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
@@ -22,6 +21,7 @@ import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.SnackbarResult
 import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
@@ -29,9 +29,12 @@ import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
+import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
@@ -40,20 +43,22 @@ import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
 import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.ui.common.PermissionRequestFailedScreen
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.CustomSnackBar
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.ConfigScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.options.OptionsScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.pinlock.PinLockScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.logs.LogsScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
-import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.StringValue
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import timber.log.Timber
-import java.io.IOException
+import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject

@AndroidEntryPoint
@@ -62,7 +67,12 @@ class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var dataStoreManager: DataStoreManager

-    @Inject lateinit var settingsRepository: SettingsRepository
+    @Inject
+    lateinit var settingsRepository: SettingsRepository
+
+    @Inject
+    lateinit var serviceManager: ServiceManager
+
    @OptIn(
        ExperimentalPermissionsApi::class,
    )
@@ -73,53 +83,82 @@ class MainActivity : AppCompatActivity() {

        // load preferences into memory and init data
        lifecycleScope.launch {
-            try {
-                dataStoreManager.init()
-                WireGuardAutoTunnel.requestTileServiceStateUpdate()
-            } catch (e: IOException) {
-                Timber.e("Failed to load preferences")
+            dataStoreManager.init()
+            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(this@MainActivity)
+            val settings = settingsRepository.getSettings()
+            if (settings.isAutoTunnelEnabled) {
+                serviceManager.startWatcherService(application.applicationContext)
            }
        }
        setContent {
-            //val activityViewModel = hiltViewModel<ActivityViewModel>()
-
+            val appViewModel = hiltViewModel<AppViewModel>()
+            val appUiState by appViewModel.appUiState.collectAsStateWithLifecycle()
            val navController = rememberNavController()
-            val focusRequester = remember { FocusRequester() }
+            val navBackStackEntry by navController.currentBackStackEntryAsState()

-            WireguardAutoTunnelTheme {
-
-                val snackbarHostState = remember { SnackbarHostState() }
-
-                val notificationPermissionState = if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
+            val notificationPermissionState =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS) else null

-                fun requestNotificationPermission() {
-                    if (notificationPermissionState != null && !notificationPermissionState.status.isGranted
-                    ) {
-                        notificationPermissionState.launchPermissionRequest()
-                    }
-                }
+            val snackbarHostState = remember { SnackbarHostState() }

-                LaunchedEffect(Unit) {
-                    requestNotificationPermission()
-                }
+            val vpnActivityResultState =
+                rememberLauncherForActivityResult(
+                    ActivityResultContracts.StartActivityForResult(),
+                    onResult = {
+                        val accepted = (it.resultCode == RESULT_OK)
+                        if (accepted) {
+                            appViewModel.onVpnPermissionAccepted()
+                        }
+                    },
+                )

-                fun showSnackBarMessage(message: String) {
-                    lifecycleScope.launch(Dispatchers.Main) {
-                        val result =
-                            snackbarHostState.showSnackbar(
-                                message = message,
-                                actionLabel = applicationContext.getString(R.string.okay),
-                                duration = SnackbarDuration.Short,
-                            )
-                        when (result) {
-                            SnackbarResult.ActionPerformed,
-                            SnackbarResult.Dismissed -> {
-                                snackbarHostState.currentSnackbarData?.dismiss()
-                            }
+            fun showSnackBarMessage(message: StringValue) {
+                lifecycleScope.launch(Dispatchers.Main) {
+                    val result =
+                        snackbarHostState.showSnackbar(
+                            message = message.asString(this@MainActivity),
+                            duration = SnackbarDuration.Short,
+                        )
+                    when (result) {
+                        SnackbarResult.ActionPerformed,
+                        SnackbarResult.Dismissed -> {
+                            snackbarHostState.currentSnackbarData?.dismiss()
                        }
                    }
                }
+            }
+
+            LaunchedEffect(appUiState.requestPermissions) {
+                if (appUiState.requestPermissions) {
+                    appViewModel.permissionsRequested()
+                    if (notificationPermissionState != null && !notificationPermissionState.status.isGranted
+                    ) {
+                        showSnackBarMessage(StringValue.StringResource(R.string.notification_permission_required))
+                        return@LaunchedEffect notificationPermissionState.launchPermissionRequest()
+                    }
+                    if (!appUiState.vpnPermissionAccepted) {
+                        return@LaunchedEffect vpnActivityResultState.launch(appViewModel.vpnIntent)
+                    }
+                }
+            }
+
+            WireguardAutoTunnelTheme {
+                LaunchedEffect(Unit) {
+                    appViewModel.setNotificationPermissionAccepted(
+                        notificationPermissionState?.status?.isGranted ?: true,
+                    )
+                    if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) appViewModel.readLogCatOutput()
+                }
+
+                LaunchedEffect(appUiState.snackbarMessageConsumed) {
+                    if (!appUiState.snackbarMessageConsumed) {
+                        showSnackBarMessage(StringValue.DynamicString(appUiState.snackbarMessage))
+                        appViewModel.snackbarMessageConsumed()
+                    }
+                }
+
+                val focusRequester = remember { FocusRequester() }

                Scaffold(
                    snackbarHost = {
@@ -128,95 +167,100 @@ class MainActivity : AppCompatActivity() {
                                snackbarData.visuals.message,
                                isRtl = false,
                                containerColor =
-                                    MaterialTheme.colorScheme.surfaceColorAtElevation(
-                                        2.dp,
-                                    ),
+                                MaterialTheme.colorScheme.surfaceColorAtElevation(
+                                    2.dp,
+                                ),
                            )
                        }
                    },
+                    //TODO refactor
                    modifier = Modifier
                        .focusable()
-                        .focusProperties { up = focusRequester },
-                    bottomBar =
-                        if (notificationPermissionState == null || notificationPermissionState.status.isGranted) {
-                            {
-                                BottomNavBar(
-                                    navController,
-                                    listOf(
-                                        Screen.Main.navItem,
-                                        Screen.Settings.navItem,
-                                        Screen.Support.navItem,
-                                    ),
-                                )
+                        .focusProperties {
+                            when (navBackStackEntry?.destination?.route) {
+                                Screen.Lock.route -> Unit
+                                else -> up = focusRequester
                            }
-                        } else {
-                            {}
                        },
+                    bottomBar = {
+                        BottomNavBar(
+                            navController,
+                            listOf(
+                                Screen.Main.navItem,
+                                Screen.Settings.navItem,
+                                Screen.Support.navItem,
+                            ),
+                        )
+                    },
                ) { padding ->
-                        if (notificationPermissionState != null && !notificationPermissionState.status.isGranted) {
-                            Column(modifier = Modifier.padding(padding)) {
-                                PermissionRequestFailedScreen(
-                                    onRequestAgain = {
-                                        val intentSettings =
-                                            Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
-                                        intentSettings.data =
-                                            Uri.fromParts(
-                                                Constants.URI_PACKAGE_SCHEME,
-                                                this@MainActivity.packageName,
-                                                null,
-                                            )
-                                        startActivity(intentSettings)
-                                    },
-                                    message = getString(R.string.notification_permission_required),
-                                    getString(R.string.open_settings),
-                                )
-                                return@Scaffold
-                            }
+                    NavHost(
+                        navController,
+                        startDestination =
+                        (if (PinManager.pinExists()) Screen.Lock.route else Screen.Main.route),
+                        modifier =
+                        Modifier
+                            .padding(padding)
+                            .fillMaxSize(),
+                    ) {
+                        composable(
+                            Screen.Main.route,
+                        ) {
+                            MainScreen(
+                                focusRequester = focusRequester,
+                                appViewModel = appViewModel,
+                                navController = navController,
+                            )
                        }
-                        NavHost(navController, startDestination = Screen.Main.route) {
-                            composable(
-                                Screen.Main.route,
-                            ) {
-                                MainScreen(
-                                    focusRequester = focusRequester,
-                                    showSnackbarMessage = { message -> showSnackBarMessage(message) },
+                        composable(
+                            Screen.Settings.route,
+                        ) {
+                            SettingsScreen(
+                                appViewModel = appViewModel,
+                                navController = navController,
+                                focusRequester = focusRequester,
+                            )
+                        }
+                        composable(
+                            Screen.Support.route,
+                        ) {
+                            SupportScreen(
+                                focusRequester = focusRequester,
+                                appViewModel = appViewModel,
+                                navController = navController,
+                            )
+                        }
+                        composable(Screen.Support.Logs.route) {
+                            LogsScreen(appViewModel)
+                        }
+                        composable("${Screen.Config.route}/{id}") {
+                            val id = it.arguments?.getString("id")
+                            if (!id.isNullOrBlank()) {
+                                ConfigScreen(
                                    navController = navController,
-                                )
-                            }
-                            composable(
-                                Screen.Settings.route,
-                            ) {
-                                SettingsScreen(
-                                    padding = padding,
-                                    showSnackbarMessage = { message -> showSnackBarMessage(message) },
+                                    tunnelId = id,
+                                    appViewModel = appViewModel,
                                    focusRequester = focusRequester,
                                )
-//
-                            }
-                            composable(
-                                Screen.Support.route,
-                            ) {
-                                SupportScreen(
-                                    padding = padding,
-                                    focusRequester = focusRequester,
-                                    showSnackbarMessage = { message -> showSnackBarMessage(message) },
-                                )
-                            }
-                            composable("${Screen.Config.route}/{id}") {
-                                val id = it.arguments?.getString("id")
-                                if (!id.isNullOrBlank()) {
-                                    ConfigScreen(
-                                        padding = padding,
-                                        navController = navController,
-                                        id = id,
-                                        showSnackbarMessage = { message ->
-                                            showSnackBarMessage(message)
-                                        },
-                                        focusRequester = focusRequester,
-                                    )
-                                }
                            }
                        }
+                        composable("${Screen.Option.route}/{id}") {
+                            val id = it.arguments?.getString("id")
+                            if (!id.isNullOrBlank()) {
+                                OptionsScreen(
+                                    navController = navController,
+                                    tunnelId = id,
+                                    appViewModel = appViewModel,
+                                    focusRequester = focusRequester,
+                                )
+                            }
+                        }
+                        composable(Screen.Lock.route) {
+                            PinLockScreen(
+                                navController = navController,
+                                appViewModel = appViewModel,
+                            )
+                        }
+                    }
                }
            }
        }
@@ -4,13 +4,17 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.rounded.Home
 import androidx.compose.material.icons.rounded.QuestionMark
 import androidx.compose.material.icons.rounded.Settings
+import androidx.compose.ui.res.stringResource
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavItem
+import com.zaneschepke.wireguardautotunnel.util.StringValue

 sealed class Screen(val route: String) {
    data object Main : Screen("main") {
        val navItem =
            BottomNavItem(
-                name = "Tunnels",
+                name = WireGuardAutoTunnel.instance.getString(R.string.tunnels),
                route = route,
                icon = Icons.Rounded.Home,
            )
@@ -19,7 +23,7 @@ sealed class Screen(val route: String) {
    data object Settings : Screen("settings") {
        val navItem =
            BottomNavItem(
-                name = "Settings",
+                name = WireGuardAutoTunnel.instance.getString(R.string.settings),
                route = route,
                icon = Icons.Rounded.Settings,
            )
@@ -28,11 +32,16 @@ sealed class Screen(val route: String) {
    data object Support : Screen("support") {
        val navItem =
            BottomNavItem(
-                name = "Support",
+                name = WireGuardAutoTunnel.instance.getString(R.string.support),
                route = route,
                icon = Icons.Rounded.QuestionMark,
            )
+
+        data object Logs : Screen("support/logs")
    }

    data object Config : Screen("config")
+    data object Lock : Screen("lock")
+
+    data object Option : Screen("option")
 }
@@ -10,8 +10,6 @@ import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.res.stringResource
-import com.zaneschepke.wireguardautotunnel.R

@Composable
 fun ClickableIconButton(
@@ -29,9 +27,12 @@ fun ClickableIconButton(
        Spacer(modifier = Modifier.size(ButtonDefaults.IconSpacing))
        Icon(
            imageVector = icon,
-            contentDescription = stringResource(R.string.delete),
+            contentDescription = icon.name,
            modifier =
-                Modifier.size(ButtonDefaults.IconSize).weight(1f, false).clickable {
+            Modifier
+                .size(ButtonDefaults.IconSize)
+                .weight(1f, false)
+                .clickable {
                    if (enabled) {
                        onIconClick()
                    }
@@ -1,36 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import kotlinx.coroutines.launch
-
-@Composable
-fun PermissionRequestFailedScreen(
-    onRequestAgain: () -> Unit,
-    message: String,
-    buttonText: String
-) {
-    val scope = rememberCoroutineScope()
-    Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center,
-        modifier = Modifier.fillMaxSize(),
-    ) {
-        Text(message, textAlign = TextAlign.Center, modifier = Modifier.padding(15.dp))
-        Button(
-            onClick = { scope.launch { onRequestAgain() } },
-        ) {
-            Text(buttonText)
-        }
-    }
-}
@@ -17,9 +17,9 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import com.wireguard.android.backend.Statistics
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.toThreeDecimalPlaceString
+import org.amnezia.awg.backend.Statistics

@OptIn(ExperimentalFoundationApi::class)
@Composable
@@ -34,22 +34,24 @@ fun RowListItem(
 ) {
    Box(
        modifier =
-            Modifier.animateContentSize()
-                .clip(RoundedCornerShape(30.dp))
-                .combinedClickable(
-                    onClick = { onClick() },
-                    onLongClick = { onHold() },
-                ),
+        Modifier
+            .animateContentSize()
+            .clip(RoundedCornerShape(30.dp))
+            .combinedClickable(
+                onClick = { onClick() },
+                onLongClick = { onHold() },
+            ),
    ) {
        Column {
            Row(
-                modifier = Modifier.fillMaxWidth().padding(horizontal = 15.dp, vertical = 5.dp),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 15.dp, vertical = 5.dp),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.SpaceBetween,
            ) {
                Row(
                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth(.60f),
                ) {
                    icon()
                    Text(text)
@@ -60,11 +62,13 @@ fun RowListItem(
                statistics?.peers()?.forEach {
                    Row(
                        modifier =
-                            Modifier.fillMaxWidth()
-                                .padding(end = 10.dp, bottom = 10.dp, start = 10.dp),
+                        Modifier
+                            .fillMaxWidth()
+                            .padding(end = 10.dp, bottom = 10.dp, start = 10.dp),
                        verticalAlignment = Alignment.CenterVertically,
                        horizontalArrangement = Arrangement.SpaceEvenly,
                    ) {
+                        //TODO change these to string resources
                        val handshakeEpoch = statistics.peer(it)!!.latestHandshakeEpochMillis
                        val peerTx = statistics.peer(it)!!.txBytes
                        val peerRx = statistics.peer(it)!!.rxBytes
@@ -63,17 +63,18 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
        },
        maxLines = 1,
        colors =
-            TextFieldDefaults.colors(
-                focusedContainerColor = Color.Transparent,
-                unfocusedContainerColor = Color.Transparent,
-                disabledContainerColor = Color.Transparent,
-            ),
+        TextFieldDefaults.colors(
+            focusedContainerColor = Color.Transparent,
+            unfocusedContainerColor = Color.Transparent,
+            disabledContainerColor = Color.Transparent,
+        ),
        placeholder = { Text(text = stringResource(R.string.hint_search_packages)) },
        textStyle = MaterialTheme.typography.bodySmall,
        singleLine = true,
        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Text),
        modifier =
-            Modifier.fillMaxWidth()
-                .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape),
+        Modifier
+            .fillMaxWidth()
+            .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape),
    )
 }
@@ -27,10 +27,10 @@ fun ConfigurationTextBox(
        maxLines = 1,
        placeholder = { Text(hint) },
        keyboardOptions =
-            KeyboardOptions(
-                capitalization = KeyboardCapitalization.None,
-                imeAction = ImeAction.Done,
-            ),
+        KeyboardOptions(
+            capitalization = KeyboardCapitalization.None,
+            imeAction = ImeAction.Done,
+        ),
        keyboardActions = keyboardActions,
    )
 }
@@ -9,6 +9,7 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.Dp

@Composable
@@ -21,11 +22,18 @@ fun ConfigurationToggle(
    modifier: Modifier = Modifier
 ) {
    Row(
-        modifier = Modifier.fillMaxWidth().padding(padding),
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(padding),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceBetween,
    ) {
-        Text(label)
+        Text(label, textAlign = TextAlign.Start, modifier = Modifier
+            .weight(
+                weight = 1.0f,
+                fill = false,
+            ),
+            softWrap = true)
        Switch(
            modifier = modifier,
            enabled = enabled,
@@ -6,18 +6,33 @@ import androidx.compose.material3.NavigationBar
 import androidx.compose.material3.NavigationBarItem
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
 import androidx.navigation.NavController
 import androidx.navigation.compose.currentBackStackEntryAsState
+import com.zaneschepke.wireguardautotunnel.ui.Screen

@Composable
 fun BottomNavBar(navController: NavController, bottomNavItems: List<BottomNavItem>) {
    val backStackEntry = navController.currentBackStackEntryAsState()

+    var showBottomBar by rememberSaveable { mutableStateOf(true) }
+    val navBackStackEntry by navController.currentBackStackEntryAsState()
+
+    //TODO find a better way to hide nav bar
+    showBottomBar = when (navBackStackEntry?.destination?.route) {
+        Screen.Lock.route -> false
+        else -> true
+    }
+
    NavigationBar(
-        containerColor = MaterialTheme.colorScheme.background,
+        containerColor = if (!showBottomBar) Color.Transparent else MaterialTheme.colorScheme.background,
    ) {
-        bottomNavItems.forEach { item ->
+        if (showBottomBar) bottomNavItems.forEach { item ->
            val selected = item.route == backStackEntry.value?.destination?.route

            NavigationBarItem(
@@ -21,26 +21,32 @@ fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (
                onError("Biometrics not available")
                false
            }
+
            BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> {
                onError("Biometrics not created")
                false
            }
+
            BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> {
                onError("Biometric hardware not found")
                false
            }
+
            BiometricManager.BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED -> {
                onError("Biometric security update required")
                false
            }
+
            BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED -> {
                onError("Biometrics not supported")
                false
            }
+
            BiometricManager.BIOMETRIC_STATUS_UNKNOWN -> {
                onError("Biometrics status unknown")
                false
            }
+
            BiometricManager.BIOMETRIC_SUCCESS -> true
            else -> false
        }
@@ -20,10 +20,8 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel

@Composable
@@ -35,23 +33,27 @@ fun CustomSnackBar(
    Snackbar(
        containerColor = containerColor,
        modifier =
-            Modifier.fillMaxWidth(
-                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) 1 / 3f else 2 / 3f,
-                )
-                .padding(bottom = 100.dp),
+        Modifier
+            .fillMaxWidth(
+                if (WireGuardAutoTunnel.isRunningOnAndroidTv()) 1 / 3f else 2 / 3f,
+            )
+            .padding(bottom = 100.dp),
        shape = RoundedCornerShape(16.dp),
    ) {
        CompositionLocalProvider(
            LocalLayoutDirection provides if (isRtl) LayoutDirection.Rtl else LayoutDirection.Ltr,
        ) {
            Row(
-                modifier = Modifier.width(IntrinsicSize.Max).height(IntrinsicSize.Min),
+                modifier = Modifier
+                    .width(IntrinsicSize.Max)
+                    .height(IntrinsicSize.Min),
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.Start,
            ) {
+                val icon = Icons.Rounded.Info
                Icon(
-                    Icons.Rounded.Info,
-                    contentDescription = stringResource(R.string.info),
+                    icon,
+                    contentDescription = icon.name,
                    tint = Color.White,
                    modifier = Modifier.padding(end = 10.dp),
                )
@@ -16,7 +16,10 @@ fun LoadingScreen() {
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Top,
-        modifier = Modifier.fillMaxSize().focusable().padding(),
+        modifier = Modifier
+            .fillMaxSize()
+            .focusable()
+            .padding(),
    ) {
        Column(modifier = Modifier.padding(120.dp)) { CircularProgressIndicator() }
    }
@@ -0,0 +1,25 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.text
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+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.graphics.Color
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun LogTypeLabel(color: Color, content: @Composable () -> Unit) {
+    Box(
+        modifier = Modifier
+            .size(20.dp)
+            .clip(RoundedCornerShape(2.dp))
+            .background(color),
+        contentAlignment = Alignment.Center,
+    ) {
+        content()
+    }
+}
@@ -15,7 +15,7 @@ import androidx.compose.ui.unit.sp
 fun SectionTitle(title: String, padding: Dp) {
    Text(
        title,
-        textAlign = TextAlign.Center,
+        textAlign = TextAlign.Start,
        style = TextStyle(fontSize = 18.sp, fontWeight = FontWeight.ExtraBold),
        modifier = Modifier.padding(padding, bottom = 5.dp, top = 5.dp),
    )
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.models

-import com.wireguard.config.Interface
+import org.amnezia.awg.config.Interface

 data class InterfaceProxy(
    var privateKey: String = "",
@@ -18,11 +18,11 @@ data class InterfaceProxy(
                addresses = i.addresses.joinToString(", ").trim(),
                dnsServers = i.dnsServers.joinToString(", ").replace("/", "").trim(),
                listenPort =
-                    if (i.listenPort.isPresent) {
-                        i.listenPort.get().toString().trim()
-                    } else {
-                        ""
-                    },
+                if (i.listenPort.isPresent) {
+                    i.listenPort.get().toString().trim()
+                } else {
+                    ""
+                },
                mtu = if (i.mtu.isPresent) i.mtu.get().toString().trim() else "",
            )
        }
@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.models

-import com.wireguard.config.Peer
+import org.amnezia.awg.config.Peer

 data class PeerProxy(
    var publicKey: String = "",
@@ -14,23 +14,23 @@ data class PeerProxy(
            return PeerProxy(
                publicKey = peer.publicKey.toBase64(),
                preSharedKey =
-                    if (peer.preSharedKey.isPresent) {
-                        peer.preSharedKey.get().toBase64().trim()
-                    } else {
-                        ""
-                    },
+                if (peer.preSharedKey.isPresent) {
+                    peer.preSharedKey.get().toBase64().trim()
+                } else {
+                    ""
+                },
                persistentKeepalive =
-                    if (peer.persistentKeepalive.isPresent) {
-                        peer.persistentKeepalive.get().toString().trim()
-                    } else {
-                        ""
-                    },
+                if (peer.persistentKeepalive.isPresent) {
+                    peer.persistentKeepalive.get().toString().trim()
+                } else {
+                    ""
+                },
                endpoint =
-                    if (peer.endpoint.isPresent) {
-                        peer.endpoint.get().toString().trim()
-                    } else {
-                        ""
-                    },
+                if (peer.endpoint.isPresent) {
+                    peer.endpoint.get().toString().trim()
+                } else {
+                    ""
+                },
                allowedIps = peer.allowedIps.joinToString(", ").trim(),
            )
        }
@@ -7,7 +7,6 @@ import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.IntrinsicSize
-import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxHeight
@@ -73,6 +72,7 @@ import androidx.navigation.NavController
 import com.google.accompanist.drawablepainter.DrawablePainter
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.SearchBar
 import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationTextBox
@@ -90,12 +90,11 @@ import kotlinx.coroutines.delay
 )
@Composable
 fun ConfigScreen(
-    padding: PaddingValues,
    viewModel: ConfigViewModel = hiltViewModel(),
    focusRequester: FocusRequester,
    navController: NavController,
-    showSnackbarMessage: (String) -> Unit,
-    id: String
+    appViewModel: AppViewModel,
+    tunnelId: String
 ) {
    val context = LocalContext.current
    val clipboardManager: ClipboardManager = LocalClipboardManager.current
@@ -106,7 +105,7 @@ fun ConfigScreen(

    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

-    LaunchedEffect(Unit) { viewModel.init(id) }
+    LaunchedEffect(Unit) { viewModel.init(tunnelId) }

    LaunchedEffect(uiState.loading) {
        if (!uiState.loading && WireGuardAutoTunnel.isRunningOnAndroidTv()) {
@@ -131,14 +130,14 @@ fun ConfigScreen(
    val applicationButtonText = buildAnnotatedString {
        append(stringResource(id = R.string.tunneling_apps))
        append(": ")
-            if (uiState.isAllApplicationsEnabled) {
-                append(stringResource(id = R.string.all))
-            } else {
-                append("${uiState.checkedPackageNames.size} ")
-                    (if (uiState.include) append(stringResource(id = R.string.included)) else append(
-                        stringResource(id = R.string.excluded),
-                    ))
-            }
+        if (uiState.isAllApplicationsEnabled) {
+            append(stringResource(id = R.string.all))
+        } else {
+            append("${uiState.checkedPackageNames.size} ")
+            (if (uiState.include) append(stringResource(id = R.string.included)) else append(
+                stringResource(id = R.string.excluded),
+            ))
+        }
    }

    if (showAuthPrompt) {
@@ -149,11 +148,11 @@ fun ConfigScreen(
            },
            onError = {
                showAuthPrompt = false
-                showSnackbarMessage(Event.Error.AuthenticationFailed.message)
+                appViewModel.showSnackbarMessage(Event.Error.AuthenticationFailed.message)
            },
            onFailure = {
                showAuthPrompt = false
-                showSnackbarMessage(Event.Error.AuthorizationFailed.message)
+                appViewModel.showSnackbarMessage(Event.Error.AuthorizationFailed.message)
            },
        )
    }
@@ -174,8 +173,10 @@ fun ConfigScreen(
                    .fillMaxWidth()
                    .fillMaxHeight(if (uiState.isAllApplicationsEnabled) 1 / 5f else 4 / 5f),
            ) {
-                Column(modifier = Modifier
-                    .fillMaxWidth()) {
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth(),
+                ) {
                    Row(
                        modifier =
                        Modifier
@@ -258,9 +259,10 @@ fun ConfigScreen(
                                                modifier = Modifier.size(50.dp, 50.dp),
                                            )
                                        } else {
+                                            val icon = Icons.Rounded.Android
                                            Icon(
-                                                Icons.Rounded.Android,
-                                                stringResource(id = R.string.edit),
+                                                icon,
+                                                icon.name,
                                                modifier = Modifier.size(50.dp, 50.dp),
                                            )
                                        }
@@ -273,7 +275,7 @@ fun ConfigScreen(
                                        modifier = Modifier.fillMaxSize(),
                                        checked =
                                        (uiState.checkedPackageNames.contains(
-                                            pack.packageName
+                                            pack.packageName,
                                        )),
                                        onCheckedChange = {
                                            if (it) {
@@ -311,19 +313,20 @@ fun ConfigScreen(
            var fobColor by remember { mutableStateOf(secondaryColor) }
            FloatingActionButton(
                modifier =
-                    Modifier.onFocusChanged {
-                        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                            fobColor = if (it.isFocused) hoverColor else secondaryColor
-                        }
-                    },
+                Modifier.onFocusChanged {
+                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                        fobColor = if (it.isFocused) hoverColor else secondaryColor
+                    }
+                },
                onClick = {
                    viewModel.onSaveAllChanges().let {
                        when (it) {
                            is Result.Success -> {
-                                showSnackbarMessage(it.data.message)
+                                appViewModel.showSnackbarMessage(it.data.message)
                                navController.navigate(Screen.Main.route)
                            }
-                            is Result.Error -> showSnackbarMessage(it.error.message)
+
+                            is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
                        }
                    }
                },
@@ -346,8 +349,7 @@ fun ConfigScreen(
                Modifier
                    .verticalScroll(rememberScrollState())
                    .weight(1f, true)
-                    .fillMaxSize()
-                    .padding(padding),
+                    .fillMaxSize(),
            ) {
                Surface(
                    tonalElevation = 2.dp,
@@ -355,14 +357,14 @@ fun ConfigScreen(
                    shape = RoundedCornerShape(12.dp),
                    color = MaterialTheme.colorScheme.surface,
                    modifier =
-                        (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                            Modifier
-                                .fillMaxHeight(fillMaxHeight)
-                                .fillMaxWidth(fillMaxWidth)
-                            } else {
-                                Modifier.fillMaxWidth(fillMaxWidth)
-                            })
-                            .padding(bottom = 10.dp),
+                    (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                        Modifier
+                            .fillMaxHeight(fillMaxHeight)
+                            .fillMaxWidth(fillMaxWidth)
+                    } else {
+                        Modifier.fillMaxWidth(fillMaxWidth)
+                    })
+                        .padding(bottom = 10.dp),
                ) {
                    Column(
                        horizontalAlignment = Alignment.Start,
@@ -391,10 +393,10 @@ fun ConfigScreen(
                                .clickable { showAuthPrompt = true },
                            value = uiState.interfaceProxy.privateKey,
                            visualTransformation =
-                                if ((id == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated)
-                                    VisualTransformation.None
-                                else PasswordVisualTransformation(),
-                            enabled = (id == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated,
+                            if ((tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated)
+                                VisualTransformation.None
+                            else PasswordVisualTransformation(),
+                            enabled = (tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated,
                            onValueChange = { value -> viewModel.onPrivateKeyChange(value) },
                            trailingIcon = {
                                IconButton(
@@ -504,14 +506,14 @@ fun ConfigScreen(
                        shape = RoundedCornerShape(12.dp),
                        color = MaterialTheme.colorScheme.surface,
                        modifier =
-                            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                                Modifier
-                                    .fillMaxHeight(fillMaxHeight)
-                                    .fillMaxWidth(fillMaxWidth)
-                                } else {
-                                    Modifier.fillMaxWidth(fillMaxWidth)
-                                })
-                                .padding(top = 10.dp, bottom = 10.dp),
+                        (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                            Modifier
+                                .fillMaxHeight(fillMaxHeight)
+                                .fillMaxWidth(fillMaxWidth)
+                        } else {
+                            Modifier.fillMaxWidth(fillMaxWidth)
+                        })
+                            .padding(top = 10.dp, bottom = 10.dp),
                    ) {
                        Column(
                            horizontalAlignment = Alignment.Start,
@@ -532,7 +534,8 @@ fun ConfigScreen(
                                    padding = screenPadding,
                                )
                                IconButton(onClick = { viewModel.onDeletePeer(index) }) {
-                                    Icon(Icons.Rounded.Delete, stringResource(R.string.delete))
+                                    val icon = Icons.Rounded.Delete
+                                    Icon(icon, icon.name)
                                }
                            }

@@ -7,15 +7,9 @@ import android.content.pm.PackageManager
 import android.os.Build
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.wireguard.config.Config
-import com.wireguard.config.Interface
-import com.wireguard.config.Peer
-import com.wireguard.crypto.Key
-import com.wireguard.crypto.KeyPair
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.ui.models.InterfaceProxy
 import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
 import com.zaneschepke.wireguardautotunnel.util.Constants
@@ -28,8 +22,13 @@ import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
+import org.amnezia.awg.config.Config
+import org.amnezia.awg.config.Interface
+import org.amnezia.awg.config.Peer
+import org.amnezia.awg.crypto.Key
+import org.amnezia.awg.crypto.KeyPair
+import timber.log.Timber
 import javax.inject.Inject

@HiltViewModel
@@ -37,8 +36,7 @@ class ConfigViewModel
@Inject
 constructor(
    private val application: Application,
-    private val tunnelConfigRepository: TunnelConfigRepository,
-    private val settingsRepository: SettingsRepository,
+    private val appDataRepository: AppDataRepository
 ) : ViewModel() {

    private val packageManager = application.packageManager
@@ -52,7 +50,8 @@ constructor(
            val state =
                if (tunnelId != Constants.MANUAL_TUNNEL_CONFIG_ID) {
                    val tunnelConfig =
-                        tunnelConfigRepository.getAll().firstOrNull { it.id.toString() == tunnelId }
+                        appDataRepository.tunnels.getAll()
+                            .firstOrNull { it.id.toString() == tunnelId }
                    if (tunnelConfig != null) {
                        val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
                        val proxyPeers = config.peers.map { PeerProxy.from(it) }
@@ -100,7 +99,7 @@ constructor(
    fun onAddCheckedPackage(packageName: String) {
        _uiState.value =
            _uiState.value.copy(
-                checkedPackageNames = _uiState.value.checkedPackageNames + packageName
+                checkedPackageNames = _uiState.value.checkedPackageNames + packageName,
            )
    }

@@ -111,7 +110,7 @@ constructor(
    fun onRemoveCheckedPackage(packageName: String) {
        _uiState.value =
            _uiState.value.copy(
-                checkedPackageNames = _uiState.value.checkedPackageNames - packageName
+                checkedPackageNames = _uiState.value.checkedPackageNames - packageName,
            )
    }

@@ -145,26 +144,16 @@ constructor(
    }

    private fun saveConfig(tunnelConfig: TunnelConfig) =
-        viewModelScope.launch { tunnelConfigRepository.save(tunnelConfig) }
+        viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }

    private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) =
        viewModelScope.launch {
            if (tunnelConfig != null) {
                saveConfig(tunnelConfig).join()
-                WireGuardAutoTunnel.requestTileServiceStateUpdate()
-                updateSettingsDefaultTunnel(tunnelConfig)
+                WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
            }
        }

-    private suspend fun updateSettingsDefaultTunnel(tunnelConfig: TunnelConfig) {
-        val settings = settingsRepository.getSettingsFlow().first()
-        if (settings.defaultTunnel != null) {
-            if (tunnelConfig.id == TunnelConfig.from(settings.defaultTunnel!!).id) {
-                settingsRepository.save(settings.copy(defaultTunnel = tunnelConfig.toString()))
-            }
-        }
-    }
-
    private fun buildPeerListFromProxyPeers(): List<Peer> {
        return _uiState.value.proxyPeers.map {
            val builder = Peer.Builder()
@@ -206,17 +195,23 @@ constructor(
            val peerList = buildPeerListFromProxyPeers()
            val wgInterface = buildInterfaceListFromProxyInterface()
            val config = Config.Builder().addPeers(peerList).setInterface(wgInterface).build()
-            val tunnelConfig = when(uiState.value.tunnel) {
-                null -> TunnelConfig(name = _uiState.value.tunnelName, wgQuick = config.toWgQuickString())
+            val tunnelConfig = when (uiState.value.tunnel) {
+                null -> TunnelConfig(
+                    name = _uiState.value.tunnelName,
+                    wgQuick = config.toAwgQuickString(),
+                )
+
                else -> uiState.value.tunnel!!.copy(
                    name = _uiState.value.tunnelName,
-                    wgQuick = config.toWgQuickString(),
+                    wgQuick = config.toAwgQuickString(),
                )
            }
            updateTunnelConfig(tunnelConfig)
            Result.Success(Event.Message.ConfigSaved)
        } catch (e: Exception) {
-            Result.Error(Event.Error.Exception(e))
+            Timber.e(e)
+            val message = e.message?.substringAfter(":", missingDelimiterValue = "")
+            Result.Error(Event.Error.ConfigParseError(message ?: ""))
        }
    }

@@ -224,10 +219,10 @@ constructor(
        _uiState.value =
            _uiState.value.copy(
                proxyPeers =
-                    _uiState.value.proxyPeers.update(
-                        index,
-                        _uiState.value.proxyPeers[index].copy(publicKey = value),
-                    ),
+                _uiState.value.proxyPeers.update(
+                    index,
+                    _uiState.value.proxyPeers[index].copy(publicKey = value),
+                ),
            )
    }

@@ -235,10 +230,10 @@ constructor(
        _uiState.value =
            _uiState.value.copy(
                proxyPeers =
-                    _uiState.value.proxyPeers.update(
-                        index,
-                        _uiState.value.proxyPeers[index].copy(preSharedKey = value),
-                    ),
+                _uiState.value.proxyPeers.update(
+                    index,
+                    _uiState.value.proxyPeers[index].copy(preSharedKey = value),
+                ),
            )
    }

@@ -246,10 +241,10 @@ constructor(
        _uiState.value =
            _uiState.value.copy(
                proxyPeers =
-                    _uiState.value.proxyPeers.update(
-                        index,
-                        _uiState.value.proxyPeers[index].copy(endpoint = value),
-                    ),
+                _uiState.value.proxyPeers.update(
+                    index,
+                    _uiState.value.proxyPeers[index].copy(endpoint = value),
+                ),
            )
    }

@@ -257,10 +252,10 @@ constructor(
        _uiState.value =
            _uiState.value.copy(
                proxyPeers =
-                    _uiState.value.proxyPeers.update(
-                        index,
-                        _uiState.value.proxyPeers[index].copy(allowedIps = value),
-                    ),
+                _uiState.value.proxyPeers.update(
+                    index,
+                    _uiState.value.proxyPeers[index].copy(allowedIps = value),
+                ),
            )
    }

@@ -268,10 +263,10 @@ constructor(
        _uiState.value =
            _uiState.value.copy(
                proxyPeers =
-                    _uiState.value.proxyPeers.update(
-                        index,
-                        _uiState.value.proxyPeers[index].copy(persistentKeepalive = value),
-                    ),
+                _uiState.value.proxyPeers.update(
+                    index,
+                    _uiState.value.proxyPeers[index].copy(persistentKeepalive = value),
+                ),
            )
    }

@@ -291,31 +286,31 @@ constructor(
        _uiState.value =
            _uiState.value.copy(
                interfaceProxy =
-                    _uiState.value.interfaceProxy.copy(
-                        privateKey = keyPair.privateKey.toBase64(),
-                        publicKey = keyPair.publicKey.toBase64(),
-                    ),
+                _uiState.value.interfaceProxy.copy(
+                    privateKey = keyPair.privateKey.toBase64(),
+                    publicKey = keyPair.publicKey.toBase64(),
+                ),
            )
    }

    fun onAddressesChanged(value: String) {
        _uiState.value =
            _uiState.value.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(addresses = value)
+                interfaceProxy = _uiState.value.interfaceProxy.copy(addresses = value),
            )
    }

    fun onListenPortChanged(value: String) {
        _uiState.value =
            _uiState.value.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(listenPort = value)
+                interfaceProxy = _uiState.value.interfaceProxy.copy(listenPort = value),
            )
    }

    fun onDnsServersChanged(value: String) {
        _uiState.value =
            _uiState.value.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(dnsServers = value)
+                interfaceProxy = _uiState.value.interfaceProxy.copy(dnsServers = value),
            )
    }

@@ -327,14 +322,14 @@ constructor(
    private fun onInterfacePublicKeyChange(value: String) {
        _uiState.value =
            _uiState.value.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(publicKey = value)
+                interfaceProxy = _uiState.value.interfaceProxy.copy(publicKey = value),
            )
    }

    fun onPrivateKeyChange(value: String) {
        _uiState.value =
            _uiState.value.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(privateKey = value)
+                interfaceProxy = _uiState.value.interfaceProxy.copy(privateKey = value),
            )
        if (NumberUtils.isValidKey(value)) {
            val pair = KeyPair(Key.fromBase64(value))
@@ -1,19 +1,18 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.main

+import android.annotation.SuppressLint
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.os.Build
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.animation.slideInVertically
 import androidx.compose.animation.slideOutVertically
 import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.gestures.ScrollableDefaults
@@ -21,11 +20,9 @@ import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.requiredWidth
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
@@ -39,9 +36,11 @@ import androidx.compose.material.icons.filled.QrCode
 import androidx.compose.material.icons.rounded.Add
 import androidx.compose.material.icons.rounded.Bolt
 import androidx.compose.material.icons.rounded.Circle
+import androidx.compose.material.icons.rounded.CopyAll
 import androidx.compose.material.icons.rounded.Delete
-import androidx.compose.material.icons.rounded.Edit
 import androidx.compose.material.icons.rounded.Info
+import androidx.compose.material.icons.rounded.Settings
+import androidx.compose.material.icons.rounded.Smartphone
 import androidx.compose.material.icons.rounded.Star
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -51,13 +50,11 @@ import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.MaterialTheme.typography
 import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
-import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.Composable
@@ -74,10 +71,13 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource
+import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.res.stringResource
@@ -89,12 +89,11 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
 import com.journeyapps.barcodescanner.ScanContract
 import com.journeyapps.barcodescanner.ScanOptions
-import com.wireguard.android.backend.GoBackend
-import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
+import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.CaptureActivityPortrait
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.RowListItem
@@ -106,16 +105,19 @@ import com.zaneschepke.wireguardautotunnel.util.Event
 import com.zaneschepke.wireguardautotunnel.util.Result
 import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
 import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
+import com.zaneschepke.wireguardautotunnel.util.truncateWithEllipsis
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.Tunnel

+@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
@Composable
 fun MainScreen(
    viewModel: MainViewModel = hiltViewModel(),
+    appViewModel: AppViewModel,
    focusRequester: FocusRequester,
-    showSnackbarMessage: (String) -> Unit,
    navController: NavController
 ) {
    val haptic = LocalHapticFeedback.current
@@ -126,34 +128,36 @@ fun MainScreen(
    val sheetState = rememberModalBottomSheetState()
    var showBottomSheet by remember { mutableStateOf(false) }

-    var showPrimaryChangeAlertDialog by remember { mutableStateOf(false) }
+    // Nested scroll for control FAB
+    val nestedScrollConnection = remember {
+        object : NestedScrollConnection {
+            override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
+                // Hide FAB
+                if (available.y < -1) {
+                    isVisible.value = false
+                }
+                // Show FAB
+                if (available.y > 1) {
+                    isVisible.value = true
+                }
+
+                return Offset.Zero
+            }
+        }
+    }
+
+
    var showDeleteTunnelAlertDialog by remember { mutableStateOf(false) }
    var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

-    var vpnIntent by remember { mutableStateOf(GoBackend.VpnService.prepare(WireGuardAutoTunnel.instance)) }
-    val vpnActivityResultState =
-        rememberLauncherForActivityResult(
-            ActivityResultContracts.StartActivityForResult(),
-            onResult = {
-                val accepted = (it.resultCode == AppCompatActivity.RESULT_OK)
-                if (accepted) {
-                    vpnIntent = null
-                }
-            },
-        )
-    LaunchedEffect(uiState.loading) {
-        if (!uiState.loading && WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+    LaunchedEffect(Unit) {
+        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
            delay(Constants.FOCUS_REQUEST_DELAY)
            focusRequester.requestFocus()
        }
    }

-    if (uiState.loading) {
-        LoadingScreen()
-        return
-    }
-
    val tunnelFileImportResultLauncher =
        rememberLauncherForActivityResult(
            object : ActivityResultContracts.GetContent() {
@@ -183,7 +187,7 @@ fun MainScreen(
                                name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
                        }
                    ) {
-                        showSnackbarMessage(Event.Error.FileExplorerRequired.message)
+                        appViewModel.showSnackbarMessage(Event.Error.FileExplorerRequired.message)
                    }
                    return intent
                }
@@ -193,7 +197,7 @@ fun MainScreen(
            scope.launch {
                viewModel.onTunnelFileSelected(data).let {
                    when (it) {
-                        is Result.Error -> showSnackbarMessage(it.error.message)
+                        is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
                        is Result.Success -> {}
                    }
                }
@@ -208,7 +212,7 @@ fun MainScreen(
                        viewModel.onTunnelQrResult(it.contents).let { result ->
                            when (result) {
                                is Result.Success -> {}
-                                is Result.Error -> showSnackbarMessage(result.error.message)
+                                is Result.Error -> appViewModel.showSnackbarMessage(result.error.message)
                            }
                        }
                    }
@@ -216,30 +220,6 @@ fun MainScreen(
            },
        )

-    AnimatedVisibility(showPrimaryChangeAlertDialog) {
-        AlertDialog(
-            onDismissRequest = { showPrimaryChangeAlertDialog = false },
-            confirmButton = {
-                TextButton(
-                    onClick = {
-                        viewModel.onDefaultTunnelChange(selectedTunnel)
-                        showPrimaryChangeAlertDialog = false
-                        selectedTunnel = null
-                    },
-                ) {
-                    Text(text = stringResource(R.string.okay))
-                }
-            },
-            dismissButton = {
-                TextButton(onClick = { showPrimaryChangeAlertDialog = false }) {
-                    Text(text = stringResource(R.string.cancel))
-                }
-            },
-            title = { Text(text = stringResource(R.string.primary_tunnel_change)) },
-            text = { Text(text = stringResource(R.string.primary_tunnel_change_question)) },
-        )
-    }
-
    AnimatedVisibility(showDeleteTunnelAlertDialog) {
        AlertDialog(
            onDismissRequest = { showDeleteTunnelAlertDialog = false },
@@ -265,74 +245,25 @@ fun MainScreen(
    }

    fun onTunnelToggle(checked: Boolean, tunnel: TunnelConfig) {
-        if (vpnIntent != null) {
-            return vpnActivityResultState.launch(vpnIntent)
+        if (appViewModel.isRequiredPermissionGranted()) {
+            if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
        }
-        if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
+    }
+
+    if (uiState.loading) {
+        return LoadingScreen()
    }

    Scaffold(
        modifier =
-            Modifier.pointerInput(Unit) {
-                detectTapGestures(
-                    onTap = {
-                        if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) selectedTunnel = null
-                    },
-                )
-            },
-        floatingActionButtonPosition = FabPosition.End,
-        topBar = {
-            if (uiState.settings.isAutoTunnelEnabled)
-                TopAppBar(
-                    title = {
-                        Row(
-                            horizontalArrangement = Arrangement.SpaceBetween,
-                            verticalAlignment = Alignment.CenterVertically,
-                            modifier =
-                            Modifier
-                                .requiredWidth(LocalConfiguration.current.screenWidthDp.dp)
-                                .padding(end = 5.dp)
-                        ) {
-                            Row {
-                                Icon(
-                                    Icons.Rounded.Bolt,
-                                    stringResource(id = R.string.auto),
-                                    modifier = Modifier.size(25.dp),
-                                    tint =
-                                        if (uiState.settings.isAutoTunnelPaused) Color.Gray
-                                        else mint,
-                                )
-                                val autoTunnelingLabel = buildAnnotatedString {
-                                    append(stringResource(id = R.string.auto_tunneling))
-                                    append(": ")
-                                    if(uiState.settings.isAutoTunnelPaused) append(stringResource(id = R.string.paused)) else append(
-                                        stringResource(id = R.string.active),
-                                    )
-                                }
-                                Text(
-                                    autoTunnelingLabel.text,
-                                    style = typography.bodyLarge,
-                                    modifier = Modifier.padding(start = 10.dp),
-                                )
-                            }
-                            if (uiState.settings.isAutoTunnelPaused)
-                                TextButton(
-                                    onClick = { viewModel.resumeAutoTunneling() },
-                                    modifier = Modifier.padding(end = 10.dp),
-                                ) {
-                                    Text(stringResource(id = R.string.resume))
-                                }
-                            else
-                                TextButton(
-                                    onClick = { viewModel.pauseAutoTunneling() },
-                                    modifier = Modifier.padding(end = 10.dp),
-                                ) {
-                                    Text(stringResource(id = R.string.pause))
-                                }
-                        }
-                    },
-                )
+        Modifier.pointerInput(Unit) {
+            detectTapGestures(
+                onTap = {
+                    selectedTunnel = null
+                },
+            )
        },
+        floatingActionButtonPosition = FabPosition.End,
        floatingActionButton = {
            AnimatedVisibility(
                visible = isVisible.value,
@@ -350,7 +281,6 @@ fun MainScreen(
                    )
                        Modifier.focusRequester(focusRequester)
                    else Modifier)
-                        .padding(bottom = 90.dp)
                        .onFocusChanged {
                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                                fobColor = if (it.isFocused) hoverColor else secondaryColor
@@ -368,14 +298,13 @@ fun MainScreen(
                }
            }
        },
-    ) { innerPadding ->
+    ) {
        AnimatedVisibility(uiState.tunnels.isEmpty(), exit = fadeOut(), enter = fadeIn()) {
            Column(
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.Center,
                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(innerPadding),
+                    .fillMaxSize(),
            ) {
                Text(text = stringResource(R.string.no_tunnels), fontStyle = FontStyle.Italic)
            }
@@ -419,7 +348,7 @@ fun MainScreen(
                                    scanOptions.setDesiredBarcodeFormats(ScanOptions.QR_CODE)
                                    scanOptions.setOrientationLocked(true)
                                    scanOptions.setPrompt(
-                                        context.getString(R.string.scanning_qr)
+                                        context.getString(R.string.scanning_qr),
                                    )
                                    scanOptions.setBeepEnabled(false)
                                    scanOptions.captureActivity =
@@ -471,23 +400,69 @@ fun MainScreen(
            verticalArrangement = Arrangement.Top,
            modifier =
            Modifier
-                .fillMaxWidth()
-                .fillMaxHeight(.90f)
-                .overscroll(ScrollableDefaults.overscrollEffect())
-                .padding(innerPadding),
+                .fillMaxSize()
+                .overscroll(ScrollableDefaults.overscrollEffect()).nestedScroll(nestedScrollConnection),
            state = rememberLazyListState(0, uiState.tunnels.count()),
            userScrollEnabled = true,
-            reverseLayout = true,
+            reverseLayout = false,
            flingBehavior = ScrollableDefaults.flingBehavior(),
        ) {
+            item {
+                if (uiState.settings.isAutoTunnelEnabled) {
+                    val autoTunnelingLabel = buildAnnotatedString {
+                        append(stringResource(id = R.string.auto_tunneling))
+                        append(": ")
+                        if (uiState.settings.isAutoTunnelPaused) append(
+                            stringResource(id = R.string.paused),
+                        ) else append(
+                            stringResource(id = R.string.active),
+                        )
+                    }
+                    RowListItem(
+                        icon = {
+                            val icon = Icons.Rounded.Bolt
+                            Icon(
+                                icon,
+                                icon.name,
+                                modifier = Modifier
+                                    .padding(end = 8.5.dp)
+                                    .size(25.dp),
+                                tint =
+                                if (uiState.settings.isAutoTunnelPaused) Color.Gray
+                                else mint,
+                            )
+                        },
+                        text = autoTunnelingLabel.text,
+                        rowButton = {
+                            if (uiState.settings.isAutoTunnelPaused) {
+                                TextButton(
+                                    onClick = { viewModel.resumeAutoTunneling() },
+                                ) {
+                                    Text(stringResource(id = R.string.resume))
+                                }
+                            } else {
+                                TextButton(
+                                    onClick = { viewModel.pauseAutoTunneling() },
+                                ) {
+                                    Text(stringResource(id = R.string.pause))
+                                }
+                            }
+                        },
+                        onClick = {},
+                        onHold = {},
+                        expanded = false,
+                        statistics = null,
+                    )
+                }
+            }
            items(
                uiState.tunnels,
                key = { tunnel -> tunnel.id },
            ) { tunnel ->
                val leadingIconColor =
                    (if (
-                        uiState.vpnState.name == tunnel.name &&
-                            uiState.vpnState.status == Tunnel.State.UP
+                        uiState.vpnState.tunnelConfig?.name == tunnel.name &&
+                        uiState.vpnState.status == Tunnel.State.UP
                    ) {
                        uiState.vpnState.statistics
                            ?.mapPeerStats()
@@ -498,6 +473,7 @@ fun MainScreen(
                                    statuses?.any { it == HandshakeStatus.STALE } == true -> corn
                                    statuses?.all { it == HandshakeStatus.NOT_STARTED } == true ->
                                        Color.Gray
+
                                    else -> {
                                        Color.Gray
                                    }
@@ -509,33 +485,33 @@ fun MainScreen(
                val expanded = remember { mutableStateOf(false) }
                RowListItem(
                    icon = {
-                        if (uiState.settings.isTunnelConfigDefault(tunnel)) {
-                            Icon(
-                                Icons.Rounded.Star,
-                                stringResource(R.string.status),
-                                tint = leadingIconColor,
-                                modifier = Modifier
-                                    .padding(end = 10.dp)
-                                    .size(20.dp),
-                            )
+                        val circleIcon = Icons.Rounded.Circle
+                        val icon = if (tunnel.isPrimaryTunnel) {
+                            Icons.Rounded.Star
+                        } else if (tunnel.isMobileDataTunnel) {
+                            Icons.Rounded.Smartphone
                        } else {
-                            Icon(
-                                Icons.Rounded.Circle,
-                                stringResource(R.string.status),
-                                tint = leadingIconColor,
-                                modifier = Modifier
-                                    .padding(end = 15.dp)
-                                    .size(15.dp),
-                            )
+                            circleIcon
                        }
+                        Icon(
+                            icon,
+                            icon.name,
+                            tint = leadingIconColor,
+                            modifier = Modifier
+                                .padding(
+                                    end = if (icon == circleIcon) 12.5.dp else 10.dp,
+                                    start = if (icon == circleIcon) 2.5.dp else 0.dp,
+                                )
+                                .size(if (icon == circleIcon) 15.dp else 20.dp),
+                        )
                    },
-                    text = tunnel.name,
+                    text = tunnel.name.truncateWithEllipsis(Constants.ALLOWED_DISPLAY_NAME_LENGTH),
                    onHold = {
                        if (
                            (uiState.vpnState.status == Tunnel.State.UP) &&
-                                (tunnel.name == uiState.vpnState.name)
+                            (tunnel.name == uiState.vpnState.tunnelConfig?.name)
                        ) {
-                            showSnackbarMessage(Event.Message.TunnelOffAction.message)
+                            appViewModel.showSnackbarMessage(Event.Message.TunnelOffAction.message)
                            return@RowListItem
                        }
                        haptic.performHapticFeedback(HapticFeedbackType.LongPress)
@@ -545,7 +521,7 @@ fun MainScreen(
                        if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                            if (
                                uiState.vpnState.status == Tunnel.State.UP &&
-                                    (uiState.vpnState.name == tunnel.name)
+                                (uiState.vpnState.tunnelConfig?.name == tunnel.name)
                            ) {
                                expanded.value = !expanded.value
                            }
@@ -559,62 +535,51 @@ fun MainScreen(
                    rowButton = {
                        if (
                            tunnel.id == selectedTunnel?.id &&
-                                !WireGuardAutoTunnel.isRunningOnAndroidTv()
+                            !WireGuardAutoTunnel.isRunningOnAndroidTv()
                        ) {
                            Row {
-                                if (!uiState.settings.isTunnelConfigDefault(tunnel)) {
-                                    IconButton(
-                                        onClick = {
-                                            if (
-                                                uiState.settings.isAutoTunnelEnabled &&
-                                                    !uiState.settings.isAutoTunnelPaused
-                                            ) {
-                                                showSnackbarMessage(
-                                                    Event.Message.AutoTunnelOffAction.message,
-                                                )
-                                            } else {
-                                                showPrimaryChangeAlertDialog = true
-                                            }
-                                        },
-                                    ) {
-                                        Icon(
-                                            Icons.Rounded.Star,
-                                            stringResource(id = R.string.set_primary),
-                                        )
-                                    }
-                                }
                                IconButton(
                                    onClick = {
                                        if (
                                            uiState.settings.isAutoTunnelEnabled &&
-                                                uiState.settings.isTunnelConfigDefault(
-                                                    tunnel,
-                                                ) &&
-                                                !uiState.settings.isAutoTunnelPaused
+                                            !uiState.settings.isAutoTunnelPaused
                                        ) {
-                                            showSnackbarMessage(
+                                            appViewModel.showSnackbarMessage(
                                                Event.Message.AutoTunnelOffAction.message,
                                            )
-                                        } else
+                                        } else {
                                            navController.navigate(
-                                                "${Screen.Config.route}/${selectedTunnel?.id}",
+                                                "${Screen.Option.route}/${selectedTunnel?.id}",
                                            )
+                                        }
                                    },
                                ) {
-                                    Icon(Icons.Rounded.Edit, stringResource(id = R.string.edit))
+                                    val icon = Icons.Rounded.Settings
+                                    Icon(
+                                        icon,
+                                        icon.name,
+                                    )
+                                }
+                                IconButton(
+                                    modifier = Modifier.focusable(),
+                                    onClick = { viewModel.onCopyTunnel(selectedTunnel) },
+                                ) {
+                                    val icon = Icons.Rounded.CopyAll
+                                    Icon(icon, icon.name)
                                }
                                IconButton(
                                    modifier = Modifier.focusable(),
                                    onClick = { showDeleteTunnelAlertDialog = true },
                                ) {
-                                    Icon(Icons.Rounded.Delete, stringResource(id = R.string.delete))
+                                    val icon = Icons.Rounded.Delete
+                                    Icon(icon, icon.name)
                                }
                            }
                        } else {
                            val checked by remember {
                                derivedStateOf {
                                    (uiState.vpnState.status == Tunnel.State.UP &&
-                                        tunnel.name == uiState.vpnState.name)
+                                        tunnel.name == uiState.vpnState.tunnelConfig?.name)
                                }
                            }
                            if (!checked) expanded.value = false
@@ -631,77 +596,69 @@ fun MainScreen(
                                )
                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                                Row {
-                                    if (!uiState.settings.isTunnelConfigDefault(tunnel)) {
-                                        IconButton(
-                                            onClick = {
-                                                if (uiState.settings.isAutoTunnelEnabled) {
-                                                    showSnackbarMessage(
-                                                        Event.Message.AutoTunnelOffAction.message,
-                                                    )
-                                                } else {
-                                                    selectedTunnel = tunnel
-                                                    showPrimaryChangeAlertDialog = true
-                                                }
-                                            },
-                                        ) {
-                                            Icon(
-                                                Icons.Rounded.Star,
-                                                stringResource(id = R.string.set_primary),
-                                            )
-                                        }
+                                    IconButton(
+                                        onClick = {
+                                            if (uiState.settings.isAutoTunnelEnabled) {
+                                                appViewModel.showSnackbarMessage(
+                                                    Event.Message.AutoTunnelOffAction.message,
+                                                )
+                                            } else {
+                                                selectedTunnel = tunnel
+                                                navController.navigate(
+                                                    "${Screen.Option.route}/${selectedTunnel?.id}",
+                                                )
+                                            }
+                                        },
+                                    ) {
+                                        val icon = Icons.Rounded.Settings
+                                        Icon(
+                                            icon,
+                                            icon.name,
+                                        )
                                    }
                                    IconButton(
                                        modifier = Modifier.focusRequester(focusRequester),
                                        onClick = {
                                            if (
                                                uiState.vpnState.status == Tunnel.State.UP &&
-                                                    (uiState.vpnState.name == tunnel.name)
+                                                (uiState.vpnState.tunnelConfig?.name == tunnel.name)
                                            ) {
                                                expanded.value = !expanded.value
                                            } else {
-                                                showSnackbarMessage(
-                                                    Event.Message.TunnelOnAction.message
+                                                appViewModel.showSnackbarMessage(
+                                                    Event.Message.TunnelOnAction.message,
                                                )
                                            }
                                        },
                                    ) {
-                                        Icon(Icons.Rounded.Info, stringResource(R.string.info))
+                                        val icon = Icons.Rounded.Info
+                                        Icon(icon, icon.name)
+                                    }
+                                    IconButton(
+                                        onClick = { viewModel.onCopyTunnel(tunnel) },
+                                    ) {
+                                        val icon = Icons.Rounded.CopyAll
+                                        Icon(icon, icon.name)
                                    }
                                    IconButton(
                                        onClick = {
                                            if (
                                                uiState.vpnState.status == Tunnel.State.UP &&
-                                                    tunnel.name == uiState.vpnState.name
+                                                tunnel.name == uiState.vpnState.tunnelConfig?.name
                                            ) {
-                                                showSnackbarMessage(
-                                                    Event.Message.TunnelOffAction.message
-                                                )
-                                            } else {
-                                                navController.navigate(
-                                                    "${Screen.Config.route}/${tunnel.id}",
-                                                )
-                                            }
-                                        },
-                                    ) {
-                                        Icon(Icons.Rounded.Edit, stringResource(id = R.string.edit))
-                                    }
-                                    IconButton(
-                                        onClick = {
-                                            if (
-                                                uiState.vpnState.status == Tunnel.State.UP &&
-                                                    tunnel.name == uiState.vpnState.name
-                                            ) {
-                                                showSnackbarMessage(
-                                                    Event.Message.TunnelOffAction.message
+                                                appViewModel.showSnackbarMessage(
+                                                    Event.Message.TunnelOffAction.message,
                                                )
                                            } else {
+                                                selectedTunnel = tunnel
                                                showDeleteTunnelAlertDialog = true
                                            }
                                        },
                                    ) {
+                                        val icon = Icons.Rounded.Delete
                                        Icon(
-                                            Icons.Rounded.Delete,
-                                            stringResource(id = R.string.delete),
+                                            icon,
+                                            icon.name,
                                        )
                                    }
                                    TunnelSwitch()
@@ -7,12 +7,10 @@ import android.net.Uri
 import android.provider.OpenableColumns
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.wireguard.config.Config
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.model.Settings
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
@@ -21,13 +19,12 @@ import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.Result
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import org.amnezia.awg.config.Config
 import timber.log.Timber
 import java.io.InputStream
 import java.util.zip.ZipInputStream
@@ -38,76 +35,67 @@ class MainViewModel
@Inject
 constructor(
    private val application: Application,
-    private val tunnelConfigRepository: TunnelConfigRepository,
-    private val settingsRepository: SettingsRepository,
-    private val vpnService: VpnService
+    private val appDataRepository: AppDataRepository,
+    private val serviceManager: ServiceManager,
+    val vpnService: VpnService
 ) : ViewModel() {

    val uiState =
        combine(
-                settingsRepository.getSettingsFlow(),
-                tunnelConfigRepository.getTunnelConfigsFlow(),
-                vpnService.vpnState,
-            ) { settings, tunnels, vpnState ->
-                validateWatcherServiceState(settings)
-                MainUiState(settings, tunnels, vpnState, false)
-            }
+            appDataRepository.settings.getSettingsFlow(),
+            appDataRepository.tunnels.getTunnelConfigsFlow(),
+            vpnService.vpnState,
+        ) { settings, tunnels, vpnState ->
+            MainUiState(settings, tunnels, vpnState, false)
+        }
            .stateIn(
                viewModelScope,
                SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
                MainUiState(),
            )

-    private fun validateWatcherServiceState(settings: Settings) =
-        viewModelScope.launch(Dispatchers.IO) {
-            if (settings.isAutoTunnelEnabled) {
-                ServiceManager.startWatcherService(application.applicationContext)
-            }
-        }
-
    private fun stopWatcherService() =
        viewModelScope.launch(Dispatchers.IO) {
-            ServiceManager.stopWatcherService(application.applicationContext)
+            serviceManager.stopWatcherService(application.applicationContext)
        }

    fun onDelete(tunnel: TunnelConfig) {
        viewModelScope.launch(Dispatchers.IO) {
-            if (tunnelConfigRepository.count() == 1) {
+            val settings = appDataRepository.settings.getSettings()
+            val isPrimary = tunnel.isPrimaryTunnel
+            if (appDataRepository.tunnels.count() == 1 || isPrimary) {
                stopWatcherService()
-                val settings = settingsRepository.getSettings()
-                settings.defaultTunnel = null
-                settings.isAutoTunnelEnabled = false
-                settings.isAlwaysOnVpnEnabled = false
-                saveSettings(settings)
+                resetTunnelSetting(settings)
            }
-            tunnelConfigRepository.delete(tunnel)
-            WireGuardAutoTunnel.requestTileServiceStateUpdate()
+            appDataRepository.tunnels.delete(tunnel)
+            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
        }
    }

+    private fun resetTunnelSetting(settings: Settings) {
+        saveSettings(
+            settings.copy(
+                isAutoTunnelEnabled = false,
+                isAlwaysOnVpnEnabled = false,
+            ),
+        )
+    }
+
    fun onTunnelStart(tunnelConfig: TunnelConfig) =
        viewModelScope.launch(Dispatchers.IO) {
            Timber.d("On start called!")
-            stopActiveTunnel().await()
-            startTunnel(tunnelConfig)
+            serviceManager.startVpnService(
+                application.applicationContext,
+                tunnelConfig.id,
+                isManualStart = true,
+            )
        }

-    private fun startTunnel(tunnelConfig: TunnelConfig) =
-        viewModelScope.launch(Dispatchers.IO) {
-            Timber.d("Start tunnel via manager")
-            ServiceManager.startVpnService(application.applicationContext, tunnelConfig.toString())
-        }
-
-    private fun stopActiveTunnel() =
-        viewModelScope.async(Dispatchers.IO) {
-            onTunnelStop()
-            delay(Constants.TOGGLE_TUNNEL_DELAY)
-        }

    fun onTunnelStop() =
        viewModelScope.launch(Dispatchers.IO) {
-            Timber.d("Stopping active tunnel")
-            ServiceManager.stopVpnService(application.applicationContext)
+            Timber.i("Stopping active tunnel")
+            serviceManager.stopVpnService(application.applicationContext, isManualStop = true)
        }

    private fun validateConfigString(config: String) {
@@ -122,6 +110,7 @@ constructor(
            addTunnel(tunnelConfig)
            Result.Success(Unit)
        } catch (e: Exception) {
+            Timber.e(e)
            Result.Error(Event.Error.InvalidQrCode)
        }
    }
@@ -130,7 +119,7 @@ constructor(
        val bufferReader = stream.bufferedReader(charset = Charsets.UTF_8)
        val config = Config.parse(bufferReader)
        val tunnelName = getNameFromFileName(fileName)
-        addTunnel(TunnelConfig(name = tunnelName, wgQuick = config.toWgQuickString()))
+        addTunnel(TunnelConfig(name = tunnelName, wgQuick = config.toAwgQuickString()))
        withContext(Dispatchers.IO) { stream.close() }
    }

@@ -150,6 +139,7 @@ constructor(
                                is Result.Success -> return it
                            }
                        }
+
                    Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(uri)
                    else -> return Result.Error(Event.Error.InvalidFileExtension)
                }
@@ -158,6 +148,7 @@ constructor(
                return Result.Error(Event.Error.InvalidFileExtension)
            }
        } catch (e: Exception) {
+            Timber.e(e)
            return Result.Error(Event.Error.FileReadFailed)
        }
    }
@@ -173,7 +164,7 @@ constructor(
                    val name = getNameFromFileName(it.name)
                    val config = Config.parse(zip)
                    viewModelScope.launch(Dispatchers.IO) {
-                        addTunnel(TunnelConfig(name = name, wgQuick = config.toWgQuickString()))
+                        addTunnel(TunnelConfig(name = name, wgQuick = config.toAwgQuickString()))
                    }
                }
        }
@@ -190,22 +181,25 @@ constructor(
    }

    private suspend fun addTunnel(tunnelConfig: TunnelConfig) {
+        val firstTunnel = appDataRepository.tunnels.count() == 0
        saveTunnel(tunnelConfig)
-        WireGuardAutoTunnel.requestTileServiceStateUpdate()
+        if (firstTunnel) WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
    }

    fun pauseAutoTunneling() =
        viewModelScope.launch {
-            settingsRepository.save(uiState.value.settings.copy(isAutoTunnelPaused = true))
+            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = true))
+            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate(application)
        }

    fun resumeAutoTunneling() =
        viewModelScope.launch {
-            settingsRepository.save(uiState.value.settings.copy(isAutoTunnelPaused = false))
+            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = false))
+            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate(application)
        }

    private suspend fun saveTunnel(tunnelConfig: TunnelConfig) {
-        tunnelConfigRepository.save(tunnelConfig)
+        appDataRepository.tunnels.save(tunnelConfig)
    }

    private fun getFileNameByCursor(context: Context, uri: Uri): String? {
@@ -249,19 +243,23 @@ constructor(
        return try {
            fileName.substring(fileName.lastIndexOf('.'))
        } catch (e: Exception) {
+            Timber.e(e)
            ""
        }
    }

    private fun saveSettings(settings: Settings) =
-        viewModelScope.launch(Dispatchers.IO) { settingsRepository.save(settings) }
+        viewModelScope.launch(Dispatchers.IO) { appDataRepository.settings.save(settings) }

-    fun onDefaultTunnelChange(selectedTunnel: TunnelConfig?) =
-        viewModelScope.launch {
-            if (selectedTunnel != null) {
-                saveSettings(uiState.value.settings.copy(defaultTunnel = selectedTunnel.toString()))
-                    .join()
-                WireGuardAutoTunnel.requestTileServiceStateUpdate()
-            }
+
+    fun onCopyTunnel(tunnel: TunnelConfig?) = viewModelScope.launch {
+        tunnel?.let {
+            saveTunnel(
+                TunnelConfig(
+                    name = it.name.plus(NumberUtils.randomThree()),
+                    wgQuick = it.wgQuick,
+                ),
+            )
        }
+    }
 }
@@ -0,0 +1,287 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.options
+
+import androidx.compose.foundation.clickable
+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.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.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.outlined.Add
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+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.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavController
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
+import com.zaneschepke.wireguardautotunnel.ui.Screen
+import com.zaneschepke.wireguardautotunnel.ui.common.ClickableIconButton
+import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationToggle
+import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.Result
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun OptionsScreen(
+    optionsViewModel: OptionsViewModel = hiltViewModel(),
+    navController: NavController,
+    appViewModel: AppViewModel,
+    focusRequester: FocusRequester,
+    tunnelId: String
+) {
+    val scrollState = rememberScrollState()
+    val uiState by optionsViewModel.uiState.collectAsStateWithLifecycle()
+    val interactionSource = remember { MutableInteractionSource() }
+    val scope = rememberCoroutineScope()
+    val focusManager = LocalFocusManager.current
+    val screenPadding = 5.dp
+    val fillMaxWidth = .85f
+
+    var currentText by remember { mutableStateOf("") }
+
+    LaunchedEffect(Unit) {
+        optionsViewModel.init(tunnelId)
+        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+            delay(Constants.FOCUS_REQUEST_DELAY)
+            focusRequester.requestFocus()
+        }
+    }
+
+    fun saveTrustedSSID() {
+        if (currentText.isNotEmpty()) {
+            scope.launch {
+                optionsViewModel.onSaveRunSSID(currentText).let {
+                    when (it) {
+                        is Result.Success -> currentText = ""
+                        is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
+                    }
+                }
+            }
+        }
+    }
+
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Top,
+        modifier =
+        Modifier
+            .fillMaxSize()
+            .verticalScroll(scrollState)
+            .clickable(
+                indication = null,
+                interactionSource = interactionSource,
+            ) {
+                focusManager.clearFocus()
+            },
+    ) {
+        Surface(
+            tonalElevation = 2.dp,
+            shadowElevation = 2.dp,
+            shape = RoundedCornerShape(12.dp),
+            color = MaterialTheme.colorScheme.surface,
+            modifier =
+            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                Modifier
+                    .height(IntrinsicSize.Min)
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(top = 10.dp)
+            } else {
+                Modifier
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(top = 20.dp)
+            })
+                .padding(bottom = 10.dp),
+        ) {
+            Column(
+                horizontalAlignment = Alignment.Start,
+                verticalArrangement = Arrangement.Top,
+                modifier = Modifier.padding(15.dp),
+            ) {
+                SectionTitle(
+                    title = stringResource(id = R.string.general),
+                    padding = screenPadding,
+                )
+                ConfigurationToggle(
+                    stringResource(R.string.set_primary_tunnel),
+                    enabled = true,
+                    checked = uiState.isDefaultTunnel,
+                    modifier = Modifier
+                        .focusRequester(focusRequester),
+                    padding = screenPadding,
+                    onCheckChanged = { optionsViewModel.onTogglePrimaryTunnel() },
+                )
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(top = 5.dp),
+                    horizontalArrangement = Arrangement.Center,
+                ) {
+                    TextButton(
+                        onClick = {
+                            navController.navigate(
+                                "${Screen.Config.route}/${tunnelId}",
+                            )
+                        },
+                    ) {
+                        Text(stringResource(R.string.edit_tunnel))
+                    }
+                }
+            }
+        }
+        Surface(
+            tonalElevation = 2.dp,
+            shadowElevation = 2.dp,
+            shape = RoundedCornerShape(12.dp),
+            color = MaterialTheme.colorScheme.surface,
+            modifier =
+            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                Modifier
+                    .height(IntrinsicSize.Min)
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(top = 10.dp)
+            } else {
+                Modifier
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(top = 20.dp)
+            })
+                .padding(bottom = 10.dp),
+        ) {
+            Column(
+                horizontalAlignment = Alignment.Start,
+                verticalArrangement = Arrangement.Top,
+                modifier = Modifier.padding(15.dp),
+            ) {
+                SectionTitle(
+                    title = stringResource(id = R.string.auto_tunneling),
+                    padding = screenPadding,
+                )
+                ConfigurationToggle(
+                    stringResource(R.string.mobile_data_tunnel),
+                    enabled = true,
+                    checked = uiState.tunnel?.isMobileDataTunnel == true,
+                    padding = screenPadding,
+                    onCheckChanged = { optionsViewModel.onToggleIsMobileDataTunnel() },
+                )
+                Column {
+                    FlowRow(
+                        modifier = Modifier
+                            .padding(screenPadding)
+                            .fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(5.dp),
+                    ) {
+                        uiState.tunnel?.tunnelNetworks?.forEach { ssid ->
+                            ClickableIconButton(
+                                onClick = {
+                                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                                        focusRequester.requestFocus()
+                                        optionsViewModel.onDeleteRunSSID(ssid)
+                                    }
+                                },
+                                onIconClick = {
+                                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
+                                    optionsViewModel.onDeleteRunSSID(ssid)
+
+                                },
+                                text = ssid,
+                                icon = Icons.Filled.Close,
+                                enabled = true,
+                            )
+                        }
+                        if (uiState.tunnel == null || uiState.tunnel?.tunnelNetworks?.isEmpty() == true) {
+                            Text(
+                                stringResource(R.string.no_wifi_names_configured),
+                                fontStyle = FontStyle.Italic,
+                                color = Color.Gray,
+                            )
+                        }
+                    }
+                    OutlinedTextField(
+                        enabled = true,
+                        value = currentText,
+                        onValueChange = { currentText = it },
+                        label = { Text(stringResource(id = R.string.use_tunnel_on_wifi_name)) },
+                        modifier =
+                        Modifier
+                            .padding(
+                                start = screenPadding,
+                                top = 5.dp,
+                                bottom = 10.dp,
+                            ),
+                        maxLines = 1,
+                        keyboardOptions =
+                        KeyboardOptions(
+                            capitalization = KeyboardCapitalization.None,
+                            imeAction = ImeAction.Done,
+                        ),
+                        keyboardActions = KeyboardActions(onDone = { saveTrustedSSID() }),
+                        trailingIcon = {
+                            if (currentText != "") {
+                                IconButton(onClick = { saveTrustedSSID() }) {
+                                    Icon(
+                                        imageVector = Icons.Outlined.Add,
+                                        contentDescription =
+                                        if (currentText == "") {
+                                            stringResource(
+                                                id =
+                                                R.string
+                                                    .trusted_ssid_empty_description,
+                                            )
+                                        } else {
+                                            stringResource(
+                                                id =
+                                                R.string
+                                                    .trusted_ssid_value_description,
+                                            )
+                                        },
+                                        tint = MaterialTheme.colorScheme.primary,
+                                    )
+                                }
+                            }
+                        },
+                    )
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,9 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.options
+
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+
+data class OptionsUiState(
+    val id: String? = null,
+    val tunnel: TunnelConfig? = null,
+    val isDefaultTunnel: Boolean = false
+)
@@ -0,0 +1,101 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.options
+
+import androidx.compose.ui.util.fastFirstOrNull
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.util.Result
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+
+@HiltViewModel
+class OptionsViewModel @Inject
+constructor(
+    private val appDataRepository: AppDataRepository
+) : ViewModel() {
+
+    private val _optionState = MutableStateFlow(OptionsUiState())
+
+    val uiState = combine(
+        appDataRepository.tunnels.getTunnelConfigsFlow(),
+        _optionState,
+    ) { tunnels, optionState ->
+        if (optionState.id != null) {
+            val tunnelConfig = tunnels.fastFirstOrNull { it.id.toString() == optionState.id }
+            val isPrimaryTunnel = tunnelConfig?.isPrimaryTunnel == true
+            OptionsUiState(optionState.id, tunnelConfig, isPrimaryTunnel)
+        } else OptionsUiState()
+    }.stateIn(
+        viewModelScope,
+        SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
+        OptionsUiState(),
+    )
+
+    fun init(tunnelId: String) {
+        _optionState.value = _optionState.value.copy(
+            id = tunnelId,
+        )
+    }
+
+    fun onDeleteRunSSID(ssid: String) = viewModelScope.launch(Dispatchers.IO) {
+        uiState.value.tunnel?.let {
+            appDataRepository.tunnels.save(
+                tunnelConfig = it.copy(
+                    tunnelNetworks = (uiState.value.tunnel!!.tunnelNetworks - ssid).toMutableList(),
+                ),
+            )
+        }
+    }
+
+    private fun saveTunnel(tunnelConfig: TunnelConfig?) = viewModelScope.launch(Dispatchers.IO) {
+        tunnelConfig?.let {
+            appDataRepository.tunnels.save(it)
+        }
+    }
+
+    suspend fun onSaveRunSSID(ssid: String): Result<Unit> {
+        val trimmed = ssid.trim()
+        val tunnelsWithName = withContext(viewModelScope.coroutineContext) {
+            appDataRepository.tunnels.findByTunnelNetworksName(trimmed)
+        }
+        return if (uiState.value.tunnel?.tunnelNetworks?.contains(trimmed) != true &&
+            tunnelsWithName.isEmpty()) {
+            uiState.value.tunnel?.tunnelNetworks?.add(trimmed)
+            saveTunnel(uiState.value.tunnel)
+            Result.Success(Unit)
+        } else {
+            Result.Error(Event.Error.SsidConflict)
+        }
+    }
+
+    fun onToggleIsMobileDataTunnel() = viewModelScope.launch(Dispatchers.IO) {
+        uiState.value.tunnel?.let {
+            if (it.isMobileDataTunnel) {
+                appDataRepository.tunnels.updateMobileDataTunnel(null)
+            } else appDataRepository.tunnels.updateMobileDataTunnel(it)
+        }
+    }
+
+    fun onTogglePrimaryTunnel() = viewModelScope.launch(Dispatchers.IO) {
+        if (uiState.value.tunnel != null) {
+            appDataRepository.tunnels.updatePrimaryTunnel(
+                when (uiState.value.isDefaultTunnel) {
+                    true -> null
+                    false -> uiState.value.tunnel
+                },
+            )
+            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(WireGuardAutoTunnel.instance)
+        }
+    }
+}
@@ -0,0 +1,53 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.pinlock
+
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.navigation.NavController
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
+import com.zaneschepke.wireguardautotunnel.ui.Screen
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+import xyz.teamgravity.pin_lock_compose.PinLock
+
+@Composable
+fun PinLockScreen(navController: NavController, appViewModel: AppViewModel) {
+    val context = LocalContext.current
+    PinLock(
+        title = { pinExists ->
+            Text(
+                text = if (pinExists) stringResource(id = R.string.enter_pin) else stringResource(
+                    id = R.string.create_pin,
+                ),
+            )
+        },
+        color = MaterialTheme.colorScheme.surface,
+        onPinCorrect = {
+            // pin is correct, navigate or hide pin lock
+            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                navController.navigate(Screen.Main.route)
+            } else {
+                val isPopped = navController.popBackStack()
+                if (!isPopped) {
+                    navController.navigate(Screen.Main.route)
+                }
+            }
+
+        },
+        onPinIncorrect = {
+            // pin is incorrect, show error
+            appViewModel.showSnackbarMessage(
+                StringValue.StringResource(R.string.incorrect_pin).asString(context),
+            )
+        },
+        onPinCreated = {
+            // pin created for the first time, navigate or hide pin lock
+            appViewModel.showSnackbarMessage(
+                StringValue.StringResource(R.string.pin_created).asString(context),
+            )
+        },
+    )
+}
@@ -20,14 +20,13 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.IntrinsicSize
-import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
 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.width
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.KeyboardActions
@@ -55,7 +54,6 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
@@ -69,23 +67,27 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
-import com.wireguard.android.backend.Tunnel
-import com.wireguard.android.backend.WgQuickBackend
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
+import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.ClickableIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationToggle
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.AuthorizationPrompt
-import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
 import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
 import com.zaneschepke.wireguardautotunnel.util.Event
 import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.Result
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.AwgQuickBackend
+import org.amnezia.awg.backend.Tunnel
+import timber.log.Timber
+import xyz.teamgravity.pin_lock_compose.PinManager
 import java.io.File

@OptIn(
@@ -94,16 +96,17 @@ import java.io.File
 )
@Composable
 fun SettingsScreen(
-    padding: PaddingValues,
    viewModel: SettingsViewModel = hiltViewModel(),
-    showSnackbarMessage: (String) -> Unit,
-    focusRequester: FocusRequester
+    appViewModel: AppViewModel,
+    navController: NavController,
+    focusRequester: FocusRequester,
 ) {
    val scope = rememberCoroutineScope { Dispatchers.IO }
    val context = LocalContext.current
    val focusManager = LocalFocusManager.current
    val scrollState = rememberScrollState()
    val interactionSource = remember { MutableInteractionSource() }
+    val pinExists = remember { mutableStateOf(PinManager.pinExists()) }

    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

@@ -113,19 +116,12 @@ fun SettingsScreen(
    var showLocationServicesAlertDialog by remember { mutableStateOf(false) }
    var didExportFiles by remember { mutableStateOf(false) }
    var showAuthPrompt by remember { mutableStateOf(false) }
-    val focusRequester2 = remember { FocusRequester() }

    val screenPadding = 5.dp
    val fillMaxWidth = .85f

-    if (uiState.loading) {
-        LoadingScreen()
-        return
-    }
-
    val startForResult =
-        rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) {
-            result: ActivityResult ->
+        rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
            if (result.resultCode == Activity.RESULT_OK) {
                result.data
                // Handle the Intent
@@ -141,9 +137,10 @@ fun SettingsScreen(
            }
            FileUtils.saveFilesToZip(context, files)
            didExportFiles = true
-            showSnackbarMessage(Event.Message.ConfigsExported.message)
+            appViewModel.showSnackbarMessage(Event.Message.ConfigsExported.message)
        } catch (e: Exception) {
-            showSnackbarMessage(Event.Error.Exception(e).message)
+            Timber.e(e)
+            appViewModel.showSnackbarMessage(Event.Error.Exception(e).message)
        }
    }

@@ -163,7 +160,9 @@ fun SettingsScreen(

    fun handleAutoTunnelToggle() {
        if (uiState.isBatteryOptimizeDisableShown || isBatteryOptimizationsDisabled()) {
-            viewModel.toggleAutoTunnel()
+            if (appViewModel.isRequiredPermissionGranted()) {
+                viewModel.onToggleAutoTunnel()
+            }
        } else {
            requestBatteryOptimizationsDisabled()
        }
@@ -174,7 +173,7 @@ fun SettingsScreen(
            viewModel.onSaveTrustedSSID(currentText).let {
                when (it) {
                    is Result.Success -> currentText = ""
-                    is Result.Error -> showSnackbarMessage(it.error.message)
+                    is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
                }
            }
        }
@@ -201,7 +200,7 @@ fun SettingsScreen(
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        if (
            WireGuardAutoTunnel.isRunningOnAndroidTv() &&
-                Build.VERSION.SDK_INT == Build.VERSION_CODES.Q
+            Build.VERSION.SDK_INT == Build.VERSION_CODES.Q
        ) {
            checkFineLocationGranted()
        } else {
@@ -248,12 +247,16 @@ fun SettingsScreen(
        Column(
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Top,
-            modifier = Modifier.fillMaxSize().verticalScroll(scrollState).padding(padding),
+            modifier = Modifier
+                .fillMaxSize()
+                .verticalScroll(scrollState),
        ) {
            Icon(
                Icons.Rounded.LocationOff,
                contentDescription = stringResource(id = R.string.map),
-                modifier = Modifier.padding(30.dp).size(128.dp),
+                modifier = Modifier
+                    .padding(30.dp)
+                    .size(128.dp),
            )
            Text(
                stringResource(R.string.prominent_background_location_title),
@@ -269,11 +272,15 @@ fun SettingsScreen(
            )
            Row(
                modifier =
-                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                        Modifier.fillMaxWidth().padding(10.dp)
-                    } else {
-                        Modifier.fillMaxWidth().padding(30.dp)
-                    },
+                if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                    Modifier
+                        .fillMaxWidth()
+                        .padding(10.dp)
+                } else {
+                    Modifier
+                        .fillMaxWidth()
+                        .padding(30.dp)
+                },
                verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.SpaceEvenly,
            ) {
@@ -301,11 +308,11 @@ fun SettingsScreen(
            },
            onError = { _ ->
                showAuthPrompt = false
-                showSnackbarMessage(Event.Error.AuthenticationFailed.message)
+                appViewModel.showSnackbarMessage(Event.Error.AuthenticationFailed.message)
            },
            onFailure = {
                showAuthPrompt = false
-                showSnackbarMessage(Event.Error.AuthorizationFailed.message)
+                appViewModel.showSnackbarMessage(Event.Error.AuthorizationFailed.message)
            },
        )
    }
@@ -314,7 +321,7 @@ fun SettingsScreen(
        Column(
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center,
-            modifier = Modifier.fillMaxSize().padding(padding),
+            modifier = Modifier.fillMaxSize(),
        ) {
            Text(
                stringResource(R.string.one_tunnel_required),
@@ -329,7 +336,10 @@ fun SettingsScreen(
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Top,
            modifier =
-                Modifier.fillMaxSize().padding(padding).verticalScroll(scrollState).clickable(
+            Modifier
+                .fillMaxSize()
+                .verticalScroll(scrollState)
+                .clickable(
                    indication = null,
                    interactionSource = interactionSource,
                ) {
@@ -342,14 +352,17 @@ fun SettingsScreen(
                shape = RoundedCornerShape(12.dp),
                color = MaterialTheme.colorScheme.surface,
                modifier =
-                    (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                            Modifier.height(IntrinsicSize.Min)
-                                .fillMaxWidth(fillMaxWidth)
-                                .padding(top = 10.dp)
-                        } else {
-                            Modifier.fillMaxWidth(fillMaxWidth).padding(top = 20.dp)
-                        })
-                        .padding(bottom = 10.dp),
+                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                    Modifier
+                        .height(IntrinsicSize.Min)
+                        .fillMaxWidth(fillMaxWidth)
+                        .padding(top = 10.dp)
+                } else {
+                    Modifier
+                        .fillMaxWidth(fillMaxWidth)
+                        .padding(top = 20.dp)
+                })
+                    .padding(bottom = 10.dp),
            ) {
                Column(
                    horizontalAlignment = Alignment.Start,
@@ -363,38 +376,43 @@ fun SettingsScreen(
                    ConfigurationToggle(
                        stringResource(id = R.string.tunnel_on_wifi),
                        enabled =
-                            !(uiState.settings.isAutoTunnelEnabled ||
-                                uiState.settings.isAlwaysOnVpnEnabled),
+                        !(uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
                        checked = uiState.settings.isTunnelOnWifiEnabled,
                        padding = screenPadding,
                        onCheckChanged = { viewModel.onToggleTunnelOnWifi() },
                        modifier =
-                            if (uiState.settings.isAutoTunnelEnabled) Modifier
-                            else
-                                Modifier.focusRequester(focusRequester).focusProperties {
-                                    down = focusRequester2
-                                },
+                        if (uiState.settings.isAutoTunnelEnabled) Modifier
+                        else
+                            Modifier
+                                .focusRequester(focusRequester),
                    )
                    AnimatedVisibility(visible = uiState.settings.isTunnelOnWifiEnabled) {
                        Column {
                            FlowRow(
-                                modifier = Modifier.padding(screenPadding).fillMaxWidth(),
+                                modifier = Modifier
+                                    .padding(screenPadding)
+                                    .fillMaxWidth(),
                                horizontalArrangement = Arrangement.spacedBy(5.dp),
                            ) {
                                uiState.settings.trustedNetworkSSIDs.forEach { ssid ->
                                    ClickableIconButton(
                                        onClick = {
                                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                                                focusRequester.requestFocus()
                                                viewModel.onDeleteTrustedSSID(ssid)
-                                                focusRequester2.requestFocus()
                                            }
                                        },
-                                        onIconClick = { viewModel.onDeleteTrustedSSID(ssid) },
+                                        onIconClick = {
+                                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
+                                            viewModel.onDeleteTrustedSSID(ssid)
+
+                                        },
                                        text = ssid,
                                        icon = Icons.Filled.Close,
                                        enabled =
-                                            !(uiState.settings.isAutoTunnelEnabled ||
-                                                uiState.settings.isAlwaysOnVpnEnabled),
+                                        !(uiState.settings.isAutoTunnelEnabled ||
+                                            uiState.settings.isAlwaysOnVpnEnabled),
                                    )
                                }
                                if (uiState.settings.trustedNetworkSSIDs.isEmpty()) {
@@ -407,24 +425,24 @@ fun SettingsScreen(
                            }
                            OutlinedTextField(
                                enabled =
-                                    !(uiState.settings.isAutoTunnelEnabled ||
-                                        uiState.settings.isAlwaysOnVpnEnabled),
+                                !(uiState.settings.isAutoTunnelEnabled ||
+                                    uiState.settings.isAlwaysOnVpnEnabled),
                                value = currentText,
                                onValueChange = { currentText = it },
                                label = { Text(stringResource(R.string.add_trusted_ssid)) },
                                modifier =
-                                    Modifier.padding(
-                                            start = screenPadding,
-                                            top = 5.dp,
-                                            bottom = 10.dp,
-                                        )
-                                        .focusRequester(focusRequester2),
+                                Modifier
+                                    .padding(
+                                        start = screenPadding,
+                                        top = 5.dp,
+                                        bottom = 10.dp,
+                                    ),
                                maxLines = 1,
                                keyboardOptions =
-                                    KeyboardOptions(
-                                        capitalization = KeyboardCapitalization.None,
-                                        imeAction = ImeAction.Done,
-                                    ),
+                                KeyboardOptions(
+                                    capitalization = KeyboardCapitalization.None,
+                                    imeAction = ImeAction.Done,
+                                ),
                                keyboardActions = KeyboardActions(onDone = { saveTrustedSSID() }),
                                trailingIcon = {
                                    if (currentText != "") {
@@ -432,19 +450,19 @@ fun SettingsScreen(
                                            Icon(
                                                imageVector = Icons.Outlined.Add,
                                                contentDescription =
-                                                    if (currentText == "") {
-                                                        stringResource(
-                                                            id =
-                                                                R.string
-                                                                    .trusted_ssid_empty_description,
-                                                        )
-                                                    } else {
-                                                        stringResource(
-                                                            id =
-                                                                R.string
-                                                                    .trusted_ssid_value_description,
-                                                        )
-                                                    },
+                                                if (currentText == "") {
+                                                    stringResource(
+                                                        id =
+                                                        R.string
+                                                            .trusted_ssid_empty_description,
+                                                    )
+                                                } else {
+                                                    stringResource(
+                                                        id =
+                                                        R.string
+                                                            .trusted_ssid_value_description,
+                                                    )
+                                                },
                                                tint = MaterialTheme.colorScheme.primary,
                                            )
                                        }
@@ -456,8 +474,8 @@ fun SettingsScreen(
                    ConfigurationToggle(
                        stringResource(R.string.tunnel_mobile_data),
                        enabled =
-                            !(uiState.settings.isAutoTunnelEnabled ||
-                                uiState.settings.isAlwaysOnVpnEnabled),
+                        !(uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
                        checked = uiState.settings.isTunnelOnMobileDataEnabled,
                        padding = screenPadding,
                        onCheckChanged = { viewModel.onToggleTunnelOnMobileData() },
@@ -465,31 +483,31 @@ fun SettingsScreen(
                    ConfigurationToggle(
                        stringResource(id = R.string.tunnel_on_ethernet),
                        enabled =
-                            !(uiState.settings.isAutoTunnelEnabled ||
-                                uiState.settings.isAlwaysOnVpnEnabled),
+                        !(uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
                        checked = uiState.settings.isTunnelOnEthernetEnabled,
                        padding = screenPadding,
                        onCheckChanged = { viewModel.onToggleTunnelOnEthernet() },
                    )
                    ConfigurationToggle(
-                        stringResource(R.string.battery_saver),
+                        stringResource(R.string.restart_on_ping),
                        enabled =
-                            !(uiState.settings.isAutoTunnelEnabled ||
-                                uiState.settings.isAlwaysOnVpnEnabled),
-                        checked = uiState.settings.isBatterySaverEnabled,
+                        !(uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
+                        checked = uiState.settings.isPingEnabled,
                        padding = screenPadding,
-                        onCheckChanged = { viewModel.onToggleBatterySaver() },
+                        onCheckChanged = { viewModel.onToggleRestartOnPing() },
                    )
                    Row(
                        verticalAlignment = Alignment.CenterVertically,
                        modifier =
-                            (if (!uiState.settings.isAutoTunnelEnabled) Modifier
-                                else
-                                    Modifier.focusRequester(
-                                        focusRequester,
-                                    ))
-                                .fillMaxSize()
-                                .padding(top = 5.dp),
+                        (if (!uiState.settings.isAutoTunnelEnabled) Modifier
+                        else
+                            Modifier.focusRequester(
+                                focusRequester,
+                            ))
+                            .fillMaxSize()
+                            .padding(top = 5.dp),
                        horizontalArrangement = Arrangement.Center,
                    ) {
                        TextButton(
@@ -497,19 +515,22 @@ fun SettingsScreen(
                            onClick = {
                                if (
                                    uiState.settings.isTunnelOnWifiEnabled &&
-                                        !uiState.settings.isAutoTunnelEnabled
+                                    !uiState.settings.isAutoTunnelEnabled
                                ) {
                                    when (false) {
                                        isBackgroundLocationGranted ->
-                                            showSnackbarMessage(
-                                                Event.Error.BackgroundLocationRequired.message
+                                            appViewModel.showSnackbarMessage(
+                                                Event.Error.BackgroundLocationRequired.message,
                                            )
+
                                        fineLocationState.status.isGranted ->
-                                            showSnackbarMessage(
-                                                Event.Error.PreciseLocationRequired.message
+                                            appViewModel.showSnackbarMessage(
+                                                Event.Error.PreciseLocationRequired.message,
                                            )
+
                                        viewModel.isLocationEnabled(context) ->
                                            showLocationServicesAlertDialog = true
+
                                        else -> {
                                            handleAutoTunnelToggle()
                                        }
@@ -530,13 +551,15 @@ fun SettingsScreen(
                    }
                }
            }
-            if (WgQuickBackend.hasKernelSupport()) {
+            if (AwgQuickBackend.hasKernelSupport()) {
                Surface(
                    tonalElevation = 2.dp,
                    shadowElevation = 2.dp,
                    shape = RoundedCornerShape(12.dp),
                    color = MaterialTheme.colorScheme.surface,
-                    modifier = Modifier.fillMaxWidth(fillMaxWidth).padding(vertical = 10.dp),
+                    modifier = Modifier
+                        .fillMaxWidth(fillMaxWidth)
+                        .padding(vertical = 10.dp),
                ) {
                    Column(
                        horizontalAlignment = Alignment.Start,
@@ -550,15 +573,15 @@ fun SettingsScreen(
                        ConfigurationToggle(
                            stringResource(R.string.use_kernel),
                            enabled =
-                                !(uiState.settings.isAutoTunnelEnabled ||
-                                    uiState.settings.isAlwaysOnVpnEnabled ||
-                                    (uiState.vpnState.status == Tunnel.State.UP)),
+                            !(uiState.settings.isAutoTunnelEnabled ||
+                                uiState.settings.isAlwaysOnVpnEnabled ||
+                                (uiState.vpnState.status == Tunnel.State.UP)),
                            checked = uiState.settings.isKernelEnabled,
                            padding = screenPadding,
                            onCheckChanged = {
                                viewModel.onToggleKernelMode().let {
                                    when (it) {
-                                        is Result.Error -> showSnackbarMessage(it.error.message)
+                                        is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
                                        is Result.Success -> {}
                                    }
                                }
@@ -567,26 +590,27 @@ fun SettingsScreen(
                    }
                }
            }
-            if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                Surface(
-                    tonalElevation = 2.dp,
-                    shadowElevation = 2.dp,
-                    shape = RoundedCornerShape(12.dp),
-                    color = MaterialTheme.colorScheme.surface,
-                    modifier =
-                        Modifier.fillMaxWidth(fillMaxWidth)
-                            .padding(vertical = 10.dp)
-                            .padding(bottom = 140.dp),
+            Surface(
+                tonalElevation = 2.dp,
+                shadowElevation = 2.dp,
+                shape = RoundedCornerShape(12.dp),
+                color = MaterialTheme.colorScheme.surface,
+                modifier =
+                Modifier
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(vertical = 10.dp)
+                    .padding(bottom = 140.dp),
+            ) {
+                Column(
+                    horizontalAlignment = Alignment.Start,
+                    verticalArrangement = Arrangement.Top,
+                    modifier = Modifier.padding(15.dp),
                ) {
-                    Column(
-                        horizontalAlignment = Alignment.Start,
-                        verticalArrangement = Arrangement.Top,
-                        modifier = Modifier.padding(15.dp),
-                    ) {
-                        SectionTitle(
-                            title = stringResource(id = R.string.other),
-                            padding = screenPadding,
-                        )
+                    SectionTitle(
+                        title = stringResource(id = R.string.other),
+                        padding = screenPadding,
+                    )
+                    if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                        ConfigurationToggle(
                            stringResource(R.string.always_on_vpn_support),
                            enabled = !uiState.settings.isAutoTunnelEnabled,
@@ -601,9 +625,27 @@ fun SettingsScreen(
                            padding = screenPadding,
                            onCheckChanged = { viewModel.onToggleShortcutsEnabled() },
                        )
+                    }
+                    ConfigurationToggle(
+                        stringResource(R.string.enable_app_lock),
+                        enabled = true,
+                        checked = pinExists.value,
+                        padding = screenPadding,
+                        onCheckChanged = {
+                            if (pinExists.value) {
+                                PinManager.clearPin()
+                                pinExists.value = PinManager.pinExists()
+                            } else {
+                                navController.navigate(Screen.Lock.route)
+                            }
+                        },
+                    )
+                    if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                        Row(
                            verticalAlignment = Alignment.CenterVertically,
-                            modifier = Modifier.fillMaxSize().padding(top = 5.dp),
+                            modifier = Modifier
+                                .fillMaxSize()
+                                .padding(top = 5.dp),
                            horizontalArrangement = Arrangement.Center,
                        ) {
                            TextButton(
@@ -616,9 +658,6 @@ fun SettingsScreen(
                    }
                }
            }
-            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                Spacer(modifier = Modifier.weight(.17f))
-            }
        }
    }
 }
@@ -9,6 +9,5 @@ data class SettingsUiState(
    val tunnels: List<TunnelConfig> = emptyList(),
    val vpnState: VpnState = VpnState(),
    val isLocationDisclosureShown: Boolean = true,
-    val isBatteryOptimizeDisableShown: Boolean = false,
-    val loading: Boolean = true
+    val isBatteryOptimizeDisableShown: Boolean = false
 )
@@ -6,11 +6,9 @@ import android.location.LocationManager
 import androidx.core.location.LocationManagerCompat
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.wireguard.android.util.RootShell
-import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
@@ -21,6 +19,7 @@ import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
+import org.amnezia.awg.util.RootShell
 import timber.log.Timber
 import javax.inject.Inject

@@ -29,29 +28,27 @@ class SettingsViewModel
@Inject
 constructor(
    private val application: Application,
-    private val tunnelConfigRepository: TunnelConfigRepository,
-    private val settingsRepository: SettingsRepository,
-    private val dataStoreManager: DataStoreManager,
+    private val appDataRepository: AppDataRepository,
+    private val serviceManager: ServiceManager,
    private val rootShell: RootShell,
-    private val vpnService: VpnService
+    vpnService: VpnService
 ) : ViewModel() {

    val uiState =
        combine(
-                settingsRepository.getSettingsFlow(),
-                tunnelConfigRepository.getTunnelConfigsFlow(),
-                vpnService.vpnState,
-                dataStoreManager.preferencesFlow,
-            ) { settings, tunnels, tunnelState, preferences ->
-                SettingsUiState(
-                    settings,
-                    tunnels,
-                    tunnelState,
-                    preferences?.get(DataStoreManager.LOCATION_DISCLOSURE_SHOWN) ?: false,
-                    preferences?.get(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN) ?: false,
-                    false
-                )
-            }
+            appDataRepository.settings.getSettingsFlow(),
+            appDataRepository.tunnels.getTunnelConfigsFlow(),
+            vpnService.vpnState,
+            appDataRepository.appState.generalStateFlow,
+        ) { settings, tunnels, tunnelState, generalState ->
+            SettingsUiState(
+                settings,
+                tunnels,
+                tunnelState,
+                generalState.locationDisclosureShown,
+                generalState.batteryOptimizationDisableShown,
+            )
+        }
            .stateIn(
                viewModelScope,
                SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
@@ -71,12 +68,12 @@ constructor(

    fun setLocationDisclosureShown() =
        viewModelScope.launch {
-            dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, true)
+            appDataRepository.appState.setLocationDisclosureShown(true)
        }

    fun setBatteryOptimizeDisableShown() =
        viewModelScope.launch {
-            dataStoreManager.saveToDataStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN, true)
+            appDataRepository.appState.setBatteryOptimizationDisableShown(true)
        }

    fun onToggleTunnelOnMobileData() {
@@ -91,48 +88,42 @@ constructor(
        saveSettings(
            uiState.value.settings.copy(
                trustedNetworkSSIDs =
-                    (uiState.value.settings.trustedNetworkSSIDs - ssid).toMutableList(),
+                (uiState.value.settings.trustedNetworkSSIDs - ssid).toMutableList(),
            ),
        )
    }

-    private suspend fun getDefaultTunnelOrFirst(): String {
-        return uiState.value.settings.defaultTunnel
-            ?: tunnelConfigRepository.getAll().first().toString()
-    }
-
-    fun toggleAutoTunnel() =
+    fun onToggleAutoTunnel() =
        viewModelScope.launch {
            val isAutoTunnelEnabled = uiState.value.settings.isAutoTunnelEnabled
            var isAutoTunnelPaused = uiState.value.settings.isAutoTunnelPaused

            if (isAutoTunnelEnabled) {
-                ServiceManager.stopWatcherService(application)
+                serviceManager.stopWatcherService(application)
            } else {
-                ServiceManager.startWatcherService(application)
+                serviceManager.startWatcherService(application)
                isAutoTunnelPaused = false
            }
            saveSettings(
                uiState.value.settings.copy(
                    isAutoTunnelEnabled = !isAutoTunnelEnabled,
                    isAutoTunnelPaused = isAutoTunnelPaused,
-                    defaultTunnel = getDefaultTunnelOrFirst(),
                ),
            )
+            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate(application)
        }

    fun onToggleAlwaysOnVPN() =
        viewModelScope.launch {
-            val updatedSettings =
+            saveSettings(
                uiState.value.settings.copy(
                    isAlwaysOnVpnEnabled = !uiState.value.settings.isAlwaysOnVpnEnabled,
-                    defaultTunnel = getDefaultTunnelOrFirst(),
-                )
-            saveSettings(updatedSettings)
+                ),
+            )
        }

    private fun saveSettings(settings: Settings) =
-        viewModelScope.launch { settingsRepository.save(settings) }
+        viewModelScope.launch { appDataRepository.settings.save(settings) }

    fun onToggleTunnelOnEthernet() {
        saveSettings(
@@ -155,14 +146,6 @@ constructor(
        )
    }

-    fun onToggleBatterySaver() {
-        saveSettings(
-            uiState.value.settings.copy(
-                isBatterySaverEnabled = !uiState.value.settings.isBatterySaverEnabled,
-            ),
-        )
-    }
-
    private fun saveKernelMode(on: Boolean) {
        saveSettings(
            uiState.value.settings.copy(
@@ -183,9 +166,10 @@ constructor(
        if (!uiState.value.settings.isKernelEnabled) {
            try {
                rootShell.start()
-                Timber.d("Root shell accepted!")
+                Timber.i("Root shell accepted!")
                saveKernelMode(on = true)
            } catch (e: RootShell.RootShellException) {
+                Timber.e(e)
                saveKernelMode(on = false)
                return Result.Error(Event.Error.RootDenied)
            }
@@ -194,4 +178,12 @@ constructor(
        }
        return Result.Success(Unit)
    }
+
+    fun onToggleRestartOnPing() = viewModelScope.launch {
+        saveSettings(
+            uiState.value.settings.copy(
+                isPingEnabled = !uiState.value.settings.isPingEnabled,
+            ),
+        )
+    }
 }
@@ -1,14 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.support

-import android.content.Intent
-import android.content.Intent.createChooser
-import android.net.Uri
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.IntrinsicSize
-import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
@@ -22,6 +18,7 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.rounded.ArrowForward
 import androidx.compose.material.icons.rounded.Book
+import androidx.compose.material.icons.rounded.FormatListNumbered
 import androidx.compose.material.icons.rounded.Mail
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
@@ -40,26 +37,26 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import androidx.core.content.ContextCompat.startActivity
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.BuildConfig
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
+import com.zaneschepke.wireguardautotunnel.ui.Screen

@Composable
 fun SupportScreen(
-    padding: PaddingValues,
    viewModel: SupportViewModel = hiltViewModel(),
-    showSnackbarMessage: (String) -> Unit,
+    appViewModel: AppViewModel,
+    navController: NavController,
    focusRequester: FocusRequester
 ) {
    val context = LocalContext.current
@@ -67,46 +64,14 @@ fun SupportScreen(

    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

-    fun openWebPage(url: String) {
-        try {
-            val webpage: Uri = Uri.parse(url)
-            val intent = Intent(Intent.ACTION_VIEW, webpage)
-            context.startActivity(intent)
-        } catch (e: Exception) {
-            showSnackbarMessage(Event.Error.Exception(e).message)
-        }
-    }
-
-    fun launchEmail() {
-        try {
-            val intent =
-                Intent(Intent.ACTION_SENDTO).apply {
-                    type = Constants.EMAIL_MIME_TYPE
-                    putExtra(Intent.EXTRA_EMAIL, arrayOf(context.getString(R.string.my_email)))
-                    putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.email_subject))
-                }
-            startActivity(
-                context,
-                createChooser(intent, context.getString(R.string.email_chooser)),
-                null,
-            )
-        } catch (e: Exception) {
-            showSnackbarMessage(Event.Error.Exception(e).message)
-        }
-    }
-
-    if (uiState.loading) {
-        LoadingScreen()
-        return
-    }
-
    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Top,
        modifier =
-            Modifier.fillMaxSize().padding(padding)
-                .verticalScroll(rememberScrollState())
-                .focusable()
+        Modifier
+            .fillMaxSize()
+            .verticalScroll(rememberScrollState())
+            .focusable(),
    ) {
        Surface(
            tonalElevation = 2.dp,
@@ -114,16 +79,20 @@ fun SupportScreen(
            shape = RoundedCornerShape(12.dp),
            color = MaterialTheme.colorScheme.surface,
            modifier =
-                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                        Modifier.height(IntrinsicSize.Min)
-                            .fillMaxWidth(fillMaxWidth)
-                            .padding(top = 10.dp)
-                    } else {
-                        Modifier.fillMaxWidth(fillMaxWidth).padding(top = 20.dp)
-                    })
-                    .padding(bottom = 25.dp),
+            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                Modifier
+                    .height(IntrinsicSize.Min)
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(top = 10.dp)
+            } else {
+                Modifier
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(top = 20.dp)
+            })
+                .padding(bottom = 25.dp),
        ) {
            Column(modifier = Modifier.padding(20.dp)) {
+                val forwardIcon = Icons.AutoMirrored.Rounded.ArrowForward
                Text(
                    stringResource(R.string.thank_you),
                    textAlign = TextAlign.Start,
@@ -138,8 +107,10 @@ fun SupportScreen(
                    modifier = Modifier.padding(bottom = 20.dp),
                )
                TextButton(
-                    onClick = { openWebPage(context.resources.getString(R.string.docs_url)) },
-                    modifier = Modifier.padding(vertical = 5.dp).focusRequester(focusRequester),
+                    onClick = { appViewModel.openWebPage(context.resources.getString(R.string.docs_url)) },
+                    modifier = Modifier
+                        .padding(vertical = 5.dp)
+                        .focusRequester(focusRequester),
                ) {
                    Row(
                        horizontalArrangement = Arrangement.SpaceBetween,
@@ -147,25 +118,32 @@ fun SupportScreen(
                        modifier = Modifier.fillMaxWidth(),
                    ) {
                        Row {
-                            Icon(Icons.Rounded.Book, stringResource(id = R.string.docs))
+                            val icon = Icons.Rounded.Book
+                            Icon(icon, icon.name)
                            Text(
                                stringResource(id = R.string.docs_description),
                                textAlign = TextAlign.Justify,
-                                modifier = Modifier.padding(start = 10.dp),
+                                modifier = Modifier
+                                    .padding(start = 10.dp)
+                                    .weight(
+                                        weight = 1.0f,
+                                        fill = false,
+                                    ),
+                                softWrap = true
                            )
                        }
                        Icon(
-                            Icons.AutoMirrored.Rounded.ArrowForward,
-                            stringResource(id = R.string.go)
+                            forwardIcon,
+                            forwardIcon.name,
                        )
                    }
                }
                HorizontalDivider(
                    thickness = 0.5.dp,
-                    color = MaterialTheme.colorScheme.onBackground
+                    color = MaterialTheme.colorScheme.onBackground,
                )
                TextButton(
-                    onClick = { openWebPage(context.resources.getString(R.string.discord_url)) },
+                    onClick = { appViewModel.openWebPage(context.resources.getString(R.string.discord_url)) },
                    modifier = Modifier.padding(vertical = 5.dp),
                ) {
                    Row(
@@ -174,9 +152,10 @@ fun SupportScreen(
                        modifier = Modifier.fillMaxWidth(),
                    ) {
                        Row {
+                            val icon = ImageVector.vectorResource(R.drawable.discord)
                            Icon(
-                                imageVector = ImageVector.vectorResource(R.drawable.discord),
-                                stringResource(id = R.string.discord),
+                                icon,
+                                icon.name,
                                Modifier.size(25.dp),
                            )
                            Text(
@@ -186,17 +165,17 @@ fun SupportScreen(
                            )
                        }
                        Icon(
-                            Icons.AutoMirrored.Rounded.ArrowForward,
-                            stringResource(id = R.string.go)
+                            forwardIcon,
+                            forwardIcon.name,
                        )
                    }
                }
                HorizontalDivider(
                    thickness = 0.5.dp,
-                    color = MaterialTheme.colorScheme.onBackground
+                    color = MaterialTheme.colorScheme.onBackground,
                )
                TextButton(
-                    onClick = { openWebPage(context.resources.getString(R.string.github_url)) },
+                    onClick = { appViewModel.openWebPage(context.resources.getString(R.string.github_url)) },
                    modifier = Modifier.padding(vertical = 5.dp),
                ) {
                    Row(
@@ -205,29 +184,30 @@ fun SupportScreen(
                        modifier = Modifier.fillMaxWidth(),
                    ) {
                        Row {
+                            val icon = ImageVector.vectorResource(R.drawable.github)
                            Icon(
-                                imageVector = ImageVector.vectorResource(R.drawable.github),
-                                stringResource(id = R.string.github),
+                                imageVector = icon,
+                                icon.name,
                                Modifier.size(25.dp),
                            )
                            Text(
-                                "Open an issue",
+                                stringResource(id = R.string.open_issue),
                                textAlign = TextAlign.Justify,
                                modifier = Modifier.padding(start = 10.dp),
                            )
                        }
                        Icon(
-                            Icons.AutoMirrored.Rounded.ArrowForward,
-                            stringResource(id = R.string.go)
+                            forwardIcon,
+                            forwardIcon.name,
                        )
                    }
                }
                HorizontalDivider(
                    thickness = 0.5.dp,
-                    color = MaterialTheme.colorScheme.onBackground
+                    color = MaterialTheme.colorScheme.onBackground,
                )
                TextButton(
-                    onClick = { launchEmail() },
+                    onClick = { appViewModel.launchEmail() },
                    modifier = Modifier.padding(vertical = 5.dp),
                ) {
                    Row(
@@ -236,7 +216,8 @@ fun SupportScreen(
                        modifier = Modifier.fillMaxWidth(),
                    ) {
                        Row {
-                            Icon(Icons.Rounded.Mail, stringResource(id = R.string.email))
+                            val icon = Icons.Rounded.Mail
+                            Icon(icon, icon.name)
                            Text(
                                stringResource(id = R.string.email_description),
                                textAlign = TextAlign.Justify,
@@ -244,11 +225,41 @@ fun SupportScreen(
                            )
                        }
                        Icon(
-                            Icons.AutoMirrored.Rounded.ArrowForward,
-                            stringResource(id = R.string.go)
+                            forwardIcon,
+                            forwardIcon.name,
                        )
                    }
                }
+                if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                    HorizontalDivider(
+                        thickness = 0.5.dp,
+                        color = MaterialTheme.colorScheme.onBackground,
+                    )
+                    TextButton(
+                        onClick = { navController.navigate(Screen.Support.Logs.route) },
+                        modifier = Modifier.padding(vertical = 5.dp),
+                    ) {
+                        Row(
+                            horizontalArrangement = Arrangement.SpaceBetween,
+                            verticalAlignment = Alignment.CenterVertically,
+                            modifier = Modifier.fillMaxWidth(),
+                        ) {
+                            Row {
+                                val icon = Icons.Rounded.FormatListNumbered
+                                Icon(icon, icon.name)
+                                Text(
+                                    stringResource(id = R.string.read_logs),
+                                    textAlign = TextAlign.Justify,
+                                    modifier = Modifier.padding(start = 10.dp),
+                                )
+                            }
+                            Icon(
+                                Icons.AutoMirrored.Rounded.ArrowForward,
+                                stringResource(id = R.string.go),
+                            )
+                        }
+                    }
+                }
            }
        }
        Spacer(modifier = Modifier.weight(1f))
@@ -257,17 +268,30 @@ fun SupportScreen(
            style = TextStyle(textDecoration = TextDecoration.Underline),
            fontSize = 16.sp,
            modifier =
-                Modifier.clickable {
-                    openWebPage(context.resources.getString(R.string.privacy_policy_url))
-                },
+            Modifier.clickable {
+                appViewModel.openWebPage(context.resources.getString(R.string.privacy_policy_url))
+            },
        )
        Row(
            horizontalArrangement = Arrangement.spacedBy(25.dp),
            verticalAlignment = Alignment.CenterVertically,
            modifier = Modifier.padding(25.dp),
        ) {
-            Text("Version: ${BuildConfig.VERSION_NAME}", modifier = Modifier.focusable())
-            Text("Mode: ${if (uiState.settings.isKernelEnabled) "Kernel" else "Userspace"}")
+            val version = buildAnnotatedString {
+                append(stringResource(id = R.string.version))
+                append(": ")
+                append(BuildConfig.VERSION_NAME)
+            }
+            val mode = buildAnnotatedString {
+                append(stringResource(R.string.mode))
+                append(": ")
+                when(uiState.settings.isKernelEnabled){
+                    true -> append(stringResource(id = R.string.kernel))
+                    false -> append(stringResource(id = R.string.userspace))
+                }
+            }
+            Text(version.text, modifier = Modifier.focusable())
+            Text(mode.text)
        }
    }
 }
@@ -2,4 +2,4 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.support

 import com.zaneschepke.wireguardautotunnel.data.model.Settings

-data class SupportUiState(val settings: Settings = Settings(), val loading: Boolean = true)
+data class SupportUiState(val settings: Settings = Settings())
@@ -11,13 +11,13 @@ import kotlinx.coroutines.flow.stateIn
 import javax.inject.Inject

@HiltViewModel
-class SupportViewModel @Inject constructor(private val settingsRepository: SettingsRepository) :
+class SupportViewModel @Inject constructor(settingsRepository: SettingsRepository) :
    ViewModel() {

    val uiState =
        settingsRepository
            .getSettingsFlow()
-            .map { SupportUiState(it, false) }
+            .map { SupportUiState(it) }
            .stateIn(
                viewModelScope,
                SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
@@ -0,0 +1,110 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.logs
+
+import android.annotation.SuppressLint
+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.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Save
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.ClipboardManager
+import androidx.compose.ui.platform.LocalClipboardManager
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
+import com.zaneschepke.wireguardautotunnel.ui.common.text.LogTypeLabel
+import kotlinx.coroutines.launch
+
+@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
+@Composable
+fun LogsScreen(appViewModel: AppViewModel) {
+
+    val logs = remember {
+        appViewModel.logs
+    }
+
+    val lazyColumnListState = rememberLazyListState()
+    val clipboardManager: ClipboardManager = LocalClipboardManager.current
+    val scope = rememberCoroutineScope()
+
+    LaunchedEffect(logs.size) {
+        scope.launch {
+            lazyColumnListState.animateScrollToItem(logs.size)
+        }
+    }
+
+    Scaffold(
+        floatingActionButton = {
+            FloatingActionButton(
+                onClick = {
+                    appViewModel.saveLogsToFile()
+                },
+                shape = RoundedCornerShape(16.dp),
+                containerColor = MaterialTheme.colorScheme.primary,
+            ) {
+                val icon = Icons.Filled.Save
+                Icon(
+                    imageVector = icon,
+                    contentDescription = icon.name,
+                    tint = MaterialTheme.colorScheme.onPrimary,
+                )
+            }
+        },
+    ) {
+        LazyColumn(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(16.dp, Alignment.Top),
+            state = lazyColumnListState,
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(horizontal = 24.dp),
+        ) {
+            items(logs) {
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(5.dp, Alignment.Start),
+                    verticalAlignment = Alignment.Top,
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .clickable(
+                            interactionSource = remember { MutableInteractionSource() },
+                            indication = null,
+                            onClick = {
+                                clipboardManager.setText(annotatedString = AnnotatedString(it.toString()))
+                            },
+                        ),
+                ) {
+                    val fontSize = 10.sp
+                    Text(text = it.tag, modifier = Modifier.fillMaxSize(0.3f), fontSize = fontSize)
+                    LogTypeLabel(color = Color(it.level.color())) {
+                        Text(
+                            text = it.level.signifier,
+                            textAlign = TextAlign.Center,
+                            fontSize = fontSize,
+                        )
+                    }
+                    Text("${it.message} - ${it.time}", fontSize = fontSize)
+                }
+            }
+        }
+    }
+}
@@ -57,6 +57,7 @@ fun WireguardAutoTunnelTheme(
                val context = LocalContext.current
                if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
            }
+
            darkTheme -> DarkColorScheme
            else -> LightColorScheme
        }
@@ -10,13 +10,13 @@ import androidx.compose.ui.unit.sp
 val Typography =
    Typography(
        bodyLarge =
-            TextStyle(
-                fontFamily = FontFamily.Default,
-                fontWeight = FontWeight.Normal,
-                fontSize = 16.sp,
-                lineHeight = 24.sp,
-                letterSpacing = 0.5.sp,
-            ),
+        TextStyle(
+            fontFamily = FontFamily.Default,
+            fontWeight = FontWeight.Normal,
+            fontSize = 16.sp,
+            lineHeight = 24.sp,
+            letterSpacing = 0.5.sp,
+        ),
        /* Other default text styles to override
        titleLarge = TextStyle(
            fontFamily = FontFamily.Default,
@@ -1,22 +1,40 @@
 package com.zaneschepke.wireguardautotunnel.util

 object Constants {
+
+    const val BASE_LOG_FILE_NAME = "wgtunnel-logs"
+    const val LOG_BUFFER_SIZE = 3_000L
+
    const val MANUAL_TUNNEL_CONFIG_ID = "0"
-    const val BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT = 10 * 60 * 1000L // 10 minutes
-    const val DEFAULT_WATCHER_WAKE_LOCK_TIMEOUT = 30 * 60 * 1000L // 30 minutes
-    const val VPN_STATISTIC_CHECK_INTERVAL = 1000L
-    const val VPN_CONNECTED_NOTIFICATION_DELAY = 3000L
+    const val BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT = 10 * 60 * 1_000L // 10 minutes
+    const val VPN_STATISTIC_CHECK_INTERVAL = 1_000L
+    const val VPN_CONNECTED_NOTIFICATION_DELAY = 3_000L
    const val TOGGLE_TUNNEL_DELAY = 300L
+    const val WATCHER_COLLECTION_DELAY = 1_000L
    const val CONF_FILE_EXTENSION = ".conf"
    const val ZIP_FILE_EXTENSION = ".zip"
    const val URI_CONTENT_SCHEME = "content"
-    const val URI_PACKAGE_SCHEME = "package"
    const val ALLOWED_FILE_TYPES = "*/*"
+    const val TEXT_MIME_TYPE = "text/plain"
    const val GOOGLE_TV_EXPLORER_STUB = "com.google.android.tv.frameworkpackagestubs"
    const val ANDROID_TV_EXPLORER_STUB = "com.android.tv.frameworkpackagestubs"
+    const val ALWAYS_ON_VPN_ACTION = "android.net.VpnService"
    const val EMAIL_MIME_TYPE = "message/rfc822"
    const val SYSTEM_EXEMPT_SERVICE_TYPE_ID = 1024

    const val SUBSCRIPTION_TIMEOUT = 5_000L
    const val FOCUS_REQUEST_DELAY = 500L
+
+    const val BACKUP_PING_HOST = "1.1.1.1"
+    const val PING_TIMEOUT = 5_000L
+    const val VPN_RESTART_DELAY = 1_000L
+    const val PING_INTERVAL = 60_000L
+    const val PING_COOLDOWN = PING_INTERVAL * 60 //one hour
+
+    const val ALLOWED_DISPLAY_NAME_LENGTH = 20
+
+    const val TUNNEL_EXTRA_KEY = "tunnelId"
+
+    const val UNREADABLE_SSID = "<unknown ssid>"
+
 }
@@ -18,6 +18,12 @@ sealed class Event {
                get() = WireGuardAutoTunnel.instance.getString(R.string.error_ssid_exists)
        }

+        data class ConfigParseError(val appendedMessage: String) : Error() {
+            override val message: String =
+                WireGuardAutoTunnel.instance.getString(R.string.config_parse_error) + (
+                    if (appendedMessage != "") ": ${appendedMessage.trim()}" else "")
+        }
+
        data object RootDenied : Error() {
            override val message: String
                get() = WireGuardAutoTunnel.instance.getString(R.string.error_root_denied)
@@ -2,15 +2,14 @@ package com.zaneschepke.wireguardautotunnel.util

 import android.content.BroadcastReceiver
 import android.content.pm.PackageInfo
-import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Statistics.PeerStats
-import com.wireguard.crypto.Key
 import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
+import org.amnezia.awg.backend.Statistics
+import org.amnezia.awg.crypto.Key
 import java.math.BigDecimal
 import java.text.DecimalFormat
 import kotlin.coroutines.CoroutineContext
@@ -31,6 +30,12 @@ fun BroadcastReceiver.goAsync(
    }
 }

+fun String.truncateWithEllipsis(allowedLength: Int): String {
+    return if (this.length > allowedLength + 3) {
+        this.substring(0, allowedLength) + "***"
+    } else this
+}
+
 fun BigDecimal.toThreeDecimalPlaceString(): String {
    val df = DecimalFormat("#.###")
    return df.format(this)
@@ -44,15 +49,15 @@ typealias TunnelConfigs = List<TunnelConfig>

 typealias Packages = List<PackageInfo>

-fun Statistics.mapPeerStats(): Map<Key, PeerStats?> {
+fun Statistics.mapPeerStats(): Map<Key, Statistics.PeerStats?> {
    return this.peers().associateWith { key -> (this.peer(key)) }
 }

-fun PeerStats.latestHandshakeSeconds(): Long? {
+fun Statistics.PeerStats.latestHandshakeSeconds(): Long? {
    return NumberUtils.getSecondsBetweenTimestampAndNow(this.latestHandshakeEpochMillis)
 }

-fun PeerStats.handshakeStatus(): HandshakeStatus {
+fun Statistics.PeerStats.handshakeStatus(): HandshakeStatus {
    // TODO add never connected status after duration
    return this.latestHandshakeSeconds().let {
        when {
@@ -7,6 +7,7 @@ import android.os.Environment
 import android.provider.MediaStore
 import android.provider.MediaStore.MediaColumns
 import java.io.File
+import java.io.FileOutputStream
 import java.io.OutputStream
 import java.time.Instant
 import java.util.zip.ZipEntry
@@ -15,6 +16,7 @@ import java.util.zip.ZipOutputStream
 object FileUtils {
    private const val ZIP_FILE_MIME_TYPE = "application/zip"

+    //TODO issue with android 9
    private fun createDownloadsFileOutputStream(
        context: Context,
        fileName: String,
@@ -43,6 +45,31 @@ object FileUtils {
        return null
    }

+    fun saveFileToDownloads(context: Context, content: String, fileName: String) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            val contentValues = ContentValues().apply {
+                put(MediaColumns.DISPLAY_NAME, fileName)
+                put(MediaColumns.MIME_TYPE, Constants.TEXT_MIME_TYPE)
+                put(MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
+            }
+            val resolver = context.contentResolver
+            val uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues)
+            if (uri != null) {
+                resolver.openOutputStream(uri).use { output ->
+                    output?.write(content.toByteArray())
+                }
+            }
+        } else {
+            val target = File(
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+                fileName,
+            )
+            FileOutputStream(target).use { output ->
+                output.write(content.toByteArray())
+            }
+        }
+    }
+
    fun saveFilesToZip(context: Context, files: List<File>) {
        val zipOutputStream =
            createDownloadsFileOutputStream(
@@ -19,7 +19,15 @@ object NumberUtils {
    }

    fun generateRandomTunnelName(): String {
-        return "tunnel${(Math.random() * 100000).toInt()}"
+        return "tunnel${randomFive()}"
+    }
+
+    private fun randomFive(): Int {
+        return (Math.random() * 100000).toInt()
+    }
+
+    fun randomThree(): Int {
+        return (Math.random() * 1000).toInt()
    }

    fun getSecondsBetweenTimestampAndNow(epoch: Long): Long? {
@@ -0,0 +1,17 @@
+package com.zaneschepke.wireguardautotunnel.util
+
+import timber.log.Timber
+
+class ReleaseTree : Timber.DebugTree() {
+    override fun d(t: Throwable?) {
+        return
+    }
+
+    override fun d(t: Throwable?, message: String?, vararg args: Any?) {
+        return
+    }
+
+    override fun d(message: String?, vararg args: Any?) {
+        return
+    }
+}
@@ -0,0 +1,24 @@
+package com.zaneschepke.wireguardautotunnel.util
+
+import android.content.Context
+import androidx.annotation.StringRes
+
+sealed class StringValue {
+
+    data class DynamicString(val value: String) : StringValue()
+
+    data object Empty : StringValue()
+
+    class StringResource(
+        @StringRes val resId: Int,
+        vararg val args: Any
+    ) : StringValue()
+
+    fun asString(context: Context?): String {
+        return when (this) {
+            is Empty -> ""
+            is DynamicString -> value
+            is StringResource -> context?.getString(resId, *args).orEmpty()
+        }
+    }
+}
@@ -1,17 +1,18 @@
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="24dp"
    android:height="24dp"
+    android:tint="#FFFFFF"
    android:viewportWidth="640"
-    android:viewportHeight="640"
-    android:tint="#FFFFFF">
-  <group android:scaleX="1.0132159"
-      android:scaleY="1.0132159"
-      android:translateX="-4.229075"
-      android:translateY="-4.229075">
-    <path
-        android:pathData="M316.72,80.15C314.94,80.82 312.08,83.95 308.79,88.84C275.66,138.15 157.88,161.96 119.66,127.08C109.97,118.24 101.21,118.84 98.97,128.5C96.01,141.29 98.49,204.07 103.12,233.5C123.71,364.32 186.77,465.69 303.03,554.88C314.06,563.34 316.63,563.42 326.93,555.61C329.91,553.35 336.21,548.63 340.93,545.13C345.64,541.63 350.87,537.46 352.55,535.88C354.23,534.29 357.92,531.53 360.75,529.74C413.56,496.43 481.74,399.04 510.38,316C527.22,267.19 534.86,236.66 539.96,197.9C547.99,136.74 545.31,124.46 526,134.01C469.85,161.74 361.02,137.16 333.39,90.49C327.63,80.75 322.93,77.84 316.72,80.15M307.5,195.34C282.24,203.76 266.16,237.38 269.85,274.04C270.99,285.39 271.18,285 264.63,285C254.13,285 254.15,284.87 255,352.05C255.64,402.94 250.1,397.02 298.5,398.52C352.54,400.2 377.63,400.23 379.23,398.63C381.67,396.18 381.86,392.86 382.46,339.89C383.09,283.93 383.39,286 374.51,286C367.07,286 367.21,286.26 367.77,273.58C369.89,225.38 338.74,184.92 307.5,195.34M308.93,216.98C294.31,224.7 281.68,270.05 290.33,283.75C291.74,285.99 346.85,285.51 347.78,283.25C359.48,254.75 330.62,205.51 308.93,216.98M309.54,317.1C304.18,321.81 304.39,327.76 310.11,332.99C314.78,337.26 314.82,336.51 309.33,349.89C307.44,354.51 306.13,358.89 306.42,359.64C306.96,361.06 329,361.75 329,360.35C329,359.98 327.42,354.82 325.5,348.86C323.58,342.91 322,337.52 322,336.89C322,336.26 323.58,334 325.5,331.87C335.69,320.59 321.02,307.02 309.54,317.1"
-        android:fillColor="#53bdb6"
-        android:fillType="evenOdd"
-        android:strokeColor="#00000000"/>
-  </group>
+    android:viewportHeight="640">
+    <group
+        android:scaleX="1.0132159"
+        android:scaleY="1.0132159"
+        android:translateX="-4.229075"
+        android:translateY="-4.229075">
+        <path
+            android:fillColor="#53bdb6"
+            android:fillType="evenOdd"
+            android:pathData="M316.72,80.15C314.94,80.82 312.08,83.95 308.79,88.84C275.66,138.15 157.88,161.96 119.66,127.08C109.97,118.24 101.21,118.84 98.97,128.5C96.01,141.29 98.49,204.07 103.12,233.5C123.71,364.32 186.77,465.69 303.03,554.88C314.06,563.34 316.63,563.42 326.93,555.61C329.91,553.35 336.21,548.63 340.93,545.13C345.64,541.63 350.87,537.46 352.55,535.88C354.23,534.29 357.92,531.53 360.75,529.74C413.56,496.43 481.74,399.04 510.38,316C527.22,267.19 534.86,236.66 539.96,197.9C547.99,136.74 545.31,124.46 526,134.01C469.85,161.74 361.02,137.16 333.39,90.49C327.63,80.75 322.93,77.84 316.72,80.15M307.5,195.34C282.24,203.76 266.16,237.38 269.85,274.04C270.99,285.39 271.18,285 264.63,285C254.13,285 254.15,284.87 255,352.05C255.64,402.94 250.1,397.02 298.5,398.52C352.54,400.2 377.63,400.23 379.23,398.63C381.67,396.18 381.86,392.86 382.46,339.89C383.09,283.93 383.39,286 374.51,286C367.07,286 367.21,286.26 367.77,273.58C369.89,225.38 338.74,184.92 307.5,195.34M308.93,216.98C294.31,224.7 281.68,270.05 290.33,283.75C291.74,285.99 346.85,285.51 347.78,283.25C359.48,254.75 330.62,205.51 308.93,216.98M309.54,317.1C304.18,321.81 304.39,327.76 310.11,332.99C314.78,337.26 314.82,336.51 309.33,349.89C307.44,354.51 306.13,358.89 306.42,359.64C306.96,361.06 329,361.75 329,360.35C329,359.98 327.42,354.82 325.5,348.86C323.58,342.91 322,337.52 322,336.89C322,336.26 323.58,334 325.5,331.87C335.69,320.59 321.02,307.02 309.54,317.1"
+            android:strokeColor="#00000000" />
+    </group>
 </vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#FF000000"
+        android:pathData="M360,600v-240h80v240h-80ZM520,600v-240h80v240h-80ZM480,920q-108,0 -202.5,-49.5T120,732v108L40,840v-240h240v80h-98q51,75 129.5,117.5T480,840q115,0 208.5,-66T820,599l78,18q-45,136 -160,219.5T480,920ZM42,440q7,-67 32,-128.5T143,198l57,57q-32,41 -52,87.5T123,440L42,440ZM256,199 L199,142q53,-44 114,-69.5T440,42v80q-51,5 -97,25t-87,52ZM705,199q-41,-32 -87.5,-52T520,122v-80q67,6 128.5,31T762,142l-57,57ZM838,440q-5,-51 -25,-97.5T761,255l57,-57q44,52 69,113.5T918,440h-80Z" />
+</vector>
@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+    <path
+        android:fillColor="#FF000000"
+        android:pathData="M380,660v-360l280,180 -280,180ZM480,920q-108,0 -202.5,-49.5T120,732v108L40,840v-240h240v80h-98q51,75 129.5,117.5T480,840q115,0 208.5,-66T820,599l78,18q-45,136 -160,219.5T480,920ZM42,440q7,-67 32,-128.5T143,198l57,57q-32,41 -52,87.5T123,440L42,440ZM256,199 L199,142q53,-44 114,-69.5T440,42v80q-51,5 -97,25t-87,52ZM705,199q-41,-32 -87.5,-52T520,122v-80q67,6 128.5,31T762,142l-57,57ZM838,440q-5,-51 -25,-97.5T761,255l57,-57q44,52 69,113.5T918,440h-80Z" />
+</vector>
@@ -3,43 +3,54 @@
    android:height="180dp"
    android:viewportWidth="640"
    android:viewportHeight="640">
-  <group android:scaleX="0.6666667"
-      android:scaleY="0.6666667"
-      android:translateX="106.666664"
-      android:translateY="106.666664">
-    <group android:scaleX="0.315"
-        android:scaleY="0.56"
-        android:translateX="46.4"
-        android:translateY="140.8">
-      <path
-          android:pathData="M316.72,80.15C314.94,80.82 312.08,83.95 308.79,88.84C275.66,138.15 157.88,161.96 119.66,127.08C109.97,118.24 101.21,118.84 98.97,128.5C96.01,141.29 98.49,204.07 103.12,233.5C123.71,364.32 186.77,465.69 303.03,554.88C314.06,563.34 316.63,563.42 326.93,555.61C329.91,553.35 336.21,548.63 340.93,545.13C345.64,541.63 350.87,537.46 352.55,535.88C354.23,534.29 357.92,531.53 360.75,529.74C413.56,496.43 481.74,399.04 510.38,316C527.22,267.19 534.86,236.66 539.96,197.9C547.99,136.74 545.31,124.46 526,134.01C469.85,161.74 361.02,137.16 333.39,90.49C327.63,80.75 322.93,77.84 316.72,80.15M307.5,195.34C282.24,203.76 266.16,237.38 269.85,274.04C270.99,285.39 271.18,285 264.63,285C254.13,285 254.15,284.87 255,352.05C255.64,402.94 250.1,397.02 298.5,398.52C352.54,400.2 377.63,400.23 379.23,398.63C381.67,396.18 381.86,392.86 382.46,339.89C383.09,283.93 383.39,286 374.51,286C367.07,286 367.21,286.26 367.77,273.58C369.89,225.38 338.74,184.92 307.5,195.34M308.93,216.98C294.31,224.7 281.68,270.05 290.33,283.75C291.74,285.99 346.85,285.51 347.78,283.25C359.48,254.75 330.62,205.51 308.93,216.98M309.54,317.1C304.18,321.81 304.39,327.76 310.11,332.99C314.78,337.26 314.82,336.51 309.33,349.89C307.44,354.51 306.13,358.89 306.42,359.64C306.96,361.06 329,361.75 329,360.35C329,359.98 327.42,354.82 325.5,348.86C323.58,342.91 322,337.52 322,336.89C322,336.26 323.58,334 325.5,331.87C335.69,320.59 321.02,307.02 309.54,317.1"
-          android:fillColor="#53bdb6"
-          android:fillType="evenOdd"
-          android:strokeColor="#00000000"/>
-    </group>
+    <group
+        android:scaleX="0.6666667"
+        android:scaleY="0.6666667"
+        android:translateX="106.666664"
+        android:translateY="106.666664">
+        <group
+            android:scaleX="0.315"
+            android:scaleY="0.56"
+            android:translateX="46.4"
+            android:translateY="140.8">
+            <path
+                android:fillColor="#53bdb6"
+                android:fillType="evenOdd"
+                android:pathData="M316.72,80.15C314.94,80.82 312.08,83.95 308.79,88.84C275.66,138.15 157.88,161.96 119.66,127.08C109.97,118.24 101.21,118.84 98.97,128.5C96.01,141.29 98.49,204.07 103.12,233.5C123.71,364.32 186.77,465.69 303.03,554.88C314.06,563.34 316.63,563.42 326.93,555.61C329.91,553.35 336.21,548.63 340.93,545.13C345.64,541.63 350.87,537.46 352.55,535.88C354.23,534.29 357.92,531.53 360.75,529.74C413.56,496.43 481.74,399.04 510.38,316C527.22,267.19 534.86,236.66 539.96,197.9C547.99,136.74 545.31,124.46 526,134.01C469.85,161.74 361.02,137.16 333.39,90.49C327.63,80.75 322.93,77.84 316.72,80.15M307.5,195.34C282.24,203.76 266.16,237.38 269.85,274.04C270.99,285.39 271.18,285 264.63,285C254.13,285 254.15,284.87 255,352.05C255.64,402.94 250.1,397.02 298.5,398.52C352.54,400.2 377.63,400.23 379.23,398.63C381.67,396.18 381.86,392.86 382.46,339.89C383.09,283.93 383.39,286 374.51,286C367.07,286 367.21,286.26 367.77,273.58C369.89,225.38 338.74,184.92 307.5,195.34M308.93,216.98C294.31,224.7 281.68,270.05 290.33,283.75C291.74,285.99 346.85,285.51 347.78,283.25C359.48,254.75 330.62,205.51 308.93,216.98M309.54,317.1C304.18,321.81 304.39,327.76 310.11,332.99C314.78,337.26 314.82,336.51 309.33,349.89C307.44,354.51 306.13,358.89 306.42,359.64C306.96,361.06 329,361.75 329,360.35C329,359.98 327.42,354.82 325.5,348.86C323.58,342.91 322,337.52 322,336.89C322,336.26 323.58,334 325.5,331.87C335.69,320.59 321.02,307.02 309.54,317.1"
+                android:strokeColor="#00000000" />
+        </group>

-    <group android:scaleX="0.52644"
-        android:scaleY="0.20707752"
-        android:translateX="320.4"
-        android:translateY="70.26513">
-      <group android:translateY="132.92308">
-        <path android:pathData="M76.06154,-101.68616L87.95077,-101.68616L72.44308,0L55.606155,0L43.93846,-76.72615L32.196922,0L14.990769,0L0.6646154,-101.68616L13.513846,-101.68616L24.36923,-14.104615L36.553844,-89.870766L52.283077,-89.870766L63.876923,-14.104615Z"
-            android:fillColor="#53BDB6"/>
-        <path android:pathData="M135.30154,1.6984615Q123.11692,1.6984615,114.25539,-4.1723075Q105.393845,-10.0430765,100.55692,-21.821539Q95.72,-33.6,95.72,-50.88Q95.72,-67.643074,101.62769,-79.495384Q107.535385,-91.347694,117.246155,-97.32923Q126.956924,-103.31077,138.25539,-103.31077Q147.78154,-103.31077,154.42769,-100.61539Q161.07385,-97.92,167.35077,-92.16L159.59692,-84.11077Q154.94461,-88.46769,149.77539,-90.535385Q144.60616,-92.60307,138.32922,-92.60307Q130.42769,-92.60307,123.92923,-88.504616Q117.43077,-84.40615,113.44308,-75.10154Q109.45538,-65.79692,109.45538,-50.88Q109.45538,-29.095385,116.175385,-19.089231Q122.895386,-9.0830765,136.48308,-9.0830765Q146.7477,-9.0830765,155.83076,-13.9569235L155.83076,-44.97231L135.81847,-44.97231L134.26768,-55.606155L168.5323,-55.606155L168.5323,-7.163077Q160.70462,-2.88,152.98769,-0.59076923Q145.27077,1.6984615,135.30154,1.6984615Z"
-            android:fillColor="#53BDB6"/>
-        <path android:pathData="M348.30463,-90.683075L317.43692,-90.683075L317.43692,0L304.66153,0L304.66153,-90.683075L272.90768,-90.683075L272.90768,-101.68616L349.63385,-101.68616Z"
-            android:fillColor="#53BDB6"/>
-        <path android:pathData="M383.24924,-22.670769Q383.24924,-15.064615,386.3877,-11.630769Q389.52615,-8.196923,396.32,-8.196923Q402.44922,-8.196923,408.24615,-11.741538Q414.0431,-15.286154,417.36615,-20.52923L417.36615,-77.76L429.7723,-77.76L429.7723,0L419.2123,0L418.17847,-10.486154Q413.67386,-4.726154,406.99078,-1.5138462Q400.30768,1.6984615,393.2923,1.6984615Q382.14154,1.6984615,376.4923,-4.246154Q370.84308,-10.190769,370.84308,-21.193846L370.84308,-77.76L383.24924,-77.76Z"
-            android:fillColor="#53BDB6"/>
-        <path android:pathData="M459.84308,0L459.84308,-77.76L470.40308,-77.76L471.36307,-66.97846Q476.01538,-72.81231,483.0677,-76.098465Q490.12,-79.38461,497.06152,-79.38461Q508.2123,-79.38461,513.56616,-73.47692Q518.92,-67.56923,518.92,-56.49231L518.92,0L506.51385,0L506.51385,-47.335384Q506.51385,-56.049232,505.59076,-60.627693Q504.6677,-65.206154,501.82462,-67.42154Q498.98154,-69.636925,493.22153,-69.636925Q486.9446,-69.636925,481.36923,-65.76Q475.79385,-61.883076,472.24924,-56.64L472.24924,0Z"
-            android:fillColor="#53BDB6"/>
-        <path android:pathData="M548.8431,0L548.8431,-77.76L559.4031,-77.76L560.3631,-66.97846Q565.0154,-72.81231,572.0677,-76.098465Q579.12,-79.38461,586.0615,-79.38461Q597.2123,-79.38461,602.56616,-73.47692Q607.92,-67.56923,607.92,-56.49231L607.92,0L595.51385,0L595.51385,-47.335384Q595.51385,-56.049232,594.59076,-60.627693Q593.66766,-65.206154,590.8246,-67.42154Q587.98157,-69.636925,582.22156,-69.636925Q575.94464,-69.636925,570.3692,-65.76Q564.7938,-61.883076,561.2492,-56.64L561.2492,0Z"
-            android:fillColor="#53BDB6"/>
-        <path android:pathData="M647.59076,-34.486153Q647.88617,-25.772308,650.9877,-19.975384Q654.08923,-14.178461,659.1108,-11.409231Q664.1323,-8.64,670.3354,-8.64Q676.0954,-8.64,680.9323,-10.338462Q685.7692,-12.036923,691.0862,-15.655385L696.92,-7.4584618Q691.4554,-3.1753845,684.4031,-0.73846155Q677.35077,1.6984615,670.1877,1.6984615Q659.0369,1.6984615,650.9877,-3.323077Q642.9385,-8.344615,638.7662,-17.50154Q634.5939,-26.65846,634.5939,-38.76923Q634.5939,-50.51077,638.8031,-59.74154Q643.0123,-68.972305,650.6923,-74.17846Q658.3723,-79.38461,668.56305,-79.38461Q678.3108,-79.38461,685.43695,-74.80615Q692.56305,-70.22769,696.36615,-61.624615Q700.16925,-53.021538,700.16925,-41.28Q700.16925,-37.883076,699.87384,-34.486153ZM668.71075,-69.19385Q659.70154,-69.19385,654.0523,-62.88Q648.4031,-56.566154,647.6646,-44.086155L688.2062,-44.086155Q687.9846,-56.344616,682.81537,-62.76923Q677.6462,-69.19385,668.71075,-69.19385Z"
-            android:fillColor="#53BDB6"/>
-        <path android:pathData="M757.12,-19.2Q757.12,-13.735385,760.55383,-11.187693Q763.9877,-8.64,769.96924,-8.64Q776.24615,-8.64,783.04,-11.372308L786.3631,-2.2892308Q782.8185,-0.51692307,778.0923,0.59076923Q773.36615,1.6984615,767.90155,1.6984615Q761.0339,1.6984615,755.75385,-0.8861538Q750.4738,-3.4707692,747.5939,-8.344615Q744.71387,-13.218462,744.71387,-19.864614L744.71387,-99.24923L720.8615,-99.24923L720.8615,-109.07077L757.12,-109.07077Z"
-            android:fillColor="#53BDB6"/>
-      </group>
+        <group
+            android:scaleX="0.52644"
+            android:scaleY="0.20707752"
+            android:translateX="320.4"
+            android:translateY="70.26513">
+            <group android:translateY="132.92308">
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M76.06154,-101.68616L87.95077,-101.68616L72.44308,0L55.606155,0L43.93846,-76.72615L32.196922,0L14.990769,0L0.6646154,-101.68616L13.513846,-101.68616L24.36923,-14.104615L36.553844,-89.870766L52.283077,-89.870766L63.876923,-14.104615Z" />
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M135.30154,1.6984615Q123.11692,1.6984615,114.25539,-4.1723075Q105.393845,-10.0430765,100.55692,-21.821539Q95.72,-33.6,95.72,-50.88Q95.72,-67.643074,101.62769,-79.495384Q107.535385,-91.347694,117.246155,-97.32923Q126.956924,-103.31077,138.25539,-103.31077Q147.78154,-103.31077,154.42769,-100.61539Q161.07385,-97.92,167.35077,-92.16L159.59692,-84.11077Q154.94461,-88.46769,149.77539,-90.535385Q144.60616,-92.60307,138.32922,-92.60307Q130.42769,-92.60307,123.92923,-88.504616Q117.43077,-84.40615,113.44308,-75.10154Q109.45538,-65.79692,109.45538,-50.88Q109.45538,-29.095385,116.175385,-19.089231Q122.895386,-9.0830765,136.48308,-9.0830765Q146.7477,-9.0830765,155.83076,-13.9569235L155.83076,-44.97231L135.81847,-44.97231L134.26768,-55.606155L168.5323,-55.606155L168.5323,-7.163077Q160.70462,-2.88,152.98769,-0.59076923Q145.27077,1.6984615,135.30154,1.6984615Z" />
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M348.30463,-90.683075L317.43692,-90.683075L317.43692,0L304.66153,0L304.66153,-90.683075L272.90768,-90.683075L272.90768,-101.68616L349.63385,-101.68616Z" />
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M383.24924,-22.670769Q383.24924,-15.064615,386.3877,-11.630769Q389.52615,-8.196923,396.32,-8.196923Q402.44922,-8.196923,408.24615,-11.741538Q414.0431,-15.286154,417.36615,-20.52923L417.36615,-77.76L429.7723,-77.76L429.7723,0L419.2123,0L418.17847,-10.486154Q413.67386,-4.726154,406.99078,-1.5138462Q400.30768,1.6984615,393.2923,1.6984615Q382.14154,1.6984615,376.4923,-4.246154Q370.84308,-10.190769,370.84308,-21.193846L370.84308,-77.76L383.24924,-77.76Z" />
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M459.84308,0L459.84308,-77.76L470.40308,-77.76L471.36307,-66.97846Q476.01538,-72.81231,483.0677,-76.098465Q490.12,-79.38461,497.06152,-79.38461Q508.2123,-79.38461,513.56616,-73.47692Q518.92,-67.56923,518.92,-56.49231L518.92,0L506.51385,0L506.51385,-47.335384Q506.51385,-56.049232,505.59076,-60.627693Q504.6677,-65.206154,501.82462,-67.42154Q498.98154,-69.636925,493.22153,-69.636925Q486.9446,-69.636925,481.36923,-65.76Q475.79385,-61.883076,472.24924,-56.64L472.24924,0Z" />
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M548.8431,0L548.8431,-77.76L559.4031,-77.76L560.3631,-66.97846Q565.0154,-72.81231,572.0677,-76.098465Q579.12,-79.38461,586.0615,-79.38461Q597.2123,-79.38461,602.56616,-73.47692Q607.92,-67.56923,607.92,-56.49231L607.92,0L595.51385,0L595.51385,-47.335384Q595.51385,-56.049232,594.59076,-60.627693Q593.66766,-65.206154,590.8246,-67.42154Q587.98157,-69.636925,582.22156,-69.636925Q575.94464,-69.636925,570.3692,-65.76Q564.7938,-61.883076,561.2492,-56.64L561.2492,0Z" />
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M647.59076,-34.486153Q647.88617,-25.772308,650.9877,-19.975384Q654.08923,-14.178461,659.1108,-11.409231Q664.1323,-8.64,670.3354,-8.64Q676.0954,-8.64,680.9323,-10.338462Q685.7692,-12.036923,691.0862,-15.655385L696.92,-7.4584618Q691.4554,-3.1753845,684.4031,-0.73846155Q677.35077,1.6984615,670.1877,1.6984615Q659.0369,1.6984615,650.9877,-3.323077Q642.9385,-8.344615,638.7662,-17.50154Q634.5939,-26.65846,634.5939,-38.76923Q634.5939,-50.51077,638.8031,-59.74154Q643.0123,-68.972305,650.6923,-74.17846Q658.3723,-79.38461,668.56305,-79.38461Q678.3108,-79.38461,685.43695,-74.80615Q692.56305,-70.22769,696.36615,-61.624615Q700.16925,-53.021538,700.16925,-41.28Q700.16925,-37.883076,699.87384,-34.486153ZM668.71075,-69.19385Q659.70154,-69.19385,654.0523,-62.88Q648.4031,-56.566154,647.6646,-44.086155L688.2062,-44.086155Q687.9846,-56.344616,682.81537,-62.76923Q677.6462,-69.19385,668.71075,-69.19385Z" />
+                <path
+                    android:fillColor="#53BDB6"
+                    android:pathData="M757.12,-19.2Q757.12,-13.735385,760.55383,-11.187693Q763.9877,-8.64,769.96924,-8.64Q776.24615,-8.64,783.04,-11.372308L786.3631,-2.2892308Q782.8185,-0.51692307,778.0923,0.59076923Q773.36615,1.6984615,767.90155,1.6984615Q761.0339,1.6984615,755.75385,-0.8861538Q750.4738,-3.4707692,747.5939,-8.344615Q744.71387,-13.218462,744.71387,-19.864614L744.71387,-99.24923L720.8615,-99.24923L720.8615,-109.07077L757.12,-109.07077Z" />
+            </group>
+        </group>
    </group>
-  </group>
 </vector>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Zane Schepke	6f48147b3e	feat: add amneziawg support	2024-04-27 21:44:41 -04:00
Zane Schepke	16979dbb2b	Update ic_channel.xml	2024-04-26 01:50:08 -04:00
Hosted Weblate	5d8190628d	Update translation files Updated by "Remove blank strings" hook in Weblate. Translation: WG Tunnel/strings Translate-URL: https://hosted.weblate.org/projects/wg-tunnel/strings/	2024-04-26 01:50:08 -04:00
Anonymous	6d597a235d	Translated using Weblate (Spanish) Currently translated at 100.0% (159 of 159 strings) Translation: WG Tunnel/strings Translate-URL: https://hosted.weblate.org/projects/wg-tunnel/strings/es/	2024-04-26 01:49:49 -04:00
Anonymous	61fd2f01b9	Translated using Weblate (German) Currently translated at 49.0% (78 of 159 strings) Translation: WG Tunnel/strings Translate-URL: https://hosted.weblate.org/projects/wg-tunnel/strings/de/	2024-04-26 01:49:08 -04:00
Anonymous	914a641977	Translated using Weblate (Russian) Currently translated at 3.1% (5 of 159 strings) Translation: WG Tunnel/strings Translate-URL: https://hosted.weblate.org/projects/wg-tunnel/strings/ru/	2024-04-26 01:49:08 -04:00
Anonymous	c97a3afbc4	Translated using Weblate (Turkish) Currently translated at 100.0% (159 of 159 strings) Translation: WG Tunnel/strings Translate-URL: https://hosted.weblate.org/projects/wg-tunnel/strings/tr/	2024-04-26 01:49:08 -04:00
gallegonovato	fadc2d1562	Translated using Weblate (Spanish) Currently translated at 100.0% (159 of 159 strings) Translation: WG Tunnel/strings Translate-URL: https://hosted.weblate.org/projects/wg-tunnel/strings/es/	2024-04-26 01:49:08 -04:00
Languages add-on	106ab76b82	Added translation using Weblate (Spanish)	2024-04-26 01:48:39 -04:00
Weblate (bot)	48b3f60b37	Translations update from Hosted Weblate (#177 ) Co-authored-by: Languages add-on <noreply-addon-languages@weblate.org> Co-authored-by: Gabriel Franz <gabrielfranz31@gmail.com> Co-authored-by: Saratoga79 <ordizi79@gmail.com>	2024-04-24 03:49:57 -04:00
ＷＩＮＺＯＲＴ	e7f5cee6dd	Add fastlane tr (#173 )	2024-04-22 23:21:19 -04:00
Zane Schepke	5e01fd6c85	Merge pull request #175 from zaneschepke/i18n Translations update from Hosted Weblate	2024-04-22 23:18:46 -04:00
Dominik Thalhammer	dcbd72c6f6	Translated using Weblate (German) Currently translated at 40.9% (9 of 22 strings) Translation: WG Tunnel/fastlane Translate-URL: https://hosted.weblate.org/projects/wg-tunnel/fastlane/de/	2024-04-22 13:18:21 +02:00
Languages add-on	f27aa1452a	Added translation using Weblate (German)	2024-04-22 07:52:45 +02:00
Languages add-on	82c3521c58	Added translation using Weblate (Russian)	2024-04-21 06:19:53 +02:00
Zane Schepke	c6535ffe7e	chore: update chats	2024-04-20 18:36:40 -04:00
Zane Schepke	be5fe94ce6	chore: cleanup unused strings	2024-04-20 17:42:14 -04:00
Zane Schepke	1e905c1cfb	chore: update README.md	2024-04-20 17:09:36 -04:00
Zane Schepke	a549c111aa	Merge pull request #170 from yurtpage/i18n i18n	2024-04-20 16:28:15 -04:00
Zane Schepke	5ab344044e	chore: add Weblate details to README	2024-04-20 14:30:21 -04:00
Zane Schepke	7030f68548	chore: update README	2024-04-20 13:57:33 -04:00
Zane Schepke	ecd51b6fe5	chore: add code of conduct	2024-04-20 13:52:28 -04:00
Yurt Page	3e4f8e0791	fastlane i18n ru Signed-off-by: Yurt Page <yurtpage@gmail.com>	2024-04-19 18:28:58 +03:00
Zane Schepke	e940a0dbc5	Merge pull request #167 from mikropsoft/main Improve tr locales	2024-04-18 22:12:21 -04:00
ＷＩＮＺＯＲＴ	8e233475df	Update strings.xml	2024-04-17 17:41:49 +03:00
ＷＩＮＺＯＲＴ	24789826ad	Update strings.xml	2024-04-17 17:38:00 +03:00
ＷＩＮＺＯＲＴ	787e0d1a71	Update strings.xml	2024-04-17 17:37:22 +03:00
ＷＩＮＺＯＲＴ	914ef53ef0	Improve tr locales	2024-04-17 17:23:27 +03:00
Zane Schepke	a569974beb	add Turkish localization	2024-04-16 16:13:41 -04:00
Zane Schepke	87bc89b6f1	Merge branch 'main' of https://github.com/zaneschepke/wgtunnel	2024-04-16 00:50:43 -04:00
Zane Schepke	c343220e96	Merge pull request #156 from mikropsoft/main Add tr locales	2024-04-16 00:41:14 -04:00
Zane Schepke	5447ec73f7	fix: stop tunnel regression Fixes regression where tunnel is stuck in on state after x amount of toggles. Closes #163 Adds obfuscation of potentially sensitive data from logs. Closes #160 Adds hiding of FAB on scroll to allow users to toggle tunnels when they have many tunnel configs. Closes #161	2024-04-16 00:14:06 -04:00
Zane Schepke	a2b8eb5b0b	ci: update release wording	2024-04-06 11:06:19 -04:00
Zane Schepke	e37777e662	fix: improve auto-tunnel reliability Improved service manager stop service command to improve reliability Closes #148 Added assets required by Google Play for AndroidTV to fix Google Play release Added apk fingerprint hash to release to allow verification of apk signature via apksigner Improve tile sync when tiles are first added Bump versions	2024-04-06 10:43:00 -04:00
ＷＩＮＺＯＲＴ	ee3fcabcf1	Add tr locales	2024-04-06 15:39:46 +03:00
Zane Schepke	2a8895ffbc	docs: update readme, add security	2024-03-30 23:16:19 -04:00
Zane Schepke	b1fdb5b9b2	feat: auto-tunneling flexibility Added tunnel settings feature where users can configure a tunnel to be used on certain SSID or with mobile data. Closes #50 Added feature where if a tunnel was active when phone restarted, the app will start that tunnel on boot. Removed automatic auto-tunnel toggling/override from the tunnel tile and app shortcuts as it can cause undesirable behavior. Added second tile to control auto-tunneling pause/resume state from a tile. Added two additional static shortcuts to be able to control auto-tunneling pause/resume state from shortcuts. Fixed bug where crashes can happen from serializing and deserializing tunnel configs by removing the need for serialization of tunnel configs. Refactored logic of watcher and tunnel service to make state more predictable. #127 Fixed bug where rapidly toggling tunnels can cause crashes. Closes #145 Improved how tunnels are manually toggled from one to another. Improved logic/storage around primary tunnel behavior. Fixes issue where info level logs were not populating on release builds. Increase allowed name length displayed in UI. Closes #143 Fixes bug where androidTV could crash in certain situations. Bump versions. Updated screenshots.	2024-03-30 00:00:35 -04:00
Zane Schepke	1d644748e5	Update README.md	2024-03-18 23:48:38 -04:00
Zane Schepke	61989b596f	Merge pull request #135 from zaneschepke/dependabot/github_actions/softprops/action-gh-release-2 build(deps): bump softprops/action-gh-release from 1 to 2	2024-03-18 23:40:46 -04:00
Zane Schepke	5946d7c10d	feat: add lock, logs, and ping Fixes bug where control tile tunnel did not match with tunnel being controlled Closes #132 Fixes tunnel config edit screen error message #131 Revert to official lib to fix slow speeds issue Closes #137 Adds local app lock feature Closes #88 Adds restart vpn on ping fail with 1 minute interval and 60 minute cooldown Closes #6 Adds ability to easily make a copy of a tunnel. Fixes bug on AndroidTV where tunnels were not being deleted properly. Fixes bug where auto tunneling could be turned on before VPN permission was given.	2024-03-18 22:52:00 -04:00
Zane Schepke	4fc8ffbcbb	feat: add logs screen	2024-03-13 02:52:57 -04:00
Zane Schepke	c0cff297b2	remove firebase	2024-03-11 12:39:00 -04:00
dependabot[bot]	7ca0db3a40	build(deps): bump softprops/action-gh-release from 1 to 2 Bumps [softprops/action-gh-release](https://github.com/softprops/action-gh-release) from 1 to 2. - [Release notes](https://github.com/softprops/action-gh-release/releases) - [Changelog](https://github.com/softprops/action-gh-release/blob/master/CHANGELOG.md) - [Commits](https://github.com/softprops/action-gh-release/compare/v1...v2) --- updated-dependencies: - dependency-name: softprops/action-gh-release dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2024-03-11 13:36:55 +00:00
Zane Schepke	ee8db0a859	fix: ui bug and graphene notification Fixes a bug where save button was hidden on config screen Adds a disclaimer notification for when GrapheneOS auto enabled Always-on VPN on first app tunnel start Closes #121 #120	2024-02-20 16:17:34 -05:00