fix: start foreground

Fixes issue where auto tunnel should be starting service foreground
fix pipeline sdk target
2026-06-02 08:33:40 +02:00 · 2023-12-31 22:44:44 -05:00 · 2023-12-31 20:35:57 -05:00 · 2023-12-31 17:59:30 -05:00 · 2023-12-21 12:22:55 -05:00 · 2023-12-20 23:17:15 -05:00
169 changed files with 6611 additions and 2817 deletions
@@ -0,0 +1,31 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG] - Problem with app"
+labels: bug
+assignees: zaneschepke
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - Android Version: [e.g. iOS8.1]
+ - App Version [e.g. 22]
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots (Only if necessary)**
+
+**Additional context**
+Add any other context about the problem here.
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEATURE] - New feature request"
+labels: enhancement
+assignees: zaneschepke
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
@@ -0,0 +1,17 @@
+# Support
+
+If you are experiencing issues with the app, the following resources are available to help you. 
+
+<ol>
+  <li>
+    See the app docs site <a href="https://zaneschepke.com/wgtunnel-docs/overview.html">here</a> (work in progress).
+  </li>
+  <li>
+    Chat with me and our community on Discord <a href="https://discord.gg/rbRRNh6H7V">here</a>, or open an issue on GitHub <a href="https://github.com/zaneschepke/wgtunnel/issues/new/choose">here</a>.
+  </li>
+  <li>
+    Send me an email <a href="mailto:zanecschepke@gmail.com">here</a>.
+  </li>
+</ol>
+
+Thank you for using WG Tunnel.
@@ -0,0 +1,87 @@
+# name of the workflow
+name: Android CI Tag Deployment
+
+on:
+  push:
+    tags:
+      - '*.*.*'
+
+jobs:
+  build:
+    name: Build Signed APK
+    # change to macos because of hilt issues on ubuntu in gradle 8.3
+    runs-on: ubuntu-latest
+
+    env:
+      KEY_STORE_PATH: ${{ secrets.KEY_STORE_PATH }}
+      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
+      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
+      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: gradle
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      # Here we need to decode keystore.jks from base64 string and place it
+      # in the folder specified in the release signing configuration
+      - name: Decode Keystore
+        id: decode_keystore
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: 'android_keystore.jks'
+          fileDir: ${{ github.workspace }}/app/keystore/
+          encodedString: ${{ secrets.KEYSTORE }}
+
+      - name: Create service_account.json
+        id: createServiceAccount
+        run: echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
+
+      # Build and sign APK ("-x test" argument is used to skip tests)
+      # add fdroid flavor for apk upload
+      - name: Build Fdroid Release APK
+        run: ./gradlew :app:assembleFdroidRelease -x test
+
+      # get fdroid flavor release apk path
+      - name: Get apk path
+        id: apk-path
+        run: echo "path=$(find . -regex '^.*/build/outputs/apk/fdroid/release/.*\.apk$' -type f | head -1)" >> $GITHUB_OUTPUT
+
+      # Save the APK after the Build job is complete to publish it as a Github release in the next job
+      - name: Upload APK
+        uses: actions/upload-artifact@v3.1.2
+        with:
+          name: wgtunnel
+          path: ${{ steps.apk-path.outputs.path }}
+      - name: Download APK from build
+        uses: actions/download-artifact@v1
+        with:
+          name: wgtunnel
+      - name: Create Release with Fastlane changelog notes
+        id: create_release
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          # fix hardcode changelog file name
+          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/33200.txt
+          tag_name: ${{ github.ref_name }}
+          name: Release ${{ github.ref_name }}
+          draft: false
+          prerelease: false
+          files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
+      - name: Deploy with fastlane
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2' # Not needed with a .ruby-version file
+          bundler-cache: true
+
+      - name: Distribute app to Beta track 🚀
+        run: (cd ${{ github.workspace }} && bundle install && bundle exec fastlane beta)
+
@@ -69,3 +69,5 @@ lint/tmp/
 # App Specific cases
 app/release/output.json
 .idea/codeStyles/
+# where we keep our signing secrets locally
+app/signing.properties
@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "fastlane"
@@ -2,50 +2,64 @@
 WG Tunnel
 </h1>

-<span align="center">
+<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)

-</span>
+</div>

-<span align="center">
+<div align="center">


 [![Google Play](https://img.shields.io/badge/Google_Play-414141?style=for-the-badge&logo=google-play&logoColor=white)](https://play.google.com/store/apps/details?id=com.zaneschepke.wireguardautotunnel)
+[![Fire TV](https://img.shields.io/badge/fire%20tv-fc3b2d?style=for-the-badge&logo=amazon%20fire%20tv&logoColor=white)](https://www.amazon.com/gp/product/B0CFGGL7WK)
+[![F-Droid](https://img.shields.io/static/v1?style=for-the-badge&message=F-Droid&color=1976D2&logo=F-Droid&logoColor=FFFFFF&label=)](https://f-droid.org/packages/com.zaneschepke.wireguardautotunnel/)

-</span>

-<span align="left">
+</div>
+
+<div align="center">
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/N4N8NMJN2)
+
+</div>
+
+
+<div align="left">

 This is an alternative Android Application for [WireGuard](https://www.wireguard.com/) with added features. Built using the [wireguard-android](https://github.com/WireGuard/wireguard-android) library and [Jetpack Compose](https://developer.android.com/jetpack/compose), this application was inspired by the official [WireGuard Android](https://github.com/WireGuard/wireguard-android) app.

-</span>
+</div>

-<span align="center">
+<div align="center">

 ## Screenshots

 <p float="center">
  <img label="Main" style="padding-right:25px" src="asset/main_screen.png" width="200" />
-  <img label="Config" style="padding-left:25px" src="./asset/config_screen.png" width="200" />
-  <img label="Settings" style="padding-left:25px" src="./asset/settings_screen.png" width="200" />
-  <img label="Support" style="padding-left:25px" src="./asset/support_screen.png" width="200" />
+  <img label="Config" style="padding-left:25px" src="asset/config_screen.png" width="200" />
+  <img label="Settings" style="padding-left:25px" src="asset/settings_screen.png" width="200" />
+  <img label="Support" style="padding-left:25px" src="asset/support_screen.png" width="200" />
 </p>

-<span align="left">
+<div align="left">

 ## Inspiration

-The inspiration for this app came from the inconvenience of constantly having to turn VPN off and on while on different networks. With there being no free solution to this problem, this app was created to meet that need.
+The original inspiration for this app came from the inconvenience of having to manually turn VPN off and on while on different networks. This app was created to offer a free solution to this problem. 

 ## Features

-* Add tunnels via .conf file
+* Add tunnels via .conf file, zip, manual entry, or QR code
 * Auto connect to VPN based on Wi-Fi SSID
-* Split tunneling by application
-* Configurable Trusted Network list 
-* Optional auto connect on mobile data
+* Split tunneling by application with search
+* Always-on VPN for Android support
+* Export tunnels to zip
+* Quick tile support for VPN toggling
+* Static shortcuts support for primary tunnel for automation integration
+* Intent automation support for all tunnels
+* Optional auto connect on mobile data, ethernet
 * Automatic service restart after reboot
 * Service will stay running in background after app has been closed

@@ -55,7 +69,7 @@ The inspiration for this app came from the inconvenience of constantly having to
 ```
 $ git clone https://github.com/zaneschepke/wgtunnel
 $ cd wgtunnel
-$ ./gradlew assembleRelease
+$ ./gradlew assembleDebug
 ```

 </span>
@@ -1,31 +1,33 @@
-val rExtra = rootProject.extra
+import java.util.Properties

 plugins {
-    id("com.android.application")
-    id("org.jetbrains.kotlin.android")
-    kotlin("kapt")
-    id("com.google.dagger.hilt.android")
-    id("com.google.gms.google-services")
-    id("com.google.firebase.crashlytics")
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.hilt.android)
    id("org.jetbrains.kotlin.plugin.serialization")
-    id("io.objectbox")
+    alias(libs.plugins.ksp)
 }

 android {
-    namespace = "com.zaneschepke.wireguardautotunnel"
-    compileSdk = 34
-
-    val versionMajor = 2
-    val versionMinor = 1
-    val versionPatch = 4
-    val versionBuild = 0
+    namespace = Constants.APP_ID
+    compileSdk = Constants.TARGET_SDK

    defaultConfig {
-        applicationId = "com.zaneschepke.wireguardautotunnel"
-        minSdk = 29
-        targetSdk = 34
-        versionCode = versionMajor * 10000 + versionMinor * 1000 + versionPatch * 100 + versionBuild
-        versionName = "${versionMajor}.${versionMinor}.${versionPatch}"
+        applicationId = Constants.APP_ID
+        minSdk = Constants.MIN_SDK
+        targetSdk = Constants.TARGET_SDK
+        versionCode = Constants.VERSION_CODE
+        versionName = Constants.VERSION_NAME
+
+        ksp {
+            arg("room.schemaLocation", "$projectDir/schemas")
+        }
+
+        sourceSets {
+            getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
+        }
+
+        resourceConfigurations.addAll(listOf("en"))

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables {
@@ -33,28 +35,98 @@ android {
        }
    }

+    signingConfigs {
+        create(Constants.RELEASE) {
+            val properties =
+                Properties().apply {
+                    // created local file for signing details
+                    try {
+                        load(file("signing.properties").reader())
+                    } catch (_: Exception) {
+                        load(file("signing_template.properties").reader())
+                    }
+                }
+
+            // try to get secrets from env first for pipeline build, then properties file for local build
+            storeFile = file(
+                System.getenv().getOrDefault(
+                    Constants.KEY_STORE_PATH_VAR,
+                    properties.getProperty(Constants.KEY_STORE_PATH_VAR)
+                )
+            )
+            storePassword = System.getenv().getOrDefault(
+                Constants.STORE_PASS_VAR,
+                properties.getProperty(Constants.STORE_PASS_VAR)
+            )
+            keyAlias = System.getenv().getOrDefault(
+                Constants.KEY_ALIAS_VAR,
+                properties.getProperty(Constants.KEY_ALIAS_VAR)
+            )
+            keyPassword = System.getenv().getOrDefault(
+                Constants.KEY_PASS_VAR,
+                properties.getProperty(Constants.KEY_PASS_VAR)
+            )
+        }
+    }
+
    buildTypes {
+        // don't strip
+        packaging.jniLibs.keepDebugSymbols.addAll(
+            listOf("libwg-go.so", "libwg-quick.so", "libwg.so")
+        )
+
+        applicationVariants.all {
+            val variant = this
+            variant.outputs
+                .map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
+                .forEach { output ->
+                    val outputFileName =
+                        "${Constants.APP_NAME}-${variant.flavorName}-${variant.buildType.name}-${variant.versionName}.apk"
+                    output.outputFileName = outputFileName
+                }
+        }
        release {
            isDebuggable = false
-            isMinifyEnabled = false
+            isMinifyEnabled = true
+            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
+            signingConfig = signingConfigs.getByName(Constants.RELEASE)
+        }
+        debug {
+            isDebuggable = true
+        }
+    }
+    flavorDimensions.add(Constants.TYPE)
+    productFlavors {
+        create("fdroid") {
+            dimension = Constants.TYPE
+            proguardFile("fdroid-rules.pro")
+        }
+        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")
+            }
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
+        isCoreLibraryDesugaringEnabled = true
    }
    kotlinOptions {
-        jvmTarget = "17"
+        jvmTarget = Constants.JVM_TARGET
    }
    buildFeatures {
        compose = true
+        buildConfig = true
    }
    composeOptions {
-        kotlinCompilerExtensionVersion = "1.4.8"
+        kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
    }
    packaging {
        resources {
@@ -63,71 +135,81 @@ android {
    }
 }

+val generalImplementation by configurations
 dependencies {
-    implementation("androidx.core:core-ktx:1.10.1")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.1")
-    implementation("androidx.activity:activity-compose:1.7.2")
-    implementation(platform("androidx.compose:compose-bom:2023.03.00"))
-    implementation("androidx.compose.ui:ui")
-    implementation("androidx.compose.ui:ui-graphics")
-    implementation("androidx.compose.ui:ui-tooling-preview")
-    implementation("androidx.compose.material3:material3:1.1.1")
-    implementation("androidx.appcompat:appcompat:1.6.1")
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    // optional - helpers for implementing LifecycleOwner in a Service
+    implementation(libs.androidx.lifecycle.service)
+    implementation(libs.androidx.activity.compose)
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.compose.ui)
+    implementation(libs.androidx.compose.ui.graphics)
+    implementation(libs.androidx.compose.ui.tooling.preview)
+    implementation(libs.androidx.material3)
+    implementation(libs.androidx.appcompat)

-    testImplementation("junit:junit:4.13.2")
-    androidTestImplementation("androidx.test.ext:junit:1.1.5")
-    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
-    androidTestImplementation(platform("androidx.compose:compose-bom:2023.03.00"))
-    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
-    debugImplementation("androidx.compose.ui:ui-tooling")
-    debugImplementation("androidx.compose.ui:ui-test-manifest")
+    // test
+    testImplementation(libs.junit)
+    testImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    androidTestImplementation(platform(libs.androidx.compose.bom))
+    androidTestImplementation(libs.androidx.compose.ui.test)
+    androidTestImplementation(libs.androidx.room.testing)
+    debugImplementation(libs.androidx.compose.ui.tooling)
+    debugImplementation(libs.androidx.compose.manifest)

-    //wireguard tunnel
-    implementation("com.wireguard.android:tunnel:1.0.20230427")
+    // wg
+    implementation(libs.tunnel)
+    coreLibraryDesugaring(libs.desugar.jdk.libs)

-    //logging
-    implementation("com.jakewharton.timber:timber:5.0.1")
+    // logging
+    implementation(libs.timber)

    // compose navigation
-    implementation("androidx.navigation:navigation-compose:2.6.0")
-    implementation("androidx.hilt:hilt-navigation-compose:1.0.0")
+    implementation(libs.androidx.navigation.compose)
+    implementation(libs.androidx.hilt.navigation.compose)

    // hilt
-    implementation("com.google.dagger:hilt-android:${rExtra.get("hiltVersion")}")
-    kapt("com.google.dagger:hilt-android-compiler:${rExtra.get("hiltVersion")}")
+    implementation(libs.hilt.android)
+    ksp(libs.hilt.android.compiler)

-    //accompanist
-    implementation("com.google.accompanist:accompanist-systemuicontroller:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-permissions:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-flowlayout:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-navigation-animation:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-drawablepainter:${rExtra.get("accompanistVersion")}")
+    // accompanist
+    implementation(libs.accompanist.systemuicontroller)
+    implementation(libs.accompanist.permissions)
+    implementation(libs.accompanist.flowlayout)
+    implementation(libs.accompanist.drawablepainter)

-    //db
-    implementation("io.objectbox:objectbox-kotlin:${rExtra.get("objectBoxVersion")}")
+    // storage
+    implementation(libs.androidx.room.runtime)
+    ksp(libs.androidx.room.compiler)
+    implementation(libs.androidx.room.ktx)
+    implementation(libs.androidx.datastore.preferences)

-    //lifecycle
-    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.6.1")
+    // lifecycle
+    implementation(libs.lifecycle.runtime.compose)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.lifecycle.process)

-    //icons
-    implementation("androidx.compose.material:material-icons-extended:1.4.3")
+    // icons
+    implementation(libs.material.icons.extended)
+    // 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)

-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1")
-
-
-    //firebase crashlytics
-    implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
-    implementation("com.google.firebase:firebase-crashlytics-ktx")
-    implementation("com.google.firebase:firebase-analytics-ktx")
-
-    //barcode scanning
-    implementation("com.google.android.gms:play-services-code-scanner:16.0.0")
-
+    // barcode scanning
+    implementation(libs.zxing.android.embedded)
+    implementation(libs.zxing.core)

+    // bio
+    implementation(libs.androidx.biometric.ktx)

+    // shortcuts
+    implementation(libs.androidx.core)
+    implementation(libs.androidx.core.google.shortcuts)
 }
-
-kapt {
-    correctErrorTypes = true
-}
@@ -0,0 +1,5 @@
+-dontwarn com.google.errorprone.annotations.**
+
+-keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
+    <fields>;
+}
@@ -1,94 +0,0 @@
-{
-  "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
-  "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
-  "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
-  "entities": [
-    {
-      "id": "1:2692736974585027589",
-      "lastPropertyId": "15:5057486545428188436",
-      "name": "TunnelConfig",
-      "properties": [
-        {
-          "id": "1:1985347930017457084",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "12:2409068226744965585",
-          "name": "name",
-          "indexId": "1:4811206443952699137",
-          "type": 9,
-          "flags": 34848
-        },
-        {
-          "id": "13:8987443291286312275",
-          "name": "wgQuick",
-          "type": 9
-        }
-      ],
-      "relations": []
-    },
-    {
-      "id": "2:8887605597748372702",
-      "lastPropertyId": "8:4981008812459251156",
-      "name": "Settings",
-      "properties": [
-        {
-          "id": "1:7485739868216068651",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "2:5814013113141456749",
-          "name": "isAutoTunnelEnabled",
-          "type": 1
-        },
-        {
-          "id": "4:5645665441196906014",
-          "name": "trustedNetworkSSIDs",
-          "type": 30
-        },
-        {
-          "id": "5:4989886999117763881",
-          "name": "isTunnelOnMobileDataEnabled",
-          "type": 1
-        },
-        {
-          "id": "6:3370284381040192129",
-          "name": "defaultTunnel",
-          "type": 9
-        }
-      ],
-      "relations": []
-    }
-  ],
-  "lastEntityId": "2:8887605597748372702",
-  "lastIndexId": "1:4811206443952699137",
-  "lastRelationId": "0:0",
-  "lastSequenceId": "0:0",
-  "modelVersion": 5,
-  "modelVersionParserMinimum": 5,
-  "retiredEntityUids": [],
-  "retiredIndexUids": [],
-  "retiredPropertyUids": [
-    1763475292291320186,
-    6483820955437198310,
-    8323071516033820771,
-    5904440563612311217,
-    1408037976996390989,
-    7737847485212546994,
-    8215616901775229364,
-    8021610768066328637,
-    6174306582797008721,
-    2175939938544485767,
-    7555225587864607050,
-    969146862000617878,
-    5057486545428188436,
-    2814640993034665120,
-    4981008812459251156
-  ],
-  "retiredRelationUids": [],
-  "version": 1
-}
@@ -1,98 +0,0 @@
-{
-  "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
-  "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
-  "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
-  "entities": [
-    {
-      "id": "1:2692736974585027589",
-      "lastPropertyId": "15:5057486545428188436",
-      "name": "TunnelConfig",
-      "properties": [
-        {
-          "id": "1:1985347930017457084",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "12:2409068226744965585",
-          "name": "name",
-          "indexId": "1:4811206443952699137",
-          "type": 9,
-          "flags": 34848
-        },
-        {
-          "id": "13:8987443291286312275",
-          "name": "wgQuick",
-          "type": 9
-        }
-      ],
-      "relations": []
-    },
-    {
-      "id": "2:8887605597748372702",
-      "lastPropertyId": "8:4981008812459251156",
-      "name": "Settings",
-      "properties": [
-        {
-          "id": "1:7485739868216068651",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "2:5814013113141456749",
-          "name": "isAutoTunnelEnabled",
-          "type": 1
-        },
-        {
-          "id": "4:5645665441196906014",
-          "name": "trustedNetworkSSIDs",
-          "type": 30
-        },
-        {
-          "id": "5:4989886999117763881",
-          "name": "isTunnelOnMobileDataEnabled",
-          "type": 1
-        },
-        {
-          "id": "6:3370284381040192129",
-          "name": "defaultTunnel",
-          "type": 9
-        },
-        {
-          "id": "8:4981008812459251156",
-          "name": "showProminentDisclosure",
-          "type": 1
-        }
-      ],
-      "relations": []
-    }
-  ],
-  "lastEntityId": "2:8887605597748372702",
-  "lastIndexId": "1:4811206443952699137",
-  "lastRelationId": "0:0",
-  "lastSequenceId": "0:0",
-  "modelVersion": 5,
-  "modelVersionParserMinimum": 5,
-  "retiredEntityUids": [],
-  "retiredIndexUids": [],
-  "retiredPropertyUids": [
-    1763475292291320186,
-    6483820955437198310,
-    8323071516033820771,
-    5904440563612311217,
-    1408037976996390989,
-    7737847485212546994,
-    8215616901775229364,
-    8021610768066328637,
-    6174306582797008721,
-    2175939938544485767,
-    7555225587864607050,
-    969146862000617878,
-    5057486545428188436,
-    2814640993034665120
-  ],
-  "retiredRelationUids": [],
-  "version": 1
-}
@@ -18,4 +18,9 @@

 # If you keep the line number information, uncomment this to
 # hide the original source file name.
-#-renamesourcefileattribute SourceFile
+#-renamesourcefileattribute SourceFile
+-keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
+    <fields>;
+}
+
+
@@ -0,0 +1,112 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "ba86153e6fb0b823197b987239b03e64",
+    "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)",
+        "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
+          }
+        ],
+        "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, 'ba86153e6fb0b823197b987239b03e64')"
+    ]
+  }
+}
@@ -0,0 +1,126 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "65b1c9efff61712231fa64d1f19f3915",
+    "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)",
+        "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"
+          }
+        ],
+        "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, '65b1c9efff61712231fa64d1f19f3915')"
+    ]
+  }
+}
@@ -0,0 +1,133 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 3,
+    "identityHash": "6b30daba29bb95f8ddc4d26206329d4f",
+    "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)",
+        "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"
+          }
+        ],
+        "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, '6b30daba29bb95f8ddc4d26206329d4f')"
+    ]
+  }
+}
@@ -0,0 +1,154 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 4,
+    "identityHash": "aee55639422df8dadfe74c3bad204477",
+    "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)",
+        "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"
+          }
+        ],
+        "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, 'aee55639422df8dadfe74c3bad204477')"
+    ]
+  }
+}
@@ -0,0 +1,161 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 5,
+    "identityHash": "bc15003a44746e18b9c260ec49737089",
+    "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)",
+        "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"
+          }
+        ],
+        "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, 'bc15003a44746e18b9c260ec49737089')"
+    ]
+  }
+}
@@ -0,0 +1,4 @@
+SIGNING_STORE_PASSWORD=
+SIGNING_KEY_ALIAS=
+SIGNING_KEY_PASSWORD=
+KEY_STORE_PATH=/
@@ -1,13 +1,11 @@
 package com.zaneschepke.wireguardautotunnel

-import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.ext.junit.runners.AndroidJUnit4
-
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.junit.runner.RunWith

-import org.junit.Assert.*
-
 /**
 * Instrumented test, which will execute on an Android device.
 *
@@ -21,4 +19,4 @@ class ExampleInstrumentedTest {
        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
        assertEquals("com.zaneschepke.wireguardautotunnel", appContext.packageName)
    }
-}
+}
@@ -0,0 +1,69 @@
+package com.zaneschepke.wireguardautotunnel
+
+import androidx.room.testing.MigrationTestHelper
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.IOException
+
+@RunWith(AndroidJUnit4::class)
+class MigrationTest {
+    private val dbName = "migration-test"
+
+    @get:Rule
+    val helper: MigrationTestHelper = MigrationTestHelper(
+        InstrumentationRegistry.getInstrumentation(),
+        AppDatabase::class.java
+    )
+
+    @Test
+    @Throws(IOException::class)
+    fun migrate4To5() {
+        helper.createDatabase(dbName, 4).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(
+                "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," +
+                        "is_multi_tunnel_enabled)" +
+                        " VALUES " +
+                        "('false'," +
+                        "'false'," +
+                        "'[trustedSSID1,trustedSSID2]'," +
+                        "'defaultTunnel'," +
+                        "'false'," +
+                        "'false'," +
+                        "'false'," +
+                        "'false'," +
+                        "'false'," +
+                        "'false'," +
+                        "'false'," +
+                        "'false')"
+            )
+            execSQL(
+                "INSERT INTO TunnelConfig (name, wg_quick)" +
+                        " VALUES ('hello', 'hello')"
+            )
+            // Prepare for the next version.
+            close()
+        }
+
+        // Re-open the database with version 2 and provide
+        // MIGRATION_1_2 as the migration process.
+        helper.runMigrationsAndValidate(dbName, 5, true)
+        // MigrationTestHelper automatically verifies the schema changes,
+        // but you need to validate that the data was migrated properly.
+    }
+}
@@ -4,21 +4,40 @@
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
        android:maxSdkVersion="32" />
+    <uses-permission
+        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="32"
+        tools:ignore="ScopedStorage" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"
-        android:maxSdkVersion="30" />
+        android:maxSdkVersion="30"
+        tools:ignore="LeanbackUsesWifi" />
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING"/>
+    <!--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" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <!--start service on boot permission-->
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
+    <!--android tv support-->
+    <uses-feature android:name="android.software.leanback"
+        android:required="false" />
+    <uses-feature android:name="android.hardware.touchscreen"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.location.gps"
+        android:required="false" />
+    <uses-feature
+    android:name="android.hardware.screen.portrait"
+    android:required="false" />
    <queries>
        <intent>
            <action android:name="android.intent.action.MAIN" />
@@ -26,15 +45,17 @@
    </queries>
    <application
        android:allowBackup="true"
+        android:enableOnBackInvokedCallback="true"
        android:name=".WireGuardAutoTunnel"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
+        android:banner="@mipmap/ic_banner"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.WireguardAutoTunnel"
-        tools:targetApi="31">
+        tools:targetApi="tiramisu">
        <activity
            android:name=".ui.MainActivity"
            android:exported="true"
@@ -42,40 +63,78 @@
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
+                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
+                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES"/>
            </intent-filter>
+            <meta-data android:name="android.app.shortcuts"
+                android:resource="@xml/shortcuts" />
        </activity>
+        <activity
+            android:name=".ui.CaptureActivityPortrait"
+            android:screenOrientation="fullSensor"
+            android:stateNotNeeded="true"
+            android:theme="@style/zxing_CaptureTheme"
+            android:windowSoftInputMode="stateAlwaysHidden" />
+        <activity
+            android:finishOnTaskLaunch="true"
+            android:enabled="true"
+            android:exported="true"
+            android:theme="@android:style/Theme.NoDisplay"
+            android:name=".service.shortcut.ShortcutsActivity"/>
        <service
            android:name=".service.foreground.ForegroundService"
            android:enabled="true"
-            android:foregroundServiceType="remoteMessaging"
+            android:foregroundServiceType="systemExempted|specialUse"
+            tools:node="merge"
            android:exported="false">
        </service>
+        <service
+            android:exported="true"
+            android:name=".service.tile.TunnelControlTile"
+            android:icon="@drawable/shield"
+            android:label="WG Tunnel"
+            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.foreground.WireGuardTunnelService"
+            android:permission="android.permission.BIND_VPN_SERVICE"
            android:enabled="true"
-            android:foregroundServiceType="remoteMessaging"
+            android:persistent="true"
+            android:foregroundServiceType="systemExempted|specialUse"
+            tools:node="merge"
            android:exported="false">
+            <intent-filter>
+                <action android:name="android.net.VpnService"/>
+            </intent-filter>
+            <meta-data android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
+                android:value="true" />
        </service>
        <service
            android:name=".service.foreground.WireGuardConnectivityWatcherService"
            android:enabled="true"
            android:stopWithTask="false"
-            android:foregroundServiceType="location"
-            android:permission=""
+            android:persistent="true"
+            android:foregroundServiceType="systemExempted|specialUse"
+            tools:node="merge"
            android:exported="false">
        </service>
        <receiver android:enabled="true" android:name=".receiver.BootReceiver"
-            android:exported="true">
+            android:exported="false">
            <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED"/>
+                <category android:name="android.intent.category.DEFAULT" />
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <action android:name="android.intent.action.ACTION_BOOT_COMPLETED" />
+                <action android:name="android.intent.action.QUICKBOOT_POWERON" />
+                <action android:name="com.htc.intent.action.QUICKBOOT_POWERON" />
            </intent-filter>
        </receiver>
        <receiver android:exported="false" android:name=".receiver.NotificationActionReceiver"/>
-        <meta-data
-            android:name="com.google.mlkit.vision.DEPENDENCIES"
-            android:value="barcode_ui"/>
-        <meta-data
-            android:name="firebase_crashlytics_collection_enabled"
-            android:value="true" />
    </application>
 </manifest>
@@ -1,25 +1,64 @@
 package com.zaneschepke.wireguardautotunnel

 import android.app.Application
-import com.google.firebase.crashlytics.FirebaseCrashlytics
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
+import android.content.ComponentName
+import android.content.pm.PackageManager
+import android.service.quicksettings.TileService
+import androidx.lifecycle.ProcessLifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.launch
 import timber.log.Timber
+import java.io.IOException
 import javax.inject.Inject

@HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
+    @Inject
+    lateinit var settingsRepository: SettingsRepository

    @Inject
-    lateinit var settingsRepo : Repository<Settings>
+    lateinit var dataStoreManager: DataStoreManager

    override fun onCreate() {
        super.onCreate()
-        if(BuildConfig.DEBUG) {
-            FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(false);
-            Timber.plant(Timber.DebugTree())
+        instance = this
+        if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree())
+        initSettings()
+        with(ProcessLifecycleOwner.get()) {
+            lifecycleScope.launch {
+                try {
+                    // load preferences into memory
+                    dataStoreManager.init()
+                    requestTileServiceStateUpdate()
+                } catch (e: IOException) {
+                    Timber.e("Failed to load preferences")
+                }
+            }
        }
-        settingsRepo.init()
    }
-}
+
+    private fun initSettings() {
+        with(ProcessLifecycleOwner.get()) {
+            lifecycleScope.launch {
+                if (settingsRepository.getAll().isEmpty()) {
+                    settingsRepository.save(Settings())
+                }
+            }
+        }
+    }
+
+    companion object {
+        lateinit var instance: WireGuardAutoTunnel private set
+        fun isRunningOnAndroidTv(): Boolean {
+            return instance.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
+        }
+        fun requestTileServiceStateUpdate() {
+            TileService.requestListeningState(instance, ComponentName(instance, TunnelControlTile::class.java))
+        }
+    }
+}
@@ -0,0 +1,29 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.AutoMigration
+import androidx.room.Database
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+
+@Database(
+    entities = [Settings::class, TunnelConfig::class],
+    version = 5,
+    autoMigrations = [
+        AutoMigration(from = 1, to = 2), AutoMigration(from = 2, to = 3), AutoMigration(
+            from = 3,
+            to = 4
+        ),AutoMigration(
+            from = 4,
+            to = 5
+        )
+    ],
+    exportSchema = true
+)
+@TypeConverters(DatabaseListConverters::class)
+abstract class AppDatabase : RoomDatabase() {
+    abstract fun settingDao(): SettingsDao
+
+    abstract fun tunnelConfigDoa(): TunnelConfigDao
+}
@@ -0,0 +1,24 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.TypeConverter
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+class DatabaseListConverters {
+    @TypeConverter
+    fun listToString(value: MutableList<String>): String {
+        return Json.encodeToString(value)
+    }
+
+    @TypeConverter
+    fun stringToList(value: String): MutableList<String> {
+        if (value.isEmpty()) return mutableListOf()
+        return try {
+            Json.decodeFromString<MutableList<String>>(value)
+        } catch (e: Exception) {
+            val list = value.split(",").toMutableList()
+            val json = listToString(list)
+            Json.decodeFromString<MutableList<String>>(json)
+        }
+    }
+}
@@ -0,0 +1,36 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface SettingsDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun save(t: 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")
+    suspend fun getAll(): List<Settings>
+
+    @Query("SELECT * FROM settings LIMIT 1")
+    fun getSettingsFlow(): Flow<Settings>
+
+    @Query("SELECT * FROM settings")
+    fun getAllFlow(): Flow<MutableList<Settings>>
+
+    @Delete
+    suspend fun delete(t: Settings)
+
+    @Query("SELECT COUNT('id') FROM settings")
+    suspend fun count(): Long
+}
@@ -0,0 +1,33 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface TunnelConfigDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun save(t: TunnelConfig)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun saveAll(t: List<TunnelConfig>)
+
+    @Query("SELECT * FROM TunnelConfig WHERE id=:id")
+    suspend fun getById(id: Long): TunnelConfig?
+
+    @Query("SELECT * FROM TunnelConfig")
+    suspend fun getAll(): List<TunnelConfig>
+
+    @Delete
+    suspend fun delete(t: TunnelConfig)
+
+    @Query("SELECT COUNT('id') FROM TunnelConfig")
+    suspend fun count(): Long
+
+    @Query("SELECT * FROM tunnelconfig")
+    fun getAllFlow(): Flow<MutableList<TunnelConfig>>
+}
@@ -0,0 +1,39 @@
+package com.zaneschepke.wireguardautotunnel.data.datastore
+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.preferencesDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+
+class DataStoreManager(private val context: Context) {
+    companion object {
+        val LOCATION_DISCLOSURE_SHOWN = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
+    }
+
+    // preferences
+    private val preferencesKey = "preferences"
+    private val Context.dataStore by preferencesDataStore(
+        name = preferencesKey
+    )
+
+    suspend fun init() {
+        context.dataStore.data.first()
+    }
+
+    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]
+
+    val locationDisclosureFlow: Flow<Boolean?> = context.dataStore.data.map {
+        it[LOCATION_DISCLOSURE_SHOWN]
+    }
+}
@@ -0,0 +1,53 @@
+package com.zaneschepke.wireguardautotunnel.data.model
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+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_on_mobile_data_enabled") var 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,
+    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled") var 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,
+    @ColumnInfo(
+        name = "is_tunnel_on_wifi_enabled",
+        defaultValue = "false"
+    ) var isTunnelOnWifiEnabled: Boolean = false,
+    @ColumnInfo(
+        name = "is_kernel_enabled",
+        defaultValue = "false"
+    ) var isKernelEnabled: Boolean = false,
+    @ColumnInfo(
+    name = "is_restore_on_boot_enabled",
+    defaultValue = "false"
+    ) var isRestoreOnBootEnabled: Boolean = false,
+    @ColumnInfo(
+    name = "is_multi_tunnel_enabled",
+    defaultValue = "false"
+    ) var 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
+        }
+    }
+}
@@ -0,0 +1,34 @@
+package com.zaneschepke.wireguardautotunnel.data.model
+
+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 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
+) {
+    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)
+            return Config.parse(reader)
+        }
+    }
+}
@@ -0,0 +1,12 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import kotlinx.coroutines.flow.Flow
+
+interface SettingsRepository {
+    suspend fun save(settings : Settings)
+    fun getSettingsFlow() : Flow<Settings>
+
+    suspend fun getSettings() : Settings
+    suspend fun getAll() : List<Settings>
+}
@@ -0,0 +1,24 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+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 {
+
+    override suspend fun save(settings: Settings) {
+        settingsDoa.save(settings)
+    }
+
+    override fun getSettingsFlow(): Flow<Settings> {
+        return settingsDoa.getSettingsFlow()
+    }
+
+    override suspend fun getSettings(): Settings {
+        return settingsDoa.getAll().firstOrNull() ?: Settings()
+    }
+
+    override suspend fun getAll(): List<Settings> {
+        return settingsDoa.getAll()
+    }
+}
@@ -0,0 +1,14 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import kotlinx.coroutines.flow.Flow
+
+interface TunnelConfigRepository {
+
+    fun getTunnelConfigsFlow() : Flow<TunnelConfigs>
+    suspend fun getAll() : TunnelConfigs
+    suspend fun save(tunnelConfig: TunnelConfig)
+    suspend fun delete(tunnelConfig: TunnelConfig)
+    suspend fun count() : Int
+}
@@ -0,0 +1,28 @@
+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()
+    }
+}
@@ -1,40 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.module
-
-import android.content.Context
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.MyObjectBox
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-class BoxModule {
-
-    @Provides
-    @Singleton
-    fun provideBoxStore(@ApplicationContext context : Context) : BoxStore {
-        return MyObjectBox.builder()
-            .androidContext(context.applicationContext)
-            .build()
-    }
-
-    @Provides
-    @Singleton
-    fun provideBoxForSettings(store : BoxStore) : Box<Settings> {
-        return store.boxFor(Settings::class.java)
-    }
-
-    @Provides
-    @Singleton
-    fun provideBoxForTunnels(store : BoxStore) : Box<TunnelConfig> {
-        return store.boxFor(TunnelConfig::class.java)
-    }
-
-}
@@ -0,0 +1,30 @@
+package com.zaneschepke.wireguardautotunnel.module
+
+import android.content.Context
+import androidx.room.Room
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+class DatabaseModule {
+    @Provides
+    @Singleton
+    fun provideDatabase(
+        @ApplicationContext context: Context
+    ): AppDatabase {
+        return Room.databaseBuilder(
+            context,
+            AppDatabase::class.java,
+            context.getString(R.string.db_name)
+        )
+            .fallbackToDestructiveMigration()
+            .build()
+    }
+}
@@ -0,0 +1,7 @@
+package com.zaneschepke.wireguardautotunnel.module
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class Kernel
@@ -1,25 +1,51 @@
 package com.zaneschepke.wireguardautotunnel.module

-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.repository.SettingsBox
-import com.zaneschepke.wireguardautotunnel.repository.TunnelBox
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import dagger.Binds
+import android.content.Context
+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.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
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import javax.inject.Singleton

@Module
@InstallIn(SingletonComponent::class)
-abstract class RepositoryModule {
-
-    @Binds
+class RepositoryModule {
    @Singleton
-    abstract fun provideSettingsRepository(settingsBox: SettingsBox) : Repository<Settings>
+    @Provides
+    fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
+        return appDatabase.settingDao()
+    }

-    @Binds
    @Singleton
-    abstract fun provideTunnelRepository(tunnelBox: TunnelBox) : Repository<TunnelConfig>
-}
+    @Provides
+    fun provideTunnelConfigDoa(appDatabase: AppDatabase): TunnelConfigDao {
+        return appDatabase.tunnelConfigDoa()
+    }
+
+    @Singleton
+    @Provides
+    fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao): TunnelConfigRepository {
+        return TunnelConfigRepositoryImpl(tunnelConfigDao)
+    }
+
+    @Singleton
+    @Provides
+    fun provideSettingsRepository(settingsDao: SettingsDao): SettingsRepository {
+        return SettingsRepositoryImpl(settingsDao)
+    }
+
+    @Singleton
+    @Provides
+    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStoreManager {
+        return DataStoreManager(context)
+    }
+}
@@ -1,41 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.module
-
-import android.content.Context
-import com.google.mlkit.vision.barcode.common.Barcode
-import com.google.mlkit.vision.codescanner.GmsBarcodeScanner
-import com.google.mlkit.vision.codescanner.GmsBarcodeScannerOptions
-import com.google.mlkit.vision.codescanner.GmsBarcodeScanning
-import com.zaneschepke.wireguardautotunnel.service.barcode.CodeScanner
-import com.zaneschepke.wireguardautotunnel.service.barcode.QRScanner
-import dagger.Binds
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.components.ViewModelComponent
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.android.scopes.ViewModelScoped
-
-@Module
-@InstallIn(ViewModelComponent::class)
-class ScannerModule {
-
-    @ViewModelScoped
-    @Provides
-    fun provideBarCodeOptions() : GmsBarcodeScannerOptions {
-        return GmsBarcodeScannerOptions.Builder()
-            .setBarcodeFormats(Barcode.FORMAT_QR_CODE)
-            .build()
-    }
-
-    @ViewModelScoped
-    @Provides
-    fun provideBarCodeScanner(@ApplicationContext context: Context, options: GmsBarcodeScannerOptions) : GmsBarcodeScanner {
-        return GmsBarcodeScanning.getClient(context, options)
-    }
-
-    @ViewModelScoped
-    @Provides
-    fun provideQRScanner(gmsBarcodeScanner: GmsBarcodeScanner) : CodeScanner {
-        return QRScanner(gmsBarcodeScanner)
-    }
-}
@@ -1,7 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.module

-import com.zaneschepke.wireguardautotunnel.service.barcode.CodeScanner
-import com.zaneschepke.wireguardautotunnel.service.barcode.QRScanner
+import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
 import com.zaneschepke.wireguardautotunnel.service.network.WifiService
@@ -12,21 +11,23 @@ import dagger.Module
 import dagger.hilt.InstallIn
 import dagger.hilt.android.components.ServiceComponent
 import dagger.hilt.android.scopes.ServiceScoped
-import dagger.hilt.android.scopes.ViewModelScoped

@Module
@InstallIn(ServiceComponent::class)
 abstract class ServiceModule {
+    @Binds
+    @ServiceScoped
+    abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification): NotificationService

    @Binds
    @ServiceScoped
-    abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification) : NotificationService
+    abstract fun provideWifiService(wifiService: WifiService): NetworkService<WifiService>

    @Binds
    @ServiceScoped
-    abstract fun provideWifiService(wifiService: WifiService) : NetworkService<WifiService>
+    abstract fun provideMobileDataService(mobileDataService: MobileDataService): NetworkService<MobileDataService>

    @Binds
    @ServiceScoped
-    abstract fun provideMobileDataService(mobileDataService : MobileDataService) : NetworkService<MobileDataService>
-}
+    abstract fun provideEthernetService(ethernetService: EthernetService): NetworkService<EthernetService>
+}
@@ -3,6 +3,10 @@ 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.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
@@ -15,17 +19,40 @@ import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
 class TunnelModule {
+    @Provides
+    @Singleton
+    fun provideRootShell(
+        @ApplicationContext context: Context
+    ): RootShell {
+        return RootShell(context)
+    }

    @Provides
    @Singleton
-    fun provideBackend(@ApplicationContext context : Context) : Backend {
+    @Userspace
+    fun provideUserspaceBackend(
+        @ApplicationContext context: Context
+    ): Backend {
        return GoBackend(context)
    }

    @Provides
    @Singleton
-    fun provideVpnService(backend: Backend) : VpnService {
-        return WireGuardTunnel(backend)
+    @Kernel
+    fun provideKernelBackend(
+        @ApplicationContext context: Context,
+        rootShell: RootShell
+    ): Backend {
+        return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
    }

-}
+    @Provides
+    @Singleton
+    fun provideVpnService(
+        @Userspace userspaceBackend: Backend,
+        @Kernel kernelBackend: Backend,
+        settingsRepository : SettingsRepository
+    ): VpnService {
+        return WireGuardTunnel(userspaceBackend, kernelBackend, settingsRepository)
+    }
+}
@@ -0,0 +1,7 @@
+package com.zaneschepke.wireguardautotunnel.module
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class Userspace
@@ -3,46 +3,23 @@ package com.zaneschepke.wireguardautotunnel.receiver
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.foreground.Action
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceTracker
-import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardConnectivityWatcherService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.launch
 import javax.inject.Inject

+
@AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {

    @Inject
-    lateinit var settingsRepo : Repository<Settings>
-
-    override fun onReceive(context: Context, intent: Intent) {
-        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
-            CoroutineScope(SupervisorJob()).launch {
-                try {
-                    val settings = settingsRepo.getAll()
-                    if (!settings.isNullOrEmpty()) {
-                        val setting = settings.first()
-                        if (setting.isAutoTunnelEnabled && setting.defaultTunnel != null) {
-                            ServiceTracker.actionOnService(
-                                Action.START, context,
-                                WireGuardConnectivityWatcherService::class.java,
-                                mapOf(context.resources.getString(R.string.tunnel_extras_key) to
-                                setting.defaultTunnel!!)
-                            )
-                        }
-                    }
-                } finally {
-                    cancel()
-                }
-            }
+    lateinit var settingsRepository: SettingsRepository
+    override fun onReceive(context: Context?, intent: Intent?) = goAsync {
+        if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return@goAsync
+        if(settingsRepository.getSettings().isAutoTunnelEnabled) {
+            ServiceManager.startWatcherServiceForeground(context!!)
        }
    }
-}
+
+}
@@ -3,54 +3,33 @@ package com.zaneschepke.wireguardautotunnel.receiver
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.foreground.Action
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceTracker
-import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import javax.inject.Inject

@AndroidEntryPoint
 class NotificationActionReceiver : BroadcastReceiver() {
-
    @Inject
-    lateinit var settingsRepo : Repository<Settings>
-    override fun onReceive(context: Context, intent: Intent?) {
-        CoroutineScope(SupervisorJob()).launch {
-            try {
-                val settings = settingsRepo.getAll()
-                if (!settings.isNullOrEmpty()) {
-                    val setting = settings.first()
-                    if (setting.defaultTunnel != null) {
-                        ServiceTracker.actionOnService(
-                            Action.STOP, context,
-                            WireGuardTunnelService::class.java,
-                            mapOf(
-                                context.resources.getString(R.string.tunnel_extras_key) to
-                                        setting.defaultTunnel!!
-                            )
-                        )
-                        delay(1000)
-                        ServiceTracker.actionOnService(
-                            Action.START, context,
-                            WireGuardTunnelService::class.java,
-                            mapOf(
-                                context.resources.getString(R.string.tunnel_extras_key) to
-                                        setting.defaultTunnel!!
-                            )
-                        )
-                    }
-                }
-            } finally {
-                cancel()
+    lateinit var settingsRepository: SettingsRepository
+
+    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())
            }
+        } finally {
+            cancel()
        }
    }
-}
+}
@@ -1,16 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.repository
-
-import kotlinx.coroutines.flow.Flow
-
-interface Repository<T> {
-    suspend fun save(t : T)
-    suspend fun saveAll(t : List<T>)
-    suspend fun getById(id : Long) : T?
-    suspend fun getAll() : List<T>?
-    suspend fun delete(t : T) : Boolean?
-    suspend fun count() : Long?
-
-    val itemFlow : Flow<MutableList<T>>
-
-    fun init()
-}
@@ -1,63 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.repository
-
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import io.objectbox.kotlin.awaitCallInTx
-import io.objectbox.kotlin.toFlow
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-
-class SettingsBox @Inject constructor(private val box : Box<Settings>, private val boxStore : BoxStore) : Repository<Settings> {
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    override val itemFlow = box.query().build().subscribe().toFlow()
-
-    override fun init() {
-        CoroutineScope(Dispatchers.IO).launch {
-            if(getAll().isNullOrEmpty()) {
-                save(Settings())
-            }
-        }
-    }
-
-    override suspend fun save(t : Settings) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun saveAll(t : List<Settings>) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun getById(id: Long): Settings? {
-        return boxStore.awaitCallInTx {
-            box[id]
-        }
-    }
-
-    override suspend fun getAll(): List<Settings>? {
-        return boxStore.awaitCallInTx {
-            box.all
-        }
-    }
-
-    override suspend fun delete(t : Settings): Boolean? {
-        return boxStore.awaitCallInTx {
-            box.remove(t)
-        }
-    }
-
-    override suspend fun count() : Long? {
-        return boxStore.awaitCallInTx {
-            box.count()
-        }
-    }
-}
@@ -1,57 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.repository
-
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import io.objectbox.kotlin.awaitCallInTx
-import io.objectbox.kotlin.toFlow
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import timber.log.Timber
-import javax.inject.Inject
-
-class TunnelBox @Inject constructor(private val box : Box<TunnelConfig>,private val boxStore : BoxStore) : Repository<TunnelConfig> {
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    override val itemFlow = box.query().build().subscribe().toFlow()
-    override fun init() {
-
-    }
-
-    override suspend fun save(t : TunnelConfig) {
-        Timber.d("Saving tunnel config")
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-
-    }
-
-    override suspend fun saveAll(t : List<TunnelConfig>) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun getById(id: Long): TunnelConfig? {
-       return boxStore.awaitCallInTx {
-            box[id]
-        }
-    }
-
-    override suspend fun getAll(): List<TunnelConfig>? {
-        return boxStore.awaitCallInTx {
-            box.all
-        }
-    }
-
-    override suspend fun delete(t : TunnelConfig): Boolean? {
-        return boxStore.awaitCallInTx {
-            box.remove(t)
-        }
-    }
-
-    override suspend fun count() : Long? {
-        return boxStore.awaitCallInTx {
-            box.count()
-        }
-    }
-}
@@ -1,7 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.barcode
-
-import kotlinx.coroutines.flow.Flow
-
-interface CodeScanner {
-    fun scan() : Flow<String?>
-}
@@ -1,23 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.barcode
-
-import com.google.mlkit.vision.codescanner.GmsBarcodeScanner
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import timber.log.Timber
-import javax.inject.Inject
-
-class QRScanner @Inject constructor(private val gmsBarcodeScanner: GmsBarcodeScanner) : CodeScanner {
-    override fun scan(): Flow<String?> {
-        return callbackFlow {
-            gmsBarcodeScanner.startScan().addOnSuccessListener {
-                trySend(it.rawValue)
-            }.addOnFailureListener {
-                trySend(it.message)
-                Timber.e(it.message)
-            }
-            awaitClose {
-            }
-        }
-    }
-}
@@ -2,5 +2,6 @@ package com.zaneschepke.wireguardautotunnel.service.foreground

 enum class Action {
    START,
+    START_FOREGROUND,
    STOP
-}
+}
@@ -1,29 +1,37 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground

-import android.app.Service
 import android.content.Intent
 import android.os.Bundle
 import android.os.IBinder
+import androidx.lifecycle.LifecycleService
 import timber.log.Timber

-
-open class ForegroundService : Service() {
-
+open class ForegroundService : LifecycleService() {
    private var isServiceStarted = false

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

-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    override fun onStartCommand(
+        intent: Intent?,
+        flags: Int,
+        startId: Int
+    ): Int {
+        super.onStartCommand(intent, flags, startId)
        Timber.d("onStartCommand executed with startId: $startId")
        if (intent != null) {
            val action = intent.action
            Timber.d("using an intent with action $action")
            when (action) {
-                Action.START.name -> startService(intent.extras)
+                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")
+                    startService(intent.extras)
+                }
                else -> Timber.d("This should never happen. No action in the received intent")
            }
        } else {
@@ -35,19 +43,18 @@ open class ForegroundService : Service() {
        return START_STICKY
    }

-
    override fun onDestroy() {
        super.onDestroy()
        Timber.d("The service has been destroyed")
    }

-    protected open fun startService(extras : Bundle?) {
+    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(extras: Bundle?) {
        Timber.d("Stopping ${this.javaClass.simpleName}")
        try {
            stopForeground(STOP_FOREGROUND_REMOVE)
@@ -57,4 +64,4 @@ open class ForegroundService : Service() {
        }
        isServiceStarted = false
    }
-}
+}
@@ -0,0 +1,119 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import android.app.ActivityManager
+import android.app.Service
+import android.content.Context
+import android.content.Context.ACTIVITY_SERVICE
+import android.content.Intent
+import com.zaneschepke.wireguardautotunnel.R
+import timber.log.Timber
+
+object ServiceManager {
+    @Suppress("DEPRECATION")
+    private // Deprecated for third party Services.
+    fun <T> Context.isServiceRunning(service: Class<T>) =
+        (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
+            .getRunningServices(Integer.MAX_VALUE)
+            .any { it.service.className == 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
+    }
+
+    private fun <T : Service> actionOnService(
+        action: Action,
+        context: Context,
+        cls: Class<T>,
+        extras: Map<String, String>? = null
+    ) {
+        if (getServiceState(context, cls) == ServiceState.STOPPED && action == Action.STOP) return
+        if (getServiceState(context, cls) == ServiceState.STARTED && action == Action.START) return
+        val intent =
+            Intent(context, cls).also {
+                it.action = action.name
+                extras?.forEach { (k, v) ->
+                    it.putExtra(k, v)
+                }
+            }
+        intent.component?.javaClass
+        try {
+            when (action) {
+                Action.START_FOREGROUND -> {
+                    context.startForegroundService(intent)
+                }
+
+                Action.START -> {
+                    context.startService(intent)
+                }
+
+                Action.STOP -> context.startService(intent)
+            }
+        } catch (e: Exception) {
+            Timber.e(e.message)
+        }
+    }
+
+    fun startVpnService(
+        context: Context,
+        tunnelConfig: String
+    ) {
+        actionOnService(
+            Action.START,
+            context,
+            WireGuardTunnelService::class.java,
+            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig)
+        )
+    }
+
+    fun stopVpnService(context: Context) {
+        actionOnService(
+            Action.STOP,
+            context,
+            WireGuardTunnelService::class.java
+        )
+    }
+
+    fun startVpnServiceForeground(
+        context: Context,
+        tunnelConfig: String
+    ) {
+        actionOnService(
+            Action.START_FOREGROUND,
+            context,
+            WireGuardTunnelService::class.java,
+            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig)
+        )
+    }
+
+    fun startWatcherServiceForeground(
+        context: Context,
+    ) {
+        actionOnService(
+            Action.START_FOREGROUND,
+            context,
+            WireGuardConnectivityWatcherService::class.java
+        )
+    }
+
+    fun startWatcherService(
+        context: Context
+    ) {
+        actionOnService(
+            Action.START,
+            context,
+            WireGuardConnectivityWatcherService::class.java
+        )
+    }
+
+    fun stopWatcherService(context: Context) {
+        actionOnService(
+            Action.STOP,
+            context,
+            WireGuardConnectivityWatcherService::class.java
+        )
+    }
+}
@@ -3,4 +3,4 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 enum class ServiceState {
    STARTED,
    STOPPED,
-}
+}
@@ -1,56 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import android.app.ActivityManager
-import android.app.Application
-import android.app.Service
-import android.content.Context
-import android.content.Context.ACTIVITY_SERVICE
-import android.content.Intent
-import com.google.firebase.crashlytics.ktx.crashlytics
-import com.google.firebase.ktx.Firebase
-
-object ServiceTracker {
-    @Suppress("DEPRECATION")
-    private // Deprecated for third party Services.
-    fun <T> Context.isServiceRunning(service: Class<T>) =
-        (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
-            .getRunningServices(Integer.MAX_VALUE)
-            .any { it.service.className == 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
-    }
-
-    fun <T : Service> actionOnService(action: Action, application: Application, cls : Class<T>, extras : Map<String,String>? = null) {
-        if (getServiceState(application, cls) == ServiceState.STOPPED && action == Action.STOP) return
-        val intent = Intent(application, cls).also {
-            it.action = action.name
-            extras?.forEach {(k, v) ->
-                it.putExtra(k, v)
-            }
-        }
-        intent.component?.javaClass
-        try {
-            application.startService(intent)
-        } catch (e : Exception) {
-            e.message?.let { Firebase.crashlytics.log(it) }
-        }
-    }
-
-    fun <T : Service> actionOnService(action: Action, context: Context, cls : Class<T>, extras : Map<String,String>? = null) {
-        if (getServiceState(context, cls) == ServiceState.STOPPED && action == Action.STOP) return
-        val intent = Intent(context, cls).also {
-            it.action = action.name
-            extras?.forEach {(k, v) ->
-                it.putExtra(k, v)
-            }
-        }
-        intent.component?.javaClass
-        try {
-            context.startService(intent)
-        } catch (e : Exception) {
-            e.message?.let { Firebase.crashlytics.log(it) }
-        }
-    }
-}
@@ -1,236 +1,367 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground

 import android.app.AlarmManager
-import android.app.Application
 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.repository.Repository
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.service.network.WifiService
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import timber.log.Timber
 import javax.inject.Inject

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

-    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 settingsRepo: Repository<Settings>
+  @Inject lateinit var settingsRepository: SettingsRepository

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

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

-    private lateinit var watcherJob : Job;
-    private lateinit var setting : Settings
-    private lateinit var tunnelId: String
+  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 var connecting = false
-    private var disconnecting = false
-    private var isWifiConnected = false
-    private var isMobileDataConnected = false
+  private lateinit var watcherJob: Job

-    private var wakeLock: PowerManager.WakeLock? = null
-    private val tag = this.javaClass.name;
+  private var wakeLock: PowerManager.WakeLock? = null
+  private val tag = this.javaClass.name

-
-    override fun startService(extras: Bundle?) {
-        super.startService(extras)
-        val tunnelId = extras?.getString(getString(R.string.tunnel_extras_key))
-        if (tunnelId != null) {
-            this.tunnelId = tunnelId
-        }
-        // we need this lock so our service gets not affected by Doze Mode
-        initWakeLock()
-        cancelWatcherJob()
-        launchWatcherNotification()
-        if(this::tunnelId.isInitialized) {
-            startWatcherJob()
-        } else {
-            stopService(extras)
-        }
+  override fun onCreate() {
+    super.onCreate()
+    lifecycleScope.launch(Dispatchers.Main) {
+      try {
+          if(settingsRepository.getSettings().isAutoTunnelPaused) {
+              launchWatcherPausedNotification()
+          } else launchWatcherNotification()
+      } catch (e: Exception) {
+        Timber.e("Failed to start watcher service, not enough permissions")
+      }
    }
+  }

-    override fun stopService(extras: Bundle?) {
-        super.stopService(extras)
-        wakeLock?.let {
-            if (it.isHeld) {
-                it.release()
-            }
-        }
-        cancelWatcherJob()
-        stopVPN()
-        stopSelf()
+  override fun startService(extras: Bundle?) {
+    super.startService(extras)
+    try {
+      // we need this lock so our service gets not affected by Doze Mode
+      lifecycleScope.launch { initWakeLock() }
+      cancelWatcherJob()
+      startWatcherJob()
+    } catch (e: Exception) {
+      Timber.e("Failed to launch watcher service, no permissions")
    }
+  }

-    private fun launchWatcherNotification() {
-        val notification = notificationService.createNotification(
+  override fun stopService(extras: Bundle?) {
+    super.stopService(extras)
+    wakeLock?.let {
+      if (it.isHeld) {
+        it.release()
+      }
+    }
+    cancelWatcherJob()
+    stopSelf()
+  }
+
+  private fun launchWatcherNotification(description: String = getString(R.string.watcher_notification_text_active)) {
+    val notification =
+        notificationService.createNotification(
            channelId = getString(R.string.watcher_channel_id),
            channelName = getString(R.string.watcher_channel_name),
-            description = getString(R.string.watcher_notification_text))
-        super.startForeground(foregroundId, notification)
+            title = getString(R.string.auto_tunnel_title),
+            description = description)
+    ServiceCompat.startForeground(
+        this, foregroundId, notification, Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID)
+  }
+
+    private fun launchWatcherPausedNotification() {
+        launchWatcherNotification(getString(R.string.watcher_notification_text_paused))
    }

-    //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);
-    }
+  // 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 fun initWakeLock() {
-        wakeLock =
-            (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
-                newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
-                    acquire()
-                }
-            }
-    }
-
-    private fun cancelWatcherJob() {
-        if(this::watcherJob.isInitialized) {
-            watcherJob.cancel()
+  private suspend fun initWakeLock() {
+    val isBatterySaverOn =
+        withContext(lifecycleScope.coroutineContext) {
+          settingsRepository.getSettings().isBatterySaverEnabled
        }
-    }
-
-    private fun startWatcherJob() {
-        watcherJob = CoroutineScope(SupervisorJob()).launch {
-            val settings = settingsRepo.getAll();
-            if(!settings.isNullOrEmpty()) {
-                setting = settings[0]
-            }
-            CoroutineScope(watcherJob).launch {
-                watchForWifiConnectivityChanges()
-            }
-            if(setting.isTunnelOnMobileDataEnabled) {
-                CoroutineScope(watcherJob).launch {
-                    watchForMobileDataConnectivityChanges()
-                }
+    wakeLock =
+        (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
+          newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
+            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)
            }
+          }
        }
-    }
+  }

-    private suspend fun watchForMobileDataConnectivityChanges() {
-        mobileDataService.networkStatus.collect {
-            when(it) {
-                is NetworkStatus.Available -> {
-                    Timber.d("Gained Mobile data connection")
-                    isMobileDataConnected = true
-                }
-                is NetworkStatus.CapabilitiesChanged -> {
-                    isMobileDataConnected = true
-                    Timber.d("Mobile data capabilities changed")
-                    if(!disconnecting && !connecting) {
-                        if(!isWifiConnected && setting.isTunnelOnMobileDataEnabled
-                            && vpnService.getState() == Tunnel.State.DOWN)
-                            startVPN()
-                    }
-                }
-                is NetworkStatus.Unavailable -> {
-                    isMobileDataConnected = false
-                    if(!disconnecting && !connecting) {
-                        if(!isWifiConnected && vpnService.getState() == Tunnel.State.UP) stopVPN()
-                    }
-                    Timber.d("Lost mobile data connection")
-                }
+  private fun cancelWatcherJob() {
+    if (this::watcherJob.isInitialized) {
+      watcherJob.cancel()
+    }
+  }
+
+  private fun startWatcherJob() {
+    watcherJob =
+        lifecycleScope.launch(Dispatchers.IO) {
+          val setting = settingsRepository.getSettings()
+          launch {
+            Timber.d("Starting wifi watcher")
+            watchForWifiConnectivityChanges()
+          }
+          if (setting.isTunnelOnMobileDataEnabled) {
+            launch {
+              Timber.d("Starting mobile data watcher")
+              watchForMobileDataConnectivityChanges()
            }
-        }
-    }
-
-    private suspend fun watchForWifiConnectivityChanges() {
-        wifiService.networkStatus.collect {
-                when (it) {
-                    is NetworkStatus.Available -> {
-                        Timber.d("Gained Wi-Fi connection")
-                        isWifiConnected = true
-                    }
-                    is NetworkStatus.CapabilitiesChanged -> {
-                        Timber.d("Wifi capabilities changed")
-                        isWifiConnected = true
-                        if (!connecting && !disconnecting) {
-                            Timber.d("Not connect and not disconnecting")
-                            val ssid = wifiService.getNetworkName(it.networkCapabilities);
-                            Timber.d("SSID: $ssid")
-                            if (!setting.trustedNetworkSSIDs.contains(ssid) && vpnService.getState() == Tunnel.State.DOWN) {
-                                Timber.d("Starting VPN Tunnel for untrusted network: $ssid")
-                                startVPN()
-                            } else if (!disconnecting && vpnService.getState() == Tunnel.State.UP && setting.trustedNetworkSSIDs.contains(
-                                    ssid
-                                )
-                            ) {
-                                Timber.d("Stopping VPN Tunnel for trusted network with ssid: $ssid")
-                                stopVPN()
-                            }
-                        }
-                    }
-                    is NetworkStatus.Unavailable -> {
-                        isWifiConnected = false
-                        Timber.d("Lost Wi-Fi connection")
-                        if(!connecting || !disconnecting) {
-                            if(setting.isTunnelOnMobileDataEnabled && vpnService.getState() == Tunnel.State.DOWN
-                                && isMobileDataConnected){
-                                Timber.d("Wifi not available so starting vpn for mobile data")
-                                startVPN()
-                            }
-                            if(!setting.isTunnelOnMobileDataEnabled && vpnService.getState() == Tunnel.State.UP) {
-                                Timber.d("Lost WiFi connection, disabling vpn")
-                                stopVPN()
-                            }
-                        }
-
-                    }
-                }
+          }
+          if (setting.isTunnelOnEthernetEnabled) {
+            launch {
+              Timber.d("Starting ethernet data watcher")
+              watchForEthernetConnectivityChanges()
            }
+          }
+            launch {
+                Timber.d("Starting vpn state watcher")
+                watchForVpnConnectivityChanges()
+            }
+            launch {
+                Timber.d("Starting settings watcher")
+                watchForSettingsChanges()
+            }
+          launch {
+            Timber.d("Starting management watcher")
+            manageVpn()
+          }
        }
-    private fun startVPN() {
-        if(!connecting) {
-            connecting = true
-            ServiceTracker.actionOnService(
-                Action.START,
-                this.applicationContext as Application,
-                WireGuardTunnelService::class.java,
-                mapOf(getString(R.string.tunnel_extras_key) to tunnelId))
-            connecting = false
-        }
-    }
-    private fun stopVPN() {
-        if(!disconnecting) {
-            disconnecting = true
-            ServiceTracker.actionOnService(
-                Action.STOP,
-                this.applicationContext as Application,
-                WireGuardTunnelService::class.java
+  }
+
+  private suspend fun watchForMobileDataConnectivityChanges() {
+    mobileDataService.networkStatus.collect {
+      when (it) {
+        is NetworkStatus.Available -> {
+          Timber.d("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")
+        }
+        is NetworkStatus.Unavailable -> {
+            networkEventsFlow.value = networkEventsFlow.value.copy(
+                isMobileDataConnected = false
+            )
+          Timber.d("Lost mobile data connection")
+        }
+      }
+    }
+  }
+    private suspend fun watchForSettingsChanges() {
+        settingsRepository.getSettingsFlow().collect {
+            if(networkEventsFlow.value.settings.isAutoTunnelPaused != it.isAutoTunnelPaused) {
+                when(it.isAutoTunnelPaused) {
+                    true -> launchWatcherPausedNotification()
+                    false -> launchWatcherNotification()
+                }
+            }
+            networkEventsFlow.value = networkEventsFlow.value.copy(
+                settings = it
            )
-            disconnecting = false
        }
    }
-}
+
+    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 -> {}
+            }
+        }
+    }
+
+  private suspend fun watchForEthernetConnectivityChanges() {
+    ethernetService.networkStatus.collect {
+      when (it) {
+        is NetworkStatus.Available -> {
+          Timber.d("Gained Ethernet connection")
+            networkEventsFlow.value = networkEventsFlow.value.copy(
+                isEthernetConnected = true
+            )
+        }
+        is NetworkStatus.CapabilitiesChanged -> {
+          Timber.d("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")
+        }
+      }
+    }
+  }
+
+  private suspend fun watchForWifiConnectivityChanges() {
+    wifiService.networkStatus.collect {
+      when (it) {
+        is NetworkStatus.Available -> {
+          Timber.d("Gained Wi-Fi connection")
+            networkEventsFlow.value = networkEventsFlow.value.copy(
+                isWifiConnected = true
+            )
+        }
+        is NetworkStatus.CapabilitiesChanged -> {
+          Timber.d("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
+            )
+        }
+        is NetworkStatus.Unavailable -> {
+          networkEventsFlow.value = networkEventsFlow.value.copy(
+              isWifiConnected = false
+          )
+          Timber.d("Lost Wi-Fi connection")
+        }
+      }
+    }
+  }
+
+    //TODO clean this up
+  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)
+            when {
+                ((it.isEthernetConnected &&
+                        it.settings.isTunnelOnEthernetEnabled &&
+                        !it.isVpnConnected)) -> {
+                    ServiceManager.startVpnServiceForeground(this, it.settings.defaultTunnel!!)
+                    Timber.i("Condition 1 met")
+                }
+                (!it.isEthernetConnected &&
+                        it.settings.isTunnelOnMobileDataEnabled &&
+                        !it.isWifiConnected &&
+                        it.isMobileDataConnected &&
+                        !it.isVpnConnected) -> {
+                    ServiceManager.startVpnServiceForeground(this, it.settings.defaultTunnel!!)
+                    Timber.i("Condition 2 met")
+                }
+                (!it.isEthernetConnected &&
+                        !it.settings.isTunnelOnMobileDataEnabled &&
+                        !it.isWifiConnected &&
+                        it.isVpnConnected) -> {
+                    ServiceManager.stopVpnService(this)
+                    Timber.i("Condition 3 met")
+                }
+                (!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")
+                }
+                (!it.isEthernetConnected &&
+                        (it.isWifiConnected && it.settings.trustedNetworkSSIDs.contains(it.currentNetworkSSID)) &&
+                        (it.isVpnConnected)) -> {
+                    ServiceManager.stopVpnService(this)
+                    Timber.i("Condition 5 met")
+                }
+                (!it.isEthernetConnected &&
+                        (it.isWifiConnected &&
+                                !it.settings.isTunnelOnWifiEnabled &&
+                                (it.isVpnConnected))) -> {
+                    ServiceManager.stopVpnService(this)
+                    Timber.i("Condition 6 met")
+                }
+                (!it.isEthernetConnected &&
+                        !it.isWifiConnected &&
+                        !it.isMobileDataConnected &&
+                        (it.isVpnConnected)) -> {
+                    ServiceManager.stopVpnService(this)
+                    Timber.i("Condition 7 met")
+                }
+                else -> {
+                    Timber.i("No condition met")
+                }
+            }
+        }
+    }
+  }
+}
@@ -3,123 +3,179 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 import android.app.PendingIntent
 import android.content.Intent
 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.receiver.NotificationActionReceiver
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
+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.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject

@AndroidEntryPoint
 class WireGuardTunnelService : ForegroundService() {
-
-    private val foregroundId = 123;
+    private val foregroundId = 123

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

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

-    private lateinit var job : Job
+    @Inject
+    lateinit var tunnelConfigRepository: TunnelConfigRepository

-    private var tunnelName : String = ""
+    @Inject
+    lateinit var notificationService: NotificationService

-    override fun startService(extras : Bundle?) {
-        super.startService(extras)
-        val tunnelConfigString = extras?.getString(getString(R.string.tunnel_extras_key))
-        cancelJob()
-        job = CoroutineScope(SupervisorJob()).launch {
-            if(tunnelConfigString != null) {
-                try {
-                    val tunnelConfig = TunnelConfig.from(tunnelConfigString)
-                    tunnelName = tunnelConfig.name
-                    vpnService.startTunnel(tunnelConfig)
-                } catch (e : Exception) {
-                    Timber.e("Problem starting tunnel: ${e.message}")
-                    stopService(extras)
-                }
-            } else {
-                Timber.e("Tunnel config null")
-            }
-        }
-        CoroutineScope(job).launch {
-            var didShowConnected = false
-            var didShowFailedHandshakeNotification = false
-            vpnService.handshakeStatus.collect {
-                when(it) {
-                    HandshakeStatus.NOT_STARTED -> {
-                    }
-                    HandshakeStatus.NEVER_CONNECTED -> {
-                        if(!didShowFailedHandshakeNotification) {
-                            launchVpnConnectionFailedNotification(getString(R.string.initial_connection_failure_message))
-                            didShowFailedHandshakeNotification = true
-                        }
-                    }
-                    HandshakeStatus.HEALTHY -> {
-                        if(!didShowConnected) {
-                            launchVpnConnectedNotification()
-                            didShowConnected = true
-                        }
-                    }
-                    HandshakeStatus.UNHEALTHY -> {
-                        if(!didShowFailedHandshakeNotification) {
-                            launchVpnConnectionFailedNotification(getString(R.string.lost_connection_failure_message))
-                            didShowFailedHandshakeNotification = true
-                        }
-                    }
-                }
+    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()) {
+                launchVpnNotification()
            }
        }
    }

-    override fun stopService(extras : Bundle?) {
+    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)
+                            }
+
+                        }
+                    }
+                }
+                //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 -> {}
+                                }
+                            }
+                    }
+                }
+            }
+    }
+
+    override fun stopService(extras: Bundle?) {
        super.stopService(extras)
-        CoroutineScope(Dispatchers.IO).launch() {
+        lifecycleScope.launch(Dispatchers.IO) {
            vpnService.stopTunnel()
+            didShowConnected = false
        }
        cancelJob()
        stopSelf()
    }

-    private fun launchVpnConnectedNotification() {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.vpn_channel_id),
-            channelName = getString(R.string.vpn_channel_name),
-            title = getString(R.string.tunnel_start_title),
-            onGoing = false,
-            showTimestamp = true,
-            description = "${getString(R.string.tunnel_start_text)} $tunnelName"
+    private fun launchVpnNotification(title : String = getString(R.string.vpn_starting),description : String = getString(R.string.attempt_connection)) {
+        val notification =
+            notificationService.createNotification(
+                channelId = getString(R.string.vpn_channel_id),
+                channelName = getString(R.string.vpn_channel_name),
+                title = title,
+                onGoing = false,
+                vibration = false,
+                showTimestamp = true,
+                description = description
+            )
+        ServiceCompat.startForeground(
+            this,
+            foregroundId,
+            notification,
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID
        )
-        super.startForeground(foregroundId, notification)
    }

-    private fun launchVpnConnectionFailedNotification(message : String) {
-        val notification = notificationService.createNotification(
-            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),
-            actionText = getString(R.string.restart),
-            title = getString(R.string.vpn_connection_failed),
-            onGoing = false,
-            showTimestamp = true,
-            description = message
+    private fun launchVpnConnectionFailedNotification(message: String) {
+        val notification =
+            notificationService.createNotification(
+                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
+                ),
+                actionText = getString(R.string.restart),
+                title = getString(R.string.vpn_connection_failed),
+                onGoing = false,
+                vibration = true,
+                showTimestamp = true,
+                description = message
+            )
+        ServiceCompat.startForeground(
+            this,
+            foregroundId,
+            notification,
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID
        )
-        super.startForeground(foregroundId, notification)
    }

-
    private fun cancelJob() {
-        if(this::job.isInitialized) {
+        if (this::job.isInitialized) {
            job.cancel()
        }
    }
-}
+}
@@ -14,71 +14,86 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.map

-
-abstract class BaseNetworkService<T : BaseNetworkService<T>>(val context: Context, networkCapability : Int) : NetworkService<T> {
+abstract class BaseNetworkService<T : BaseNetworkService<T>>(
+    val context: Context,
+    networkCapability: Int
+) : NetworkService<T> {
    private val connectivityManager =
        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    private val wifiManager =
        context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager

-    override val networkStatus = callbackFlow {
-        val networkStatusCallback = when (Build.VERSION.SDK_INT) {
-            in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
-                object : ConnectivityManager.NetworkCallback(
-                    FLAG_INCLUDE_LOCATION_INFO
-                ) {
+    override val networkStatus =
+        callbackFlow {
+            val networkStatusCallback =
+                when (Build.VERSION.SDK_INT) {
+                    in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
+                        object : ConnectivityManager.NetworkCallback(
+                            FLAG_INCLUDE_LOCATION_INFO
+                        ) {
+                            override fun onAvailable(network: Network) {
+                                trySend(NetworkStatus.Available(network))
+                            }

-                    override fun onAvailable(network: Network) {
-                        trySend(NetworkStatus.Available(network))
+                            override fun onLost(network: Network) {
+                                trySend(NetworkStatus.Unavailable(network))
+                            }
+
+                            override fun onCapabilitiesChanged(
+                                network: Network,
+                                networkCapabilities: NetworkCapabilities
+                            ) {
+                                trySend(
+                                    NetworkStatus.CapabilitiesChanged(
+                                        network,
+                                        networkCapabilities
+                                    )
+                                )
+                            }
+                        }
                    }

-                    override fun onLost(network: Network) {
-                        trySend(NetworkStatus.Unavailable(network))
-                    }
+                    else -> {
+                        object : ConnectivityManager.NetworkCallback() {
+                            override fun onAvailable(network: Network) {
+                                trySend(NetworkStatus.Available(network))
+                            }

-                    override fun onCapabilitiesChanged(
-                        network: Network,
-                        networkCapabilities: NetworkCapabilities
-                    ) {
-                        trySend(NetworkStatus.CapabilitiesChanged(network, networkCapabilities))
+                            override fun onLost(network: Network) {
+                                trySend(NetworkStatus.Unavailable(network))
+                            }
+
+                            override fun onCapabilitiesChanged(
+                                network: Network,
+                                networkCapabilities: NetworkCapabilities
+                            ) {
+                                trySend(
+                                    NetworkStatus.CapabilitiesChanged(
+                                        network,
+                                        networkCapabilities
+                                    )
+                                )
+                            }
+                        }
                    }
                }
-            }
-            else -> {
-                object : ConnectivityManager.NetworkCallback() {
+            val request =
+                NetworkRequest.Builder()
+                    .addTransportType(networkCapability)
+                    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                    .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+                    .build()
+            connectivityManager.registerNetworkCallback(request, networkStatusCallback)

-                    override fun onAvailable(network: Network) {
-                        trySend(NetworkStatus.Available(network))
-                    }
-
-                    override fun onLost(network: Network) {
-                        trySend(NetworkStatus.Unavailable(network))
-                    }
-
-                    override fun onCapabilitiesChanged(
-                        network: Network,
-                        networkCapabilities: NetworkCapabilities
-                    ) {
-                        trySend(NetworkStatus.CapabilitiesChanged(network, networkCapabilities))
-                    }
-                }
+            awaitClose {
+                connectivityManager.unregisterNetworkCallback(networkStatusCallback)
            }
        }
-        val request = NetworkRequest.Builder()
-            .addTransportType(networkCapability)
-            .build()
-        connectivityManager.registerNetworkCallback(request, networkStatusCallback)
-
-        awaitClose {
-            connectivityManager.unregisterNetworkCallback(networkStatusCallback)
-        }
-    }
-

    override fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
-        var ssid : String? = getWifiNameFromCapabilities(networkCapabilities)
-        if((Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) || (Build.VERSION.SDK_INT == Build.VERSION_CODES.R)) {
+        var ssid: String? = getWifiNameFromCapabilities(networkCapabilities)
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
            val info = wifiManager.connectionInfo
            if (info.supplicantState === SupplicantState.COMPLETED) {
                ssid = info.ssid
@@ -87,28 +102,35 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(val context: Contex
        return ssid?.trim('"')
    }

-
    companion object {
-        private fun getWifiNameFromCapabilities(networkCapabilities: NetworkCapabilities) : String? {
-            val info : WifiInfo
-            if(networkCapabilities.transportInfo is WifiInfo) {
-                info = networkCapabilities.transportInfo as WifiInfo
-            } else {
-                return null
+        private fun getWifiNameFromCapabilities(networkCapabilities: NetworkCapabilities): String? {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                val info: WifiInfo
+                if (networkCapabilities.transportInfo is WifiInfo) {
+                    info = networkCapabilities.transportInfo as WifiInfo
+                    return info.ssid
+                }
            }
-            return info.ssid
+            return null
        }
    }
 }

 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,
-): Flow<Result> = map { status ->
-    when (status) {
-        is NetworkStatus.Unavailable -> onUnavailable(status.network)
-        is NetworkStatus.Available -> onAvailable(status.network)
-        is NetworkStatus.CapabilitiesChanged -> onCapabilitiesChanged(status.network, status.networkCapabilities)
+    crossinline onUnavailable: suspend (network: Network) -> Result,
+    crossinline onAvailable: suspend (network: Network) -> Result,
+    crossinline onCapabilitiesChanged: suspend (
+        network: Network,
+        networkCapabilities: NetworkCapabilities
+    ) -> Result
+): Flow<Result> =
+    map { status ->
+        when (status) {
+            is NetworkStatus.Unavailable -> onUnavailable(status.network)
+            is NetworkStatus.Available -> onAvailable(status.network)
+            is NetworkStatus.CapabilitiesChanged -> onCapabilitiesChanged(
+                status.network,
+                status.networkCapabilities
+            )
+        }
    }
-}
@@ -0,0 +1,13 @@
+package com.zaneschepke.wireguardautotunnel.service.network
+
+import android.content.Context
+import android.net.NetworkCapabilities
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+
+class EthernetService
+@Inject
+constructor(
+    @ApplicationContext context: Context
+) :
+    BaseNetworkService<EthernetService>(context, NetworkCapabilities.TRANSPORT_ETHERNET)
@@ -5,6 +5,9 @@ import android.net.NetworkCapabilities
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject

-class MobileDataService @Inject constructor(@ApplicationContext context: Context) :
-    BaseNetworkService<MobileDataService>(context, NetworkCapabilities.TRANSPORT_CELLULAR) {
-}
+class MobileDataService
+@Inject
+constructor(
+    @ApplicationContext context: Context
+) :
+    BaseNetworkService<MobileDataService>(context, NetworkCapabilities.TRANSPORT_CELLULAR)
@@ -4,7 +4,7 @@ import android.net.NetworkCapabilities
 import kotlinx.coroutines.flow.Flow

 interface NetworkService<T> {
-    fun getNetworkName(networkCapabilities: NetworkCapabilities) : String?
-    val networkStatus : Flow<NetworkStatus>
+    fun getNetworkName(networkCapabilities: NetworkCapabilities): String?

-}
+    val networkStatus: Flow<NetworkStatus>
+}
@@ -4,7 +4,10 @@ import android.net.Network
 import android.net.NetworkCapabilities

 sealed class NetworkStatus {
-    class Available(val network : Network) : NetworkStatus()
-    class Unavailable(val network : Network) : NetworkStatus()
-    class CapabilitiesChanged(val network : Network, val networkCapabilities : NetworkCapabilities) : NetworkStatus()
+    class Available(val network: Network) : NetworkStatus()
+
+    class Unavailable(val network: Network) : NetworkStatus()
+
+    class CapabilitiesChanged(val network: Network, val networkCapabilities: NetworkCapabilities) :
+        NetworkStatus()
 }
@@ -5,6 +5,9 @@ import android.net.NetworkCapabilities
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject

-class WifiService @Inject constructor(@ApplicationContext context: Context) :
-    BaseNetworkService<WifiService>(context, NetworkCapabilities.TRANSPORT_WIFI) {
-}
+class WifiService
+@Inject
+constructor(
+    @ApplicationContext context: Context
+) :
+    BaseNetworkService<WifiService>(context, NetworkCapabilities.TRANSPORT_WIFI)
@@ -3,6 +3,7 @@ package com.zaneschepke.wireguardautotunnel.service.notification
 import android.app.Notification
 import android.app.NotificationManager
 import android.app.PendingIntent
+import androidx.core.app.NotificationCompat

 interface NotificationService {
    fun createNotification(
@@ -12,10 +13,11 @@ interface NotificationService {
        action: PendingIntent? = null,
        actionText: String? = null,
        description: String,
-        showTimestamp : Boolean = false,
+        showTimestamp: Boolean = false,
        importance: Int = NotificationManager.IMPORTANCE_HIGH,
-        vibration: Boolean = true,
+        vibration: Boolean = false,
        onGoing: Boolean = true,
-        lights: Boolean = true
+        lights: Boolean = true,
+        onlyAlertOnce: Boolean = true,
    ): Notification
-}
+}
@@ -7,14 +7,29 @@ import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
 import android.graphics.Color
+import androidx.core.app.NotificationCompat
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.MainActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject

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

-    private val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager;
+    private val watcherBuilder: NotificationCompat.Builder =
+        NotificationCompat.Builder(
+            context,
+            context.getString(R.string.watcher_channel_id)
+        )
+    private val tunnelBuilder: NotificationCompat.Builder = NotificationCompat.Builder(
+        context,
+        context.getString(R.string.vpn_channel_id)
+    )

    override fun createNotification(
        channelId: String,
@@ -27,20 +42,22 @@ class WireGuardNotification @Inject constructor(@ApplicationContext private val
        importance: Int,
        vibration: Boolean,
        onGoing: Boolean,
-        lights: Boolean
+        lights: Boolean,
+        onlyAlertOnce: Boolean,
    ): Notification {
-        val channel = NotificationChannel(
-            channelId,
-            channelName,
-            importance
-        ).let {
-            it.description = title
-            it.enableLights(lights)
-            it.lightColor = Color.RED
-            it.enableVibration(vibration)
-            it.vibrationPattern = longArrayOf(100, 200, 300, 400, 500, 400, 300, 200, 400)
-            it
-        }
+        val channel =
+            NotificationChannel(
+                channelId,
+                channelName,
+                importance
+            ).let {
+                it.description = title
+                it.enableLights(lights)
+                it.lightColor = Color.RED
+                it.enableVibration(vibration)
+                it.vibrationPattern = longArrayOf(100,200,300)
+                it
+            }
        notificationManager.createNotificationChannel(channel)
        val pendingIntent: PendingIntent =
            Intent(context, MainActivity::class.java).let { notificationIntent ->
@@ -52,26 +69,34 @@ class WireGuardNotification @Inject constructor(@ApplicationContext private val
                )
            }

-        val builder: Notification.Builder =
-            Notification.Builder(
-                context,
-                channelId
-            )
-        return builder.let {
-            if(action != null && actionText != null) {
-                //TODO find a not deprecated way to do this
-                it.addAction(
-                    Notification.Action.Builder(0, actionText, action)
-                        .build())
-                    it.setAutoCancel(true)
+        val builder = when(channelId) {
+            context.getString(R.string.watcher_channel_id) -> watcherBuilder
+            context.getString(R.string.vpn_channel_id) -> tunnelBuilder
+            else -> {
+                NotificationCompat.Builder(
+                    context,
+                    channelId
+                )
            }
-                it.setContentTitle(title)
+        }
+
+        return builder.let {
+            if (action != null && actionText != null) {
+                it.addAction(
+                    NotificationCompat.Action.Builder(0, actionText, action)
+                        .build()
+                )
+                it.setAutoCancel(true)
+            }
+            it.setContentTitle(title)
                .setContentText(description)
+                .setOnlyAlertOnce(onlyAlertOnce)
                .setContentIntent(pendingIntent)
                .setOngoing(onGoing)
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
                .setShowWhen(showTimestamp)
                .setSmallIcon(R.mipmap.ic_launcher_foreground)
                .build()
        }
    }
-}
+}
@@ -0,0 +1,84 @@
+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.service.foreground.Action
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+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
+
+    private suspend fun toggleWatcherServicePause() {
+            val settings = settingsRepository.getSettings()
+            if (settings.isAutoTunnelEnabled) {
+                val pauseAutoTunnel = !settings.isAutoTunnelPaused
+                settingsRepository.save(settings.copy(
+                    isAutoTunnelPaused = pauseAutoTunnel
+                ))
+            }
+        }
+
+    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 {
+                        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!!)
+                                }
+                            }
+                        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()
+                    }
+                }
+            }
+        }
+        finish()
+    }
+
+    companion object {
+        const val TUNNEL_NAME_EXTRA_KEY = "tunnelName"
+        const val CLASS_NAME_EXTRA_KEY = "className"
+    }
+}
@@ -0,0 +1,131 @@
+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.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class TunnelControlTile() : TileService() {
+
+    @Inject
+    lateinit var tunnelConfigRepository: TunnelConfigRepository
+
+    @Inject
+    lateinit var settingsRepository: SettingsRepository
+
+    @Inject
+    lateinit var vpnService: VpnService
+
+    private val scope = CoroutineScope(Dispatchers.IO)
+
+    private var tunnelName : String? = null
+
+    override fun onStartListening() {
+        super.onStartListening()
+        Timber.d("On start listening called")
+        scope.launch {
+            vpnService.vpnState.collect {
+                when(it.status) {
+                    Tunnel.State.UP -> setActive()
+                    Tunnel.State.DOWN -> setInactive()
+                    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 ?: "")
+            }
+        }
+    }
+    override fun onDestroy() {
+        super.onDestroy()
+        scope.cancel()
+    }
+
+    override fun onTileRemoved() {
+        super.onTileRemoved()
+        scope.cancel()
+    }
+
+    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(
+                            this@TunnelControlTile,
+                            tunnelConfig.toString()
+                        )
+                    }
+                } catch (e: Exception) {
+                    Timber.e(e.message)
+                } finally {
+                    cancel()
+                }
+            }
+        }
+    }
+
+    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()
+    }
+
+    private fun setInactive() {
+        qsTile.state = Tile.STATE_INACTIVE
+        qsTile.updateTile()
+    }
+
+    private fun setUnavailable() {
+        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()
+    }
+}
@@ -2,13 +2,15 @@ package com.zaneschepke.wireguardautotunnel.service.tunnel

 enum class HandshakeStatus {
    HEALTHY,
-    UNHEALTHY,
-    NEVER_CONNECTED,
-    NOT_STARTED;
+    STALE,
+    UNKNOWN,
+    NOT_STARTED
+    ;

    companion object {
-        private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 120
-        const val UNHEALTHY_TIME_LIMIT_SEC = WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + 60
+        private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 180
+        const val STATUS_CHANGE_TIME_BUFFER = 30
+        const val STALE_TIME_LIMIT_SEC = WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + STATUS_CHANGE_TIME_BUFFER
        const val NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC = 30
    }
-}
+}
@@ -1,18 +1,15 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel

-import com.wireguard.android.backend.Statistics
 import com.wireguard.android.backend.Tunnel
-import com.wireguard.crypto.Key
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import kotlinx.coroutines.flow.SharedFlow
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import kotlinx.coroutines.flow.StateFlow

 interface VpnService : Tunnel {
-    suspend fun startTunnel(tunnelConfig : TunnelConfig) : Tunnel.State
+    suspend fun startTunnel(tunnelConfig: TunnelConfig): Tunnel.State
+
    suspend fun stopTunnel()
-    val state : SharedFlow<Tunnel.State>
-    val tunnelName : SharedFlow<String>
-    val statistics : SharedFlow<Statistics>
-    val lastHandshake : SharedFlow<Map<Key,Long>>
-    val handshakeStatus : SharedFlow<HandshakeStatus>
-    fun getState() : Tunnel.State
-}
+
+    val vpnState: StateFlow<VpnState>
+
+    fun getState(): Tunnel.State
+}
@@ -0,0 +1,10 @@
+package com.zaneschepke.wireguardautotunnel.service.tunnel
+
+import com.wireguard.android.backend.Statistics
+import com.wireguard.android.backend.Tunnel
+
+data class VpnState(
+    val status : Tunnel.State = Tunnel.State.DOWN,
+    val name : String = "",
+    val statistics : Statistics? = null
+)
@@ -3,127 +3,147 @@ 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
-import com.wireguard.crypto.Key
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.NumberUtils
+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.module.Kernel
+import com.zaneschepke.wireguardautotunnel.module.Userspace
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject

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

-    private val _tunnelName = MutableStateFlow("")
-    override val tunnelName get() = _tunnelName.asStateFlow()
+    private val scope = CoroutineScope(Dispatchers.IO)

-    private val _state = MutableSharedFlow<Tunnel.State>(
-        replay = 1)
+    private lateinit var statsJob: Job

-    private val _handshakeStatus = MutableSharedFlow<HandshakeStatus>(replay = 1,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST)
-    override val state get() = _state.asSharedFlow()
+    private var config: Config? = null

-    private val _statistics = MutableSharedFlow<Statistics>(replay = 1)
-    override val statistics get() = _statistics.asSharedFlow()
+    private var backend: Backend = userspaceBackend

-    private val _lastHandshake = MutableSharedFlow<Map<Key, Long>>(replay = 1)
-    override val lastHandshake get() = _lastHandshake.asSharedFlow()
+    private var backendIsUserspace = true

-    override val handshakeStatus: SharedFlow<HandshakeStatus>
-        get() = _handshakeStatus.asSharedFlow()
-
-    private lateinit var statsJob : Job
-
-
-    override suspend fun startTunnel(tunnelConfig: TunnelConfig) : Tunnel.State{
-        return try {
-            if(getState() == Tunnel.State.UP && _tunnelName.value != tunnelConfig.name) {
-                stopTunnel()
+    init {
+        scope.launch {
+            settingsRepository.getSettingsFlow().collect {
+                if (it.isKernelEnabled && backendIsUserspace) {
+                    Timber.d("Setting kernel backend")
+                    backend = kernelBackend
+                    backendIsUserspace = false
+                } else if (!it.isKernelEnabled && !backendIsUserspace) {
+                    Timber.d("Setting userspace backend")
+                    backend = userspaceBackend
+                    backendIsUserspace = true
+                }
            }
-            _tunnelName.emit(tunnelConfig.name)
-            val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val state = backend.setState(
-                this, Tunnel.State.UP, config)
-            _state.emit(state)
-            state;
-        } catch (e : Exception) {
+        }
+    }
+
+    override suspend fun startTunnel(tunnelConfig: TunnelConfig): 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) {
            Timber.e("Failed to start tunnel with error: ${e.message}")
-            Tunnel.State.DOWN
+            State.DOWN
+        }
+    }
+
+    private fun emitTunnelState(state: State) {
+        _vpnState.tryEmit(
+            _vpnState.value.copy(
+                status = state
+            )
+        )
+    }
+
+    private fun emitBackendStatistics(statistics: Statistics) {
+        _vpnState.tryEmit(
+            _vpnState.value.copy(
+                statistics = statistics
+            )
+        )
+    }
+
+    private suspend fun emitTunnelName(name: String) {
+        _vpnState.emit(
+            _vpnState.value.copy(
+                name = name
+            )
+        )
+    }
+
+    private suspend fun stopTunnelOnConfigChange(tunnelConfig: TunnelConfig) {
+        if (getState() == State.UP && _vpnState.value.name != tunnelConfig.name) {
+            stopTunnel()
        }
    }

    override fun getName(): String {
-        return _tunnelName.value
+        return _vpnState.value.name
    }

-    override suspend  fun stopTunnel() {
+    override suspend fun stopTunnel() {
        try {
-            if(getState() == Tunnel.State.UP) {
-                val state = backend.setState(this, Tunnel.State.DOWN, null)
-                _state.emit(state)
+            if (getState() == State.UP) {
+                val state = backend.setState(this, State.DOWN, null)
+                emitTunnelState(state)
            }
-        } catch (e : BackendException) {
+        } catch (e: BackendException) {
            Timber.e("Failed to stop tunnel with error: ${e.message}")
        }
    }

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

-    override fun onStateChange(state : Tunnel.State) {
-        val tunnel = this;
-        _state.tryEmit(state)
-        if(state == Tunnel.State.UP) {
-            statsJob = CoroutineScope(Dispatchers.IO).launch {
-                val handshakeMap = HashMap<Key, Long>()
-                var neverHadHandshakeCounter = 0
-                while (true) {
-                    val statistics = backend.getStatistics(tunnel)
-                    _statistics.emit(statistics)
-                    statistics.peers().forEach {
-                        val handshakeEpoch = statistics.peer(it)?.latestHandshakeEpochMillis ?: 0L
-                        handshakeMap[it] = handshakeEpoch
-                        if(handshakeEpoch == 0L) {
-                            if(neverHadHandshakeCounter >= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
-                                _handshakeStatus.emit(HandshakeStatus.NEVER_CONNECTED)
-                            } else {
-                                _handshakeStatus.emit(HandshakeStatus.NOT_STARTED)
-                            }
-                            if(neverHadHandshakeCounter <= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
-                                neverHadHandshakeCounter++
-                            }
-                            return@forEach
-                        }
-                        if(NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch) >= HandshakeStatus.UNHEALTHY_TIME_LIMIT_SEC) {
-                            _handshakeStatus.emit(HandshakeStatus.UNHEALTHY)
-                        } else {
-                            _handshakeStatus.emit(HandshakeStatus.HEALTHY)
-                        }
+    override fun onStateChange(state: State) {
+        val tunnel = this
+        emitTunnelState(state)
+        WireGuardAutoTunnel.requestTileServiceStateUpdate()
+        if (state == State.UP) {
+            statsJob =
+                scope.launch {
+                    while (true) {
+                        val statistics = backend.getStatistics(tunnel)
+                        emitBackendStatistics(statistics)
+                        delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
                    }
-                    _lastHandshake.emit(handshakeMap)
-                    delay(1000)
                }
-            }
        }
-        if(state == Tunnel.State.DOWN) {
-            if(this::statsJob.isInitialized) {
+        if (state == State.DOWN) {
+            if (this::statsJob.isInitialized) {
                statsJob.cancel()
            }
-            _handshakeStatus.tryEmit(HandshakeStatus.NOT_STARTED)
-            _lastHandshake.tryEmit(emptyMap())
        }
    }
-}
+}
@@ -1,14 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.tunnel.model
-
-import io.objectbox.annotation.Entity
-import io.objectbox.annotation.Id
-
-@Entity
-data class Settings(
-    @Id
-    var id : Long = 0,
-    var isAutoTunnelEnabled : Boolean = false,
-    var isTunnelOnMobileDataEnabled : Boolean = false,
-    var trustedNetworkSSIDs : MutableList<String> = mutableListOf(),
-    var defaultTunnel : String? = null
-)
@@ -1,89 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.tunnel.model
-
-import com.wireguard.config.Config
-import io.objectbox.annotation.ConflictStrategy
-import io.objectbox.annotation.Entity
-import io.objectbox.annotation.Id
-import io.objectbox.annotation.Unique
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
-import java.io.InputStream
-
-
-@Entity
-@Serializable
-data class TunnelConfig(
-    @Id
-    var id : Long = 0,
-    @Unique(onConflict = ConflictStrategy.REPLACE)
-    var name : String,
-    var wgQuick : String
-) {
-
-
-    override fun toString(): String {
-        return Json.encodeToString(serializer(), this)
-    }
-
-    companion object {
-        private const val INCLUDED_APPLICATIONS = "IncludedApplications = "
-        private const val EXCLUDED_APPLICATIONS = "ExcludedApplications = "
-        private const val INTERFACE = "[Interface]"
-        private const val NEWLINE_CHAR = "\n"
-        private const val APP_CONFIG_SEPARATOR = ", "
-
-        private fun addApplicationsToConfig(appConfig : String, wgQuick : String) : String {
-            val configList = wgQuick.split(NEWLINE_CHAR).toMutableList()
-            val interfaceIndex = configList.indexOf(INTERFACE)
-            configList.add(interfaceIndex + 1, appConfig)
-            return configList.joinToString(NEWLINE_CHAR)
-        }
-
-        fun clearAllApplicationsFromConfig(wgQuick : String) : String {
-            val configList = wgQuick.split(NEWLINE_CHAR).toMutableList()
-            val itr = configList.iterator()
-            while (itr.hasNext()) {
-                val next = itr.next()
-                if(next.contains(INCLUDED_APPLICATIONS) || next.contains(EXCLUDED_APPLICATIONS)) {
-                    itr.remove()
-                }
-            }
-            return configList.joinToString(NEWLINE_CHAR)
-        }
-
-
-        fun setExcludedApplicationsOnQuick(packages : List<String>, wgQuick: String) : String {
-            if(packages.isEmpty()) {
-                return wgQuick
-            }
-            val clearedWgQuick = clearAllApplicationsFromConfig(wgQuick)
-            val excludeConfig = buildExcludedApplicationsString(packages)
-            return addApplicationsToConfig(excludeConfig, clearedWgQuick)
-        }
-
-        fun setIncludedApplicationsOnQuick(packages : List<String>, wgQuick: String) : String {
-            if(packages.isEmpty()) {
-                return wgQuick
-            }
-            val clearedWgQuick = clearAllApplicationsFromConfig(wgQuick)
-            val includeConfig = buildIncludedApplicationsString(packages)
-            return addApplicationsToConfig(includeConfig, clearedWgQuick)
-        }
-
-        private fun buildExcludedApplicationsString(packages : List<String>) : String {
-            return EXCLUDED_APPLICATIONS + packages.joinToString(APP_CONFIG_SEPARATOR)
-        }
-
-        private fun buildIncludedApplicationsString(packages : List<String>) : String {
-            return INCLUDED_APPLICATIONS + packages.joinToString(APP_CONFIG_SEPARATOR)
-        }
-        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)
-            return Config.parse(reader)
-        }
-    }
-}
@@ -0,0 +1,13 @@
+package com.zaneschepke.wireguardautotunnel.ui
+
+import androidx.lifecycle.ViewModel
+import com.zaneschepke.wireguardautotunnel.data.SettingsDao
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+
+@HiltViewModel
+class ActivityViewModel @Inject constructor(
+    private val settingsRepo: SettingsDao,
+) : ViewModel() {
+
+}
@@ -0,0 +1,5 @@
+package com.zaneschepke.wireguardautotunnel.ui
+
+import com.journeyapps.barcodescanner.CaptureActivity
+
+class CaptureActivityPortrait : CaptureActivity()
@@ -10,21 +10,28 @@ import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.animation.ExperimentalAnimationApi
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.slideInHorizontally
+import androidx.compose.foundation.focusable
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarData
+import androidx.compose.material3.SnackbarDuration
 import androidx.compose.material3.SnackbarHost
 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.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
-import com.google.accompanist.navigation.animation.AnimatedNavHost
-import com.google.accompanist.navigation.animation.composable
-import com.google.accompanist.navigation.animation.rememberAnimatedNavController
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.lifecycleScope
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
@@ -32,25 +39,31 @@ import com.wireguard.android.backend.GoBackend
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.common.PermissionRequestFailedScreen
 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.detail.DetailScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.TransparentSystemBars
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch

@AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
-
-    @OptIn(ExperimentalAnimationApi::class,
+    @OptIn(
        ExperimentalPermissionsApi::class
    )
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
-            val navController = rememberAnimatedNavController()
+//            val activityViewModel = hiltViewModel<ActivityViewModel>()
+
+            val navController = rememberNavController()
+            val focusRequester = remember { FocusRequester()}
+
            WireguardAutoTunnelTheme {
                TransparentSystemBars()

@@ -66,28 +79,62 @@ class MainActivity : AppCompatActivity() {
                }

                var vpnIntent by remember { mutableStateOf(GoBackend.VpnService.prepare(this)) }
-                val vpnActivityResultState = rememberLauncherForActivityResult(
-                    ActivityResultContracts.StartActivityForResult(),
-                    onResult = {
-                        val accepted = (it.resultCode == RESULT_OK)
-                        if (accepted) {
-                            vpnIntent = null
+                val vpnActivityResultState =
+                    rememberLauncherForActivityResult(
+                        ActivityResultContracts.StartActivityForResult(),
+                        onResult = {
+                            val accepted = (it.resultCode == RESULT_OK)
+                            if (accepted) {
+                                vpnIntent = null
+                            }
                        }
-                    })
+                    )
                LaunchedEffect(vpnIntent) {
                    if (vpnIntent != null) {
                        vpnActivityResultState.launch(vpnIntent)
-                    } else requestNotificationPermission()
+                    } else {
+                        requestNotificationPermission()
+                    }
                }

-                Scaffold(snackbarHost = { SnackbarHost(snackbarHostState) },
-                    bottomBar = if (vpnIntent == null && notificationPermissionState.status.isGranted) {
-                        { BottomNavBar(navController, Routes.navItems) }
+                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()
+                            }
+                        }
+                    }
+                }
+
+                Scaffold(
+                    snackbarHost = {
+                        SnackbarHost(snackbarHostState) { snackbarData: SnackbarData ->
+                            CustomSnackBar(
+                                snackbarData.visuals.message,
+                                isRtl = false,
+                                containerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(
+                                    2.dp
+                                )
+                            )
+                        }
+                    },
+                    modifier = Modifier.focusable().focusProperties { up = focusRequester },
+                    bottomBar =
+                    if (vpnIntent == null && notificationPermissionState.status.isGranted) {
+                        { BottomNavBar(navController, listOf(
+                            Screen.Main.navItem,
+                            Screen.Settings.navItem,
+                            Screen.Support.navItem)) }
                    } else {
                        {}
-                    },
-                )
-                { padding ->
+                    }
+                ) { padding ->
                    if (vpnIntent != null) {
                        PermissionRequestFailedScreen(
                            padding = padding,
@@ -104,69 +151,53 @@ class MainActivity : AppCompatActivity() {
                                val intentSettings =
                                    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                                intentSettings.data =
-                                    Uri.fromParts("package", this.packageName, null)
-                                startActivity(intentSettings);
+                                    Uri.fromParts(
+                                        Constants.URI_PACKAGE_SCHEME,
+                                        this.packageName,
+                                        null
+                                    )
+                                startActivity(intentSettings)
                            },
                            message = getString(R.string.notification_permission_required),
                            getString(R.string.open_settings)
                        )
                        return@Scaffold
                    }
-                    AnimatedNavHost(navController, startDestination = Routes.Main.name) {
-                        composable(Routes.Main.name, enterTransition = {
-                            when (initialState.destination.route) {
-                                Routes.Settings.name, Routes.Support.name ->
-                                    slideInHorizontally(
-                                        initialOffsetX = { -1000 },
-                                        animationSpec = tween(500)
-                                    )
-
-                                else -> {
-                                    fadeIn(animationSpec = tween(1000))
-                                }
-                            }
-                        }) {
-                            MainScreen(padding = padding, snackbarHostState = snackbarHostState, navController = navController)
+                    NavHost(navController, startDestination = Screen.Main.route) {
+                        composable(
+                            Screen.Main.route,
+                        ) {
+                            MainScreen(padding = padding, focusRequester = focusRequester, showSnackbarMessage = { message ->
+                                showSnackBarMessage(message)
+                            }, navController = navController)
                        }
-                        composable(Routes.Settings.name, enterTransition = {
-                            when (initialState.destination.route) {
-                                Routes.Main.name ->
-                                    slideInHorizontally(
-                                        initialOffsetX = { 1000 },
-                                        animationSpec = tween(500)
-                                    )
-
-                                Routes.Support.name -> {
-                                    slideInHorizontally(
-                                        initialOffsetX = { -1000 },
-                                        animationSpec = tween(500)
-                                    )
-                                }
-
-                                else -> {
-                                    fadeIn(animationSpec = tween(1000))
-                                }
+                        composable(Screen.Settings.route,
+                        ) {
+                            SettingsScreen(padding = padding, showSnackbarMessage = { message ->
+                                showSnackBarMessage(message)
+                            }, 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()) {
+                                //https://dagger.dev/hilt/view-model#assisted-injection
+                                ConfigScreen(
+                                    navController = navController,
+                                    id = id,
+                                    showSnackbarMessage = { message ->
+                                        showSnackBarMessage(message)
+                                    },
+                                    focusRequester = focusRequester
+                                )
                            }
-                        }) { SettingsScreen(padding = padding, snackbarHostState = snackbarHostState, navController = navController) }
-                        composable(Routes.Support.name, enterTransition = {
-                            when (initialState.destination.route) {
-                                Routes.Settings.name, Routes.Main.name ->
-                                    slideInHorizontally(
-                                        initialOffsetX = { 1000 },
-                                        animationSpec = tween(500)
-                                    )
-
-                                else -> {
-                                    fadeIn(animationSpec = tween(1000))
-                                }
-                            }
-                        }) { SupportScreen(padding = padding) }
-                        composable("${Routes.Config.name}/{id}", enterTransition = {
-                            fadeIn(animationSpec = tween(1000))
-                        }) { ConfigScreen(padding = padding, navController = navController, id = it.arguments?.getString("id"))}
-                        composable("${Routes.Detail.name}/{id}", enterTransition = {
-                            fadeIn(animationSpec = tween(1000))
-                        }) { DetailScreen(padding = padding, id = it.arguments?.getString("id")) }
+                        }
                    }
                }
            }
@@ -1,36 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-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 com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavItem
-
-enum class Routes {
-    Main,
-    Settings,
-    Support,
-    Config,
-    Detail;
-
-
-    companion object {
-        val navItems = listOf(
-            BottomNavItem(
-                name = "Tunnels",
-                route = Main.name,
-                icon = Icons.Rounded.Home,
-            ),
-            BottomNavItem(
-                name = "Settings",
-                route = Settings.name,
-                icon = Icons.Rounded.Settings,
-            ),
-            BottomNavItem(
-                name = "Support",
-                route = Support.name,
-                icon = Icons.Rounded.QuestionMark,
-            )
-        )
-    }
-}
@@ -0,0 +1,33 @@
+package com.zaneschepke.wireguardautotunnel.ui
+
+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 com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavItem
+
+sealed class Screen(val route : String) {
+    data object Main: Screen("main") {
+        val navItem = BottomNavItem(
+        name = "Tunnels",
+        route = route,
+        icon = Icons.Rounded.Home
+        )
+    }
+    data object Settings: Screen("settings") {
+        val navItem = BottomNavItem(
+        name = "Settings",
+        route = route,
+        icon = Icons.Rounded.Settings
+        )
+    }
+    data object Support: Screen("support") {
+        val navItem = BottomNavItem(
+        name = "Support",
+        route = route,
+        icon = Icons.Rounded.QuestionMark
+        )
+    }
+    data object Config : Screen("config")
+
+}
@@ -1,9 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-data class ViewState(
-    val showSnackbarMessage : Boolean = false,
-    val snackbarMessage : String = "",
-    val snackbarActionText : String = "",
-    val onSnackbarActionClick : () -> Unit = {},
-    val isLoading : Boolean = false
-)
@@ -3,29 +3,39 @@ package com.zaneschepke.wireguardautotunnel.ui.common
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.size
-import androidx.compose.material3.Button
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
 import androidx.compose.material3.Text
+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(onIconClick : () -> Unit, text : String, icon : ImageVector, enabled : Boolean) {
-    Button(onClick = {},
+fun ClickableIconButton(
+    onClick: () -> Unit,
+    onIconClick: () -> Unit,
+    text: String,
+    icon: ImageVector,
+    enabled: Boolean
+) {
+    TextButton(
+        onClick = onClick,
        enabled = enabled
    ) {
-        Text(text)
+        Text(text, Modifier.weight(1f, false))
        Spacer(modifier = Modifier.size(ButtonDefaults.IconSpacing))
        Icon(
            imageVector = icon,
-            contentDescription = "Delete",
-            modifier = Modifier.size(ButtonDefaults.IconSize).clickable {
-                if(enabled) {
+            contentDescription = stringResource(R.string.delete),
+            modifier =
+            Modifier.size(ButtonDefaults.IconSize).weight(1f, false).clickable {
+                if (enabled) {
                    onIconClick()
                }
            }
        )
    }
-}
+}
@@ -16,13 +16,21 @@ import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.launch

@Composable
-fun PermissionRequestFailedScreen(padding : PaddingValues, onRequestAgain : () -> Unit, message : String, buttonText : String ) {
+fun PermissionRequestFailedScreen(
+    padding: PaddingValues,
+    onRequestAgain: () -> Unit,
+    message: String,
+    buttonText: String
+) {
    val scope = rememberCoroutineScope()
-    Column(horizontalAlignment = Alignment.CenterHorizontally,
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center,
-        modifier = Modifier
+        modifier =
+        Modifier
            .fillMaxSize()
-            .padding(padding)) {
+            .padding(padding)
+    ) {
        Text(message, textAlign = TextAlign.Center, modifier = Modifier.padding(15.dp))
        Button(onClick = {
            scope.launch {
@@ -32,4 +40,4 @@ fun PermissionRequestFailedScreen(padding : PaddingValues, onRequestAgain : () -
            Text(buttonText)
        }
    }
-}
+}
@@ -1,27 +1,42 @@
 package com.zaneschepke.wireguardautotunnel.ui.common

+import androidx.compose.animation.animateContentSize
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.material3.Icon
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
+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

@OptIn(ExperimentalFoundationApi::class)
@Composable
-fun RowListItem(leadingIcon : ImageVector? = null, leadingIconColor : Color = Color.Gray, text : String, onHold : () -> Unit, onClick: () -> Unit, rowButton : @Composable() () -> Unit ) {
+fun RowListItem(
+    icon: @Composable () -> Unit,
+    text: String,
+    onHold: () -> Unit,
+    onClick: () -> Unit,
+    rowButton: @Composable () -> Unit,
+    expanded: Boolean,
+    statistics: Statistics?
+) {
    Box(
-        modifier = Modifier
+        modifier =
+        Modifier
+            .animateContentSize()
+            .clip(RoundedCornerShape(30.dp))
            .combinedClickable(
                onClick = {
                    onClick()
@@ -31,25 +46,52 @@ fun RowListItem(leadingIcon : ImageVector? = null, leadingIconColor : Color = Co
                }
            )
    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(14.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Row(verticalAlignment = Alignment.CenterVertically,) {
-                if(leadingIcon != null) {
-                    Icon(
-                        leadingIcon, "status",
-                        tint = leadingIconColor,
-                        modifier =  Modifier.padding(end = 10.dp).size(15.dp)
-                    )
+        Column {
+            Row(
+                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)
+                }
+                rowButton()
+            }
+            if (expanded) {
+                statistics?.peers()?.forEach {
+                    Row(
+                        modifier =
+                        Modifier
+                            .fillMaxWidth()
+                            .padding(end = 10.dp, bottom = 10.dp, start = 10.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.SpaceEvenly
+                    ) {
+                        val handshakeEpoch = statistics.peer(it)!!.latestHandshakeEpochMillis
+                        val peerTx = statistics.peer(it)!!.txBytes
+                        val peerRx = statistics.peer(it)!!.rxBytes
+                        val peerId = it.toBase64().subSequence(0, 3).toString() + "***"
+                        val handshakeSec =
+                            NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch)
+                        val handshake =
+                            if (handshakeSec == null) "never" else "$handshakeSec secs ago"
+                        val peerTxMB = NumberUtils.bytesToMB(peerTx).toThreeDecimalPlaceString()
+                        val peerRxMB = NumberUtils.bytesToMB(peerRx).toThreeDecimalPlaceString()
+                        val fontSize = 9.sp
+                        Text("peer: $peerId", fontSize = fontSize)
+                        Text("handshake: $handshake", fontSize = fontSize)
+                        Text("tx: $peerTxMB MB", fontSize = fontSize)
+                        Text("rx: $peerRxMB MB", fontSize = fontSize)
+                    }
                }
-                Text(text)
            }
-
-            rowButton()
        }
    }
-}
+}
@@ -0,0 +1,80 @@
+package com.zaneschepke.wireguardautotunnel.ui.common
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Clear
+import androidx.compose.material.icons.rounded.Search
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextField
+import androidx.compose.material3.TextFieldDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.KeyboardType
+import com.zaneschepke.wireguardautotunnel.R
+
+@Composable
+fun SearchBar(onQuery: (queryString: String) -> Unit) {
+    // Immediately update and keep track of query from text field changes.
+    var query: String by rememberSaveable { mutableStateOf("") }
+    var showClearIcon by rememberSaveable { mutableStateOf(false) }
+
+    if (query.isEmpty()) {
+        showClearIcon = false
+    } else if (query.isNotEmpty()) {
+        showClearIcon = true
+    }
+
+    TextField(
+        value = query,
+        onValueChange = { onQueryChanged ->
+            // If user makes changes to text, immediately updated it.
+            query = onQueryChanged
+            onQuery(onQueryChanged)
+        },
+        leadingIcon = {
+            Icon(
+                imageVector = Icons.Rounded.Search,
+                tint = MaterialTheme.colorScheme.onBackground,
+                contentDescription = stringResource(id = R.string.search_icon)
+            )
+        },
+        trailingIcon = {
+            if (showClearIcon) {
+                IconButton(onClick = { query = "" }) {
+                    Icon(
+                        imageVector = Icons.Rounded.Clear,
+                        tint = MaterialTheme.colorScheme.onBackground,
+                        contentDescription = stringResource(id = R.string.clear_icon)
+                    )
+                }
+            }
+        },
+        maxLines = 1,
+        colors =
+        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)
+    )
+}
@@ -0,0 +1,40 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.config
+
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
+
+@Composable
+fun ConfigurationTextBox(
+    value: String,
+    hint: String,
+    onValueChange: (String) -> Unit,
+    keyboardActions: KeyboardActions,
+    label: String,
+    modifier: Modifier
+) {
+    OutlinedTextField(
+        modifier = modifier,
+        value = value,
+        singleLine = true,
+        onValueChange = {
+            onValueChange(it)
+        },
+        label = { Text(label) },
+        maxLines = 1,
+        placeholder = {
+            Text(hint)
+        },
+        keyboardOptions =
+        KeyboardOptions(
+            capitalization = KeyboardCapitalization.None,
+            imeAction = ImeAction.Done
+        ),
+        keyboardActions = keyboardActions
+    )
+}
@@ -0,0 +1,41 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.config
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.Dp
+
+@Composable
+fun ConfigurationToggle(
+    label: String,
+    enabled: Boolean,
+    checked: Boolean,
+    padding: Dp,
+    onCheckChanged: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    Row(
+        modifier =
+        Modifier
+            .fillMaxWidth()
+            .padding(padding),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.SpaceBetween
+    ) {
+        Text(label)
+        Switch(
+            modifier = modifier,
+            enabled = enabled,
+            checked = checked,
+            onCheckedChange = {
+                onCheckChanged()
+            }
+        )
+    }
+}
@@ -11,12 +11,14 @@ import androidx.navigation.NavController
 import androidx.navigation.compose.currentBackStackEntryAsState

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

    NavigationBar(
-        containerColor = MaterialTheme.colorScheme.background,
+        containerColor = MaterialTheme.colorScheme.background
    ) {
        bottomNavItems.forEach { item ->
            val selected = item.route == backStackEntry.value?.destination?.route
@@ -27,16 +29,16 @@ fun BottomNavBar(navController : NavController, bottomNavItems : List<BottomNavI
                label = {
                    Text(
                        text = item.name,
-                        fontWeight = FontWeight.SemiBold,
+                        fontWeight = FontWeight.SemiBold
                    )
                },
                icon = {
                    Icon(
                        imageVector = item.icon,
-                        contentDescription = "${item.name} Icon",
+                        contentDescription = "${item.name} Icon"
                    )
                }
            )
        }
    }
-}
+}
@@ -0,0 +1,97 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.prompt
+
+import androidx.biometric.BiometricManager
+import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_WEAK
+import androidx.biometric.BiometricManager.Authenticators.DEVICE_CREDENTIAL
+import androidx.biometric.BiometricPrompt
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalContext
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.FragmentActivity
+
+@Composable
+fun AuthorizationPrompt(
+    onSuccess: () -> Unit,
+    onFailure: () -> Unit,
+    onError: (String) -> Unit
+) {
+    val context = LocalContext.current
+    val biometricManager = BiometricManager.from(context)
+    val bio = biometricManager.canAuthenticate(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
+    val isBiometricAvailable =
+        remember {
+            when (bio) {
+                BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
+                    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
+            }
+        }
+    if (isBiometricAvailable) {
+        val executor = remember { ContextCompat.getMainExecutor(context) }
+
+        val promptInfo =
+            BiometricPrompt.PromptInfo.Builder()
+                .setAllowedAuthenticators(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
+                .setTitle("Biometric Authentication")
+                .setSubtitle("Log in using your biometric credential")
+                .build()
+
+        val biometricPrompt =
+            BiometricPrompt(
+                context as FragmentActivity,
+                executor,
+                object : BiometricPrompt.AuthenticationCallback() {
+                    override fun onAuthenticationError(
+                        errorCode: Int,
+                        errString: CharSequence
+                    ) {
+                        super.onAuthenticationError(errorCode, errString)
+                        onFailure()
+                    }
+
+                    override fun onAuthenticationSucceeded(
+                        result: BiometricPrompt.AuthenticationResult
+                    ) {
+                        super.onAuthenticationSucceeded(result)
+                        onSuccess()
+                    }
+
+                    override fun onAuthenticationFailed() {
+                        super.onAuthenticationFailed()
+                        onFailure()
+                    }
+                }
+            )
+        biometricPrompt.authenticate(promptInfo)
+    }
+}
@@ -0,0 +1,64 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.prompt
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.IntrinsicSize
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Info
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Snackbar
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.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
+fun CustomSnackBar(
+    message: String,
+    isRtl: Boolean = true,
+    containerColor: Color = MaterialTheme.colorScheme.surface
+) {
+    val context = LocalContext.current
+    Snackbar(
+        containerColor = containerColor,
+        modifier =
+        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),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.Start
+            ) {
+                Icon(
+                    Icons.Rounded.Info,
+                    contentDescription = stringResource(R.string.info),
+                    tint = Color.White,
+                    modifier = Modifier.padding(end = 10.dp)
+                )
+                Text(message, color = Color.White, modifier = Modifier.padding(end = 5.dp))
+            }
+        }
+    }
+}
@@ -0,0 +1,22 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.screen
+
+import androidx.compose.foundation.focusable
+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.CircularProgressIndicator
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun LoadingScreen() {
+  Column(
+      horizontalAlignment = Alignment.CenterHorizontally,
+      verticalArrangement = Arrangement.Top,
+      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.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+
+@Composable
+fun SectionTitle(
+    title: String,
+    padding: Dp
+) {
+    Text(
+        title,
+        textAlign = TextAlign.Center,
+        style = TextStyle(fontSize = 18.sp, fontWeight = FontWeight.ExtraBold),
+        modifier = Modifier.padding(padding, bottom = 5.dp, top = 5.dp)
+    )
+}
@@ -0,0 +1,30 @@
+package com.zaneschepke.wireguardautotunnel.ui.models
+
+import com.wireguard.config.Interface
+
+data class InterfaceProxy(
+    var privateKey: String = "",
+    var publicKey: String = "",
+    var addresses: String = "",
+    var dnsServers: String = "",
+    var listenPort: String = "",
+    var mtu: String = ""
+) {
+    companion object {
+        fun from(i: Interface): InterfaceProxy {
+            return InterfaceProxy(
+                publicKey = i.keyPair.publicKey.toBase64().trim(),
+                privateKey = i.keyPair.privateKey.toBase64().trim(),
+                addresses = i.addresses.joinToString(", ").trim(),
+                dnsServers = i.dnsServers.joinToString(", ").replace("/", "").trim(),
+                listenPort = if (i.listenPort.isPresent) {
+                    i.listenPort.get().toString()
+                    .trim()
+                } else {
+                    ""
+                },
+                mtu = if (i.mtu.isPresent) i.mtu.get().toString().trim() else ""
+            )
+        }
+    }
+}
@@ -0,0 +1,49 @@
+package com.zaneschepke.wireguardautotunnel.ui.models
+
+import com.wireguard.config.Peer
+
+data class PeerProxy(
+    var publicKey: String = "",
+    var preSharedKey: String = "",
+    var persistentKeepalive: String = "",
+    var endpoint: String = "",
+    var allowedIps: String = IPV4_WILDCARD.joinToString(", ").trim()
+) {
+    companion object {
+        fun from(peer: Peer): PeerProxy {
+            return PeerProxy(
+                publicKey = peer.publicKey.toBase64(),
+                preSharedKey = if (peer.preSharedKey.isPresent) {
+                    peer.preSharedKey.get().toBase64()
+                    .trim()
+                } else {
+                    ""
+                },
+                persistentKeepalive = if (peer.persistentKeepalive.isPresent) {
+                    peer.persistentKeepalive.get()
+                    .toString().trim()
+                } else {
+                    ""
+                },
+                endpoint = if (peer.endpoint.isPresent) {
+                    peer.endpoint.get().toString()
+                    .trim()
+                } else {
+                    ""
+                },
+                allowedIps = peer.allowedIps.joinToString(", ").trim()
+            )
+        }
+
+        val IPV4_PUBLIC_NETWORKS =
+            setOf(
+                "0.0.0.0/5", "8.0.0.0/7", "11.0.0.0/8", "12.0.0.0/6", "16.0.0.0/4", "32.0.0.0/3",
+                "64.0.0.0/2", "128.0.0.0/3", "160.0.0.0/5", "168.0.0.0/6", "172.0.0.0/12",
+                "172.32.0.0/11", "172.64.0.0/10", "172.128.0.0/9", "173.0.0.0/8", "174.0.0.0/7",
+                "176.0.0.0/4", "192.0.0.0/9", "192.128.0.0/11", "192.160.0.0/13", "192.169.0.0/16",
+                "192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10",
+                "193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6", "200.0.0.0/5", "208.0.0.0/4"
+            )
+        val IPV4_WILDCARD = setOf("0.0.0.0/0")
+    }
+}
@@ -1,233 +1,550 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.config

-import android.widget.Toast
+import android.annotation.SuppressLint
+import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.Image
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.IntrinsicSize
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+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.size
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
+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.rounded.Android
-import androidx.compose.material3.Button
+import androidx.compose.material.icons.rounded.ContentCopy
+import androidx.compose.material.icons.rounded.Delete
+import androidx.compose.material.icons.rounded.Refresh
+import androidx.compose.material.icons.rounded.Save
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Checkbox
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FabPosition
+import androidx.compose.material3.FloatingActionButton
 import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.ExperimentalComposeUiApi
 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.graphics.Color
+import androidx.compose.ui.platform.ClipboardManager
+import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.text.input.VisualTransformation
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
 import com.google.accompanist.drawablepainter.DrawablePainter
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.Routes
-import kotlinx.coroutines.launch
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.ui.Screen
+import com.zaneschepke.wireguardautotunnel.ui.common.SearchBar
+import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationTextBox
+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.Constants
+import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.util.Result
+import kotlinx.coroutines.delay

-@OptIn(ExperimentalComposeUiApi::class)
+@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
+@OptIn(
+    ExperimentalComposeUiApi::class,
+    ExperimentalMaterial3Api::class,
+    ExperimentalFoundationApi::class)
@Composable
 fun ConfigScreen(
    viewModel: ConfigViewModel = hiltViewModel(),
-    padding: PaddingValues,
+    focusRequester: FocusRequester,
    navController: NavController,
-    id : String?
+    showSnackbarMessage: (String) -> Unit,
+    id: String
 ) {
+  val context = LocalContext.current
+  val clipboardManager: ClipboardManager = LocalClipboardManager.current
+  val keyboardController = LocalSoftwareKeyboardController.current
+  var showApplicationsDialog by remember { mutableStateOf(false) }
+  var showAuthPrompt by remember { mutableStateOf(false) }
+  var isAuthenticated by remember { mutableStateOf(false) }

-    val context = LocalContext.current
-    val focusManager = LocalFocusManager.current
-    val keyboardController = LocalSoftwareKeyboardController.current
-    val scope = rememberCoroutineScope()
-    val tunnel by viewModel.tunnel.collectAsStateWithLifecycle(null)
-    val tunnelName = viewModel.tunnelName.collectAsStateWithLifecycle()
-    val packages by viewModel.packages.collectAsStateWithLifecycle()
-    val checkedPackages by viewModel.checkedPackages.collectAsStateWithLifecycle()
-    val include by viewModel.include.collectAsStateWithLifecycle()
-    val allApplications by viewModel.allApplications.collectAsStateWithLifecycle()
+  val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    LaunchedEffect(Unit) {
-        viewModel.getTunnelById(id)
-        viewModel.emitAllInternetCapablePackages()
-        viewModel.emitCurrentPackageConfigurations(id)
+        viewModel.init(id)
    }

-    if(tunnel != null) {
-        LazyColumn(
-            horizontalAlignment = Alignment.Start,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-            item {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 20.dp, vertical = 7.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceBetween
-                ) {
-                    OutlinedTextField(
-                        value = tunnelName.value,
-                        onValueChange = {
-                            viewModel.onTunnelNameChange(it)
-                        },
-                        label = { Text(stringResource(id = R.string.tunnel_name)) },
-                        maxLines = 1,
-                        keyboardOptions = KeyboardOptions(
-                            capitalization = KeyboardCapitalization.None,
-                            imeAction = ImeAction.Done
-                        ),
-                        keyboardActions = KeyboardActions(
-                            onDone = {
-                                focusManager.clearFocus()
-                                keyboardController?.hide()
-                                viewModel.onTunnelNameChange(tunnelName.value)
-                            }
-                        ),
-                    )
-                }
-            }
-            item {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 20.dp, vertical = 7.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceBetween
-                ) {
+  LaunchedEffect(uiState.loading) {
+    if(!uiState.loading && WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+        delay(Constants.FOCUS_REQUEST_DELAY)
+        focusRequester.requestFocus()
+    }
+  }
+
+  if (uiState.loading) {
+    LoadingScreen()
+      return
+  }
+
+  val keyboardActions = KeyboardActions(onDone = { keyboardController?.hide() })
+
+  val keyboardOptions =
+      KeyboardOptions(imeAction = ImeAction.Done)
+
+  val fillMaxHeight = .85f
+  val fillMaxWidth = .85f
+  val screenPadding = 5.dp
+
+  val applicationButtonText = {
+    "Tunneling apps: " +
+        if (uiState.isAllApplicationsEnabled) {
+          "all"
+        } else {
+          "${uiState.checkedPackageNames.size} " + (if (uiState.include) "included" else "excluded")
+        }
+  }
+
+  if (showAuthPrompt) {
+    AuthorizationPrompt(
+        onSuccess = {
+          showAuthPrompt = false
+          isAuthenticated = true
+        },
+        onError = { error ->
+          showAuthPrompt = false
+          showSnackbarMessage(Event.Error.AuthenticationFailed.message)
+        },
+        onFailure = {
+          showAuthPrompt = false
+          showSnackbarMessage(Event.Error.AuthorizationFailed.message)
+        })
+  }
+
+  if (showApplicationsDialog) {
+    val sortedPackages =
+        remember(uiState.packages) { uiState.packages.sortedBy { viewModel.getPackageLabel(it) } }
+    AlertDialog(onDismissRequest = { showApplicationsDialog = false }) {
+      Surface(
+          tonalElevation = 2.dp,
+          shadowElevation = 2.dp,
+          shape = RoundedCornerShape(12.dp),
+          color = MaterialTheme.colorScheme.surface,
+          modifier =
+              Modifier.fillMaxWidth()
+                  .fillMaxHeight(if (uiState.isAllApplicationsEnabled) 1 / 5f else 4 / 5f)) {
+            Column(modifier = Modifier.fillMaxWidth()) {
+              Row(
+                  modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 7.dp),
+                  verticalAlignment = Alignment.CenterVertically,
+                  horizontalArrangement = Arrangement.SpaceBetween) {
                    Text(stringResource(id = R.string.tunnel_all))
                    Switch(
-                        checked = allApplications,
-                        onCheckedChange = {
-                            viewModel.onAllApplicationsChange(!allApplications)
-                        }
-                    )
-                }
-            }
-                if (!allApplications) {
-                    item {
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(horizontal = 20.dp, vertical = 7.dp),
-                            verticalAlignment = Alignment.CenterVertically,
-                            horizontalArrangement = Arrangement.SpaceBetween
-                        ) {
-                            Row(
-                                verticalAlignment = Alignment.CenterVertically,
-                                horizontalArrangement = Arrangement.SpaceBetween
-                            ) {
-                                Text(stringResource(id = R.string.include))
-                                Checkbox(
-                                    checked = include,
-                                    onCheckedChange = {
-                                        viewModel.onIncludeChange(!include)
-                                    }
-                                )
-                            }
-                            Row(
-                                verticalAlignment = Alignment.CenterVertically,
-                                horizontalArrangement = Arrangement.SpaceBetween
-                            ) {
-                                Text(stringResource(id = R.string.exclude))
-                                Checkbox(
-                                    checked = !include,
-                                    onCheckedChange = {
-                                        viewModel.onIncludeChange(!include)
-                                    }
-                                )
-                            }
-                        }
+                        checked = uiState.isAllApplicationsEnabled,
+                        onCheckedChange = { viewModel.onAllApplicationsChange(it) })
+                  }
+              if (!uiState.isAllApplicationsEnabled) {
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 7.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.SpaceBetween) {
+                      Row(
+                          verticalAlignment = Alignment.CenterVertically,
+                          horizontalArrangement = Arrangement.SpaceBetween) {
+                            Text(stringResource(id = R.string.include))
+                            Checkbox(
+                                checked = uiState.include,
+                                onCheckedChange = { viewModel.onIncludeChange(!uiState.include) })
+                          }
+                      Row(
+                          verticalAlignment = Alignment.CenterVertically,
+                          horizontalArrangement = Arrangement.SpaceBetween) {
+                            Text(stringResource(id = R.string.exclude))
+                            Checkbox(
+                                checked = !uiState.include,
+                                onCheckedChange = { viewModel.onIncludeChange(!uiState.include) })
+                          }
                    }
-//                    LazyColumn(
-//                        modifier = Modifier
-//                            .fillMaxWidth()
-//                            .fillMaxHeight(.75f)
-//                            .padding(horizontal = 14.dp, vertical = 7.dp),
-//                        verticalArrangement = Arrangement.Center,
-//                        horizontalAlignment = Alignment.Start
-//                    ) {
-                    items(packages) { pack ->
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 7.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.SpaceBetween) {
+                      SearchBar(viewModel::emitQueriedPackages)
+                    }
+                Spacer(Modifier.padding(5.dp))
+                LazyColumn(
+                    horizontalAlignment = Alignment.Start,
+                    verticalArrangement = Arrangement.Top,
+                    modifier = Modifier.fillMaxHeight(4 / 5f)) {
+                      items(sortedPackages, key = { it.packageName }) { pack ->
                        Row(
                            verticalAlignment = Alignment.CenterVertically,
-                            horizontalArrangement = Arrangement.SpaceBetween
-                        ) {
-                            Row(
-                                horizontalArrangement = Arrangement.Center,
-                                verticalAlignment = Alignment.CenterVertically,
-                                modifier = Modifier.padding(5.dp)
-                            ) {
+                            horizontalArrangement = Arrangement.SpaceBetween,
+                            modifier = Modifier.fillMaxSize().padding(5.dp)) {
+                              Row(modifier = Modifier.fillMaxWidth(fillMaxWidth)) {
                                val drawable =
                                    pack.applicationInfo?.loadIcon(context.packageManager)
                                if (drawable != null) {
-                                    Image(
-                                        painter = DrawablePainter(drawable),
-                                        stringResource(id = R.string.icon),
-                                        modifier = Modifier.size(50.dp, 50.dp)
-                                    )
+                                  Image(
+                                      painter = DrawablePainter(drawable),
+                                      stringResource(id = R.string.icon),
+                                      modifier = Modifier.size(50.dp, 50.dp))
                                } else {
-                                    Icon(
-                                        Icons.Rounded.Android,
-                                        stringResource(id = R.string.edit),
-                                        modifier = Modifier.size(50.dp, 50.dp)
-                                    )
+                                  Icon(
+                                      Icons.Rounded.Android,
+                                      stringResource(id = R.string.edit),
+                                      modifier = Modifier.size(50.dp, 50.dp))
                                }
                                Text(
-                                    pack.applicationInfo.loadLabel(context.packageManager)
-                                        .toString(), modifier = Modifier.padding(5.dp)
-                                )
+                                    viewModel.getPackageLabel(pack),
+                                    modifier = Modifier.padding(5.dp))
+                              }
+                              Checkbox(
+                                  modifier = Modifier.fillMaxSize(),
+                                  checked =
+                                      (uiState.checkedPackageNames.contains(pack.packageName)),
+                                  onCheckedChange = {
+                                    if (it) {
+                                      viewModel.onAddCheckedPackage(pack.packageName)
+                                    } else {
+                                      viewModel.onRemoveCheckedPackage(pack.packageName)
+                                    }
+                                  })
                            }
-                            Checkbox(
-                                checked = (checkedPackages.contains(pack.packageName)),
-                                onCheckedChange = {
-                                    if (it) viewModel.onAddCheckedPackage(pack.packageName) else viewModel.onRemoveCheckedPackage(
-                                        pack.packageName
-                                    )
-                                }
-                            )
-                        }
+                      }
                    }
-                }
-            item {
-                Row(
-                    horizontalArrangement = Arrangement.Center,
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    Button(onClick = {
-                        scope.launch {
-                            viewModel.onSaveAllChanges()
-                            Toast.makeText(
-                                context,
-                                context.resources.getString(R.string.config_changes_saved),
-                                Toast.LENGTH_LONG
-                            ).show()
-                            navController.navigate(Routes.Main.name)
-                        }
-                    }, Modifier.padding(25.dp)) {
-                        Text(stringResource(id = R.string.save_changes))
+              }
+              Row(
+                  verticalAlignment = Alignment.CenterVertically,
+                  modifier = Modifier.fillMaxSize().padding(top = 5.dp),
+                  horizontalArrangement = Arrangement.Center) {
+                    TextButton(onClick = { showApplicationsDialog = false }) {
+                      Text(stringResource(R.string.done))
                    }
-                }
+                  }
            }
-        }
+          }
    }
-}
+  }
+
+    Scaffold(
+        floatingActionButtonPosition = FabPosition.End,
+        floatingActionButton = {
+          val secondaryColor = MaterialTheme.colorScheme.secondary
+          val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
+          var fobColor by remember { mutableStateOf(secondaryColor) }
+          FloatingActionButton(
+              modifier =
+                  Modifier.padding(bottom = 90.dp).onFocusChanged {
+                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                      fobColor = if (it.isFocused) hoverColor else secondaryColor
+                    }
+                  },
+              onClick = {
+                viewModel.onSaveAllChanges().let {
+                  when (it) {
+                    is Result.Success -> {
+                      showSnackbarMessage(it.data.message)
+                      navController.navigate(Screen.Main.route)
+                    }
+                    is Result.Error -> showSnackbarMessage(it.error.message)
+                  }
+                }
+              },
+              containerColor = fobColor,
+              shape = RoundedCornerShape(16.dp)) {
+                Icon(
+                    imageVector = Icons.Rounded.Save,
+                    contentDescription = stringResource(id = R.string.save_changes),
+                    tint = Color.DarkGray)
+              }
+        }) {
+          Column {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Top,
+                modifier =
+                    Modifier.verticalScroll(rememberScrollState()).weight(1f, true).fillMaxSize()) {
+                  Surface(
+                      tonalElevation = 2.dp,
+                      shadowElevation = 2.dp,
+                      shape = RoundedCornerShape(12.dp),
+                      color = MaterialTheme.colorScheme.surface,
+                      modifier =
+                          (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                                Modifier.fillMaxHeight(fillMaxHeight).fillMaxWidth(fillMaxWidth)
+                              } else {
+                                Modifier.fillMaxWidth(fillMaxWidth)
+                              })
+                              .padding(top = 50.dp, bottom = 10.dp)) {
+                        Column(
+                            horizontalAlignment = Alignment.Start,
+                            verticalArrangement = Arrangement.Top,
+                            modifier = Modifier.padding(15.dp).focusGroup()) {
+                              SectionTitle(
+                                  stringResource(R.string.interface_), padding = screenPadding)
+                              ConfigurationTextBox(
+                                  value = uiState.tunnelName,
+                                  onValueChange = { value -> viewModel.onTunnelNameChange(value) },
+                                  keyboardActions = keyboardActions,
+                                  label = stringResource(R.string.name),
+                                  hint = stringResource(R.string.tunnel_name).lowercase(),
+                                  modifier =
+                                      Modifier
+                                          .fillMaxWidth()
+                                          .focusRequester(focusRequester))
+                              OutlinedTextField(
+                                  modifier =
+                                      Modifier.fillMaxWidth().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,
+                                  onValueChange = { value -> viewModel.onPrivateKeyChange(value) },
+                                  trailingIcon = {
+                                    IconButton(
+                                        modifier = Modifier.focusRequester(FocusRequester.Default),
+                                        onClick = { viewModel.generateKeyPair() }) {
+                                          Icon(
+                                              Icons.Rounded.Refresh,
+                                              stringResource(R.string.rotate_keys),
+                                              tint = Color.White)
+                                        }
+                                  },
+                                  label = { Text(stringResource(R.string.private_key)) },
+                                  singleLine = true,
+                                  placeholder = { Text(stringResource(R.string.base64_key)) },
+                                  keyboardOptions = keyboardOptions,
+                                  keyboardActions = keyboardActions)
+                              OutlinedTextField(
+                                  modifier =
+                                      Modifier
+                                          .fillMaxWidth()
+                                          .focusRequester(FocusRequester.Default),
+                                  value = uiState.interfaceProxy.publicKey,
+                                  enabled = false,
+                                  onValueChange = {},
+                                  trailingIcon = {
+                                    IconButton(
+                                        modifier = Modifier.focusRequester(FocusRequester.Default),
+                                        onClick = {
+                                          clipboardManager.setText(
+                                              AnnotatedString(uiState.interfaceProxy.publicKey))
+                                        }) {
+                                          Icon(
+                                              Icons.Rounded.ContentCopy,
+                                              stringResource(R.string.copy_public_key),
+                                              tint = Color.White)
+                                        }
+                                  },
+                                  label = { Text(stringResource(R.string.public_key)) },
+                                  singleLine = true,
+                                  placeholder = { Text(stringResource(R.string.base64_key)) },
+                                  keyboardOptions = keyboardOptions,
+                                  keyboardActions = keyboardActions)
+                              Row(modifier = Modifier.fillMaxWidth()) {
+                                ConfigurationTextBox(
+                                    value = uiState.interfaceProxy.addresses,
+                                    onValueChange = { value ->
+                                      viewModel.onAddressesChanged(value)
+                                    },
+                                    keyboardActions = keyboardActions,
+                                    label = stringResource(R.string.addresses),
+                                    hint = stringResource(R.string.comma_separated_list),
+                                    modifier =
+                                        Modifier
+                                            .fillMaxWidth(3 / 5f)
+                                            .padding(end = 5.dp))
+                                ConfigurationTextBox(
+                                    value = uiState.interfaceProxy.listenPort,
+                                    onValueChange = { value ->
+                                      viewModel.onListenPortChanged(value)
+                                    },
+                                    keyboardActions = keyboardActions,
+                                    label = stringResource(R.string.listen_port),
+                                    hint = stringResource(R.string.random),
+                                    modifier = Modifier.width(IntrinsicSize.Min))
+                              }
+                              Row(modifier = Modifier.fillMaxWidth()) {
+                                ConfigurationTextBox(
+                                    value = uiState.interfaceProxy.dnsServers,
+                                    onValueChange = { value ->
+                                      viewModel.onDnsServersChanged(value)
+                                    },
+                                    keyboardActions = keyboardActions,
+                                    label = stringResource(R.string.dns_servers),
+                                    hint = stringResource(R.string.comma_separated_list),
+                                    modifier =
+                                        Modifier
+                                            .fillMaxWidth(3 / 5f)
+                                            .padding(end = 5.dp))
+                                ConfigurationTextBox(
+                                    value = uiState.interfaceProxy.mtu,
+                                    onValueChange = { value -> viewModel.onMtuChanged(value) },
+                                    keyboardActions = keyboardActions,
+                                    label = stringResource(R.string.mtu),
+                                    hint = stringResource(R.string.auto),
+                                    modifier = Modifier.width(IntrinsicSize.Min))
+                              }
+                              Row(
+                                  verticalAlignment = Alignment.CenterVertically,
+                                  modifier = Modifier.fillMaxSize().padding(top = 5.dp),
+                                  horizontalArrangement = Arrangement.Center) {
+                                    TextButton(onClick = { showApplicationsDialog = true }) {
+                                      Text(applicationButtonText())
+                                    }
+                                  }
+                            }
+                      }
+                  uiState.proxyPeers.forEachIndexed { index, peer ->
+                    Surface(
+                        tonalElevation = 2.dp,
+                        shadowElevation = 2.dp,
+                        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)) {
+                          Column(
+                              horizontalAlignment = Alignment.Start,
+                              verticalArrangement = Arrangement.Top,
+                              modifier =
+                                  Modifier.padding(horizontal = 15.dp).padding(bottom = 10.dp)) {
+                                Row(
+                                    horizontalArrangement = Arrangement.SpaceBetween,
+                                    verticalAlignment = Alignment.CenterVertically,
+                                    modifier = Modifier.fillMaxWidth().padding(horizontal = 5.dp)) {
+                                      SectionTitle(
+                                          stringResource(R.string.peer), padding = screenPadding)
+                                      IconButton(onClick = { viewModel.onDeletePeer(index) }) {
+                                        Icon(Icons.Rounded.Delete, stringResource(R.string.delete))
+                                      }
+                                    }
+
+                                ConfigurationTextBox(
+                                    value = peer.publicKey,
+                                    onValueChange = { value ->
+                                      viewModel.onPeerPublicKeyChange(index, value)
+                                    },
+                                    keyboardActions = keyboardActions,
+                                    label = stringResource(R.string.public_key),
+                                    hint = stringResource(R.string.base64_key),
+                                    modifier = Modifier.fillMaxWidth())
+                                ConfigurationTextBox(
+                                    value = peer.preSharedKey,
+                                    onValueChange = { value ->
+                                      viewModel.onPreSharedKeyChange(index, value)
+                                    },
+                                    keyboardActions = keyboardActions,
+                                    label = stringResource(R.string.preshared_key),
+                                    hint = stringResource(R.string.optional),
+                                    modifier = Modifier.fillMaxWidth())
+                                OutlinedTextField(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    value = peer.persistentKeepalive,
+                                    enabled = true,
+                                    onValueChange = { value ->
+                                      viewModel.onPersistentKeepaliveChanged(index, value)
+                                    },
+                                    trailingIcon = {
+                                      Text(
+                                          stringResource(R.string.seconds),
+                                          modifier = Modifier.padding(end = 10.dp))
+                                    },
+                                    label = { Text(stringResource(R.string.persistent_keepalive)) },
+                                    singleLine = true,
+                                    placeholder = {
+                                      Text(stringResource(R.string.optional_no_recommend))
+                                    },
+                                    keyboardOptions = keyboardOptions,
+                                    keyboardActions = keyboardActions)
+                                ConfigurationTextBox(
+                                    value = peer.endpoint,
+                                    onValueChange = { value ->
+                                      viewModel.onEndpointChange(index, value)
+                                    },
+                                    keyboardActions = keyboardActions,
+                                    label = stringResource(R.string.endpoint),
+                                    hint = stringResource(R.string.endpoint).lowercase(),
+                                    modifier = Modifier.fillMaxWidth())
+                                OutlinedTextField(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    value = peer.allowedIps,
+                                    enabled = true,
+                                    onValueChange = { value ->
+                                      viewModel.onAllowedIpsChange(index, value)
+                                    },
+                                    label = { Text(stringResource(R.string.allowed_ips)) },
+                                    singleLine = true,
+                                    placeholder = {
+                                      Text(stringResource(R.string.comma_separated_list))
+                                    },
+                                    keyboardOptions = keyboardOptions,
+                                    keyboardActions = keyboardActions)
+                              }
+                        }
+                  }
+                  Row(
+                      horizontalArrangement = Arrangement.SpaceEvenly,
+                      verticalAlignment = Alignment.CenterVertically,
+                      modifier = Modifier.fillMaxSize().padding(bottom = 140.dp)) {
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.Center) {
+                              TextButton(onClick = { viewModel.addEmptyPeer() }) {
+                                Text(stringResource(R.string.add_peer))
+                              }
+                            }
+                      }
+                }
+            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+              Spacer(modifier = Modifier.weight(.17f))
+            }
+          }
+        }
+}
@@ -0,0 +1,18 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.config
+
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.ui.models.InterfaceProxy
+import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
+import com.zaneschepke.wireguardautotunnel.util.Packages
+
+data class ConfigUiState(
+    val proxyPeers: List<PeerProxy> = arrayListOf(PeerProxy()),
+    val interfaceProxy: InterfaceProxy = InterfaceProxy(),
+    val packages: Packages = emptyList(),
+    val checkedPackageNames: List<String> = emptyList(),
+    val include: Boolean = true,
+    val isAllApplicationsEnabled : Boolean = false,
+    val loading: Boolean = true,
+    val tunnel: TunnelConfig? = null,
+    val tunnelName: String = ""
+)
@@ -5,142 +5,308 @@ import android.app.Application
 import android.content.pm.PackageInfo
 import android.content.pm.PackageManager
 import android.os.Build
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.toMutableStateList
 import androidx.lifecycle.ViewModel
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
+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.ui.models.InterfaceProxy
+import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.util.NumberUtils
+import com.zaneschepke.wireguardautotunnel.util.Result
+import com.zaneschepke.wireguardautotunnel.util.removeAt
+import com.zaneschepke.wireguardautotunnel.util.update
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import timber.log.Timber
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
 import javax.inject.Inject

@HiltViewModel
-class ConfigViewModel @Inject constructor(private val application : Application,
-                                          private val tunnelRepo : Repository<TunnelConfig>,
-                                          private val settingsRepo : Repository<Settings>) : ViewModel() {
+class ConfigViewModel
+@Inject
+constructor(
+    private val application: Application,
+    private val tunnelConfigRepository: TunnelConfigRepository,
+    private val settingsRepository: SettingsRepository,
+) : ViewModel() {

-    private val _tunnel = MutableStateFlow<TunnelConfig?>(null)
-    private val _tunnelName = MutableStateFlow("")
-    val tunnelName get() = _tunnelName.asStateFlow()
-    val tunnel get() = _tunnel.asStateFlow()
-    private val _packages = MutableStateFlow(emptyList<PackageInfo>())
-    val packages get() = _packages.asStateFlow()
-    private val packageManager = application.packageManager
+  private val packageManager = application.packageManager

-    private val _checkedPackages = MutableStateFlow(mutableStateListOf<String>())
-    val checkedPackages get() = _checkedPackages.asStateFlow()
-    private val _include = MutableStateFlow(true)
-    val include get() = _include.asStateFlow()
+  private val _uiState = MutableStateFlow(ConfigUiState())
+  val uiState = _uiState.asStateFlow()

-    private val _allApplications = MutableStateFlow(true)
-    val allApplications get() = _allApplications.asStateFlow()
-
-    suspend fun getTunnelById(id : String?) : TunnelConfig? {
-        return try {
-            if(id != null) {
-                val config = tunnelRepo.getById(id.toLong())
-                if (config != null) {
-                    _tunnel.emit(config)
-                    _tunnelName.emit(config.name)
-
-                }
-                return config
-            }
-            return null
-        } catch (e : Exception) {
-            Timber.e(e.message)
-            null
-        }
-    }
-
-    fun onTunnelNameChange(name : String) {
-        _tunnelName.value = name
-    }
-
-    fun onIncludeChange(include : Boolean) {
-        _include.value = include
-    }
-    fun onAddCheckedPackage(packageName : String) {
-        _checkedPackages.value.add(packageName)
-    }
-
-    fun onAllApplicationsChange(allApplications : Boolean) {
-        _allApplications.value = allApplications
-    }
-
-    fun onRemoveCheckedPackage(packageName : String) {
-        _checkedPackages.value.remove(packageName)
-    }
-
-    suspend fun emitCurrentPackageConfigurations(id : String?) {
-        val tunnelConfig = getTunnelById(id)
-        if(tunnelConfig != null) {
-            val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val excludedApps = config.`interface`.excludedApplications
-            val includedApps = config.`interface`.includedApplications
-            if(excludedApps.isNullOrEmpty() && includedApps.isNullOrEmpty()) {
-                _allApplications.emit(true)
-                return
-            }
-            if(excludedApps.isEmpty()) {
-                _include.emit(true)
-                _checkedPackages.emit(includedApps.toMutableStateList())
-            } else {
-                _include.emit(false)
-                _checkedPackages.emit(excludedApps.toMutableStateList())
-            }
-            _allApplications.emit(false)
-        }
-    }
-
-    suspend fun emitAllInternetCapablePackages() {
-        _packages.emit(getAllInternetCapablePackages())
-    }
-
-    private fun getAllInternetCapablePackages() : List<PackageInfo> {
-        return getPackagesHoldingPermissions(arrayOf(Manifest.permission.INTERNET))
-    }
-
-    private fun getPackagesHoldingPermissions(permissions: Array<String>): List<PackageInfo> {
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            packageManager.getPackagesHoldingPermissions(permissions, PackageManager.PackageInfoFlags.of(0L))
-        } else {
-            @Suppress("DEPRECATION")
-            packageManager.getPackagesHoldingPermissions(permissions, 0)
-        }
-    }
-
-    suspend fun onSaveAllChanges() {
-        var wgQuick = _tunnel.value?.wgQuick
-        if(wgQuick != null) {
-            wgQuick = if(_include.value) {
-                TunnelConfig.setIncludedApplicationsOnQuick(_checkedPackages.value, wgQuick)
-            } else {
-                TunnelConfig.setExcludedApplicationsOnQuick(_checkedPackages.value, wgQuick)
-            }
-            if(_allApplications.value) {
-                wgQuick = TunnelConfig.clearAllApplicationsFromConfig(wgQuick)
-            }
-            _tunnel.value?.copy(
-                name = _tunnelName.value,
-                wgQuick = wgQuick
-            )?.let {
-                tunnelRepo.save(it)
-                val settings = settingsRepo.getAll()
-                if(settings != null) {
-                    val setting = settings[0]
-                    if(setting.defaultTunnel != null) {
-                        if(it.id == TunnelConfig.from(setting.defaultTunnel!!).id) {
-                            settingsRepo.save(setting.copy(
-                                defaultTunnel = it.toString()
-                            ))
-                        }
+    fun init(tunnelId : String) = viewModelScope.launch(Dispatchers.IO) {
+        val packages = getQueriedPackages("")
+        val state = if(tunnelId != Constants.MANUAL_TUNNEL_CONFIG_ID) {
+            val tunnelConfig =
+                tunnelConfigRepository.getAll().firstOrNull { it.id.toString() == tunnelId }
+            if (tunnelConfig != null) {
+                val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
+                val proxyPeers = config.peers.map { PeerProxy.from(it) }
+                val proxyInterface = InterfaceProxy.from(config.`interface`)
+                var include = true
+                var isAllApplicationsEnabled = false
+                val checkedPackages =
+                    if (config.`interface`.includedApplications.isNotEmpty()) {
+                        config.`interface`.includedApplications
+                    } else if (config.`interface`.excludedApplications.isNotEmpty()) {
+                        include = false
+                        config.`interface`.excludedApplications
+                    } else {
+                        isAllApplicationsEnabled = true
+                        emptySet()
                    }
-                }
+                ConfigUiState(
+                    proxyPeers,
+                    proxyInterface,
+                    packages,
+                    checkedPackages.toList(),
+                    include,
+                    isAllApplicationsEnabled,
+                    false,
+                    tunnelConfig,
+                    tunnelConfig.name)
+            } else {
+                ConfigUiState(loading = false, packages = packages)
            }
+        } else {
+            ConfigUiState(loading = false, packages = packages)
        }
+        _uiState.value = state
    }
-}
+  fun onTunnelNameChange(name: String) {
+    _uiState.value = _uiState.value.copy(tunnelName = name)
+  }
+
+  fun onIncludeChange(include: Boolean) {
+    _uiState.value = _uiState.value.copy(include = include)
+  }
+
+  fun onAddCheckedPackage(packageName: String) {
+    _uiState.value =
+        _uiState.value.copy(checkedPackageNames = _uiState.value.checkedPackageNames + packageName)
+  }
+
+  fun onAllApplicationsChange(isAllApplicationsEnabled: Boolean) {
+    _uiState.value = _uiState.value.copy(isAllApplicationsEnabled = isAllApplicationsEnabled)
+  }
+
+  fun onRemoveCheckedPackage(packageName: String) {
+    _uiState.value =
+        _uiState.value.copy(checkedPackageNames = _uiState.value.checkedPackageNames - packageName)
+  }
+
+  private fun getQueriedPackages(query: String): List<PackageInfo> {
+    return getAllInternetCapablePackages().filter {
+      getPackageLabel(it).lowercase().contains(query.lowercase())
+    }
+  }
+
+  fun getPackageLabel(packageInfo: PackageInfo): String {
+    return packageInfo.applicationInfo.loadLabel(application.packageManager).toString()
+  }
+
+  private fun getAllInternetCapablePackages(): List<PackageInfo> {
+    return getPackagesHoldingPermissions(arrayOf(Manifest.permission.INTERNET))
+  }
+
+  private fun getPackagesHoldingPermissions(permissions: Array<String>): List<PackageInfo> {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      packageManager.getPackagesHoldingPermissions(
+          permissions, PackageManager.PackageInfoFlags.of(0L))
+    } else {
+      packageManager.getPackagesHoldingPermissions(permissions, 0)
+    }
+  }
+
+  private fun isAllApplicationsEnabled(): Boolean {
+    return _uiState.value.isAllApplicationsEnabled
+  }
+
+  private fun saveConfig(tunnelConfig: TunnelConfig) =
+      viewModelScope.launch {
+          tunnelConfigRepository.save(tunnelConfig)
+      }
+
+  private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) =
+      viewModelScope.launch {
+        if (tunnelConfig != null) {
+          saveConfig(tunnelConfig).join()
+          WireGuardAutoTunnel.requestTileServiceStateUpdate()
+          updateSettingsDefaultTunnel(tunnelConfig)
+        }
+      }
+
+  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()
+      if (it.allowedIps.isNotEmpty()) builder.parseAllowedIPs(it.allowedIps.trim())
+      if (it.publicKey.isNotEmpty()) builder.parsePublicKey(it.publicKey.trim())
+      if (it.preSharedKey.isNotEmpty()) builder.parsePreSharedKey(it.preSharedKey.trim())
+      if (it.endpoint.isNotEmpty()) builder.parseEndpoint(it.endpoint.trim())
+      if (it.persistentKeepalive.isNotEmpty()) {
+        builder.parsePersistentKeepalive(it.persistentKeepalive.trim())
+      }
+      builder.build()
+    }
+  }
+
+  private fun emptyCheckedPackagesList() {
+    _uiState.value = _uiState.value.copy(checkedPackageNames = emptyList())
+  }
+
+  private fun buildInterfaceListFromProxyInterface(): Interface {
+    val builder = Interface.Builder()
+    builder.parsePrivateKey(_uiState.value.interfaceProxy.privateKey.trim())
+    builder.parseAddresses(_uiState.value.interfaceProxy.addresses.trim())
+    builder.parseDnsServers(_uiState.value.interfaceProxy.dnsServers.trim())
+    if (_uiState.value.interfaceProxy.mtu.isNotEmpty())
+        builder.parseMtu(_uiState.value.interfaceProxy.mtu.trim())
+    if (_uiState.value.interfaceProxy.listenPort.isNotEmpty()) {
+      builder.parseListenPort(_uiState.value.interfaceProxy.listenPort.trim())
+    }
+    if (isAllApplicationsEnabled()) emptyCheckedPackagesList()
+    if (_uiState.value.include) builder.includeApplications(_uiState.value.checkedPackageNames)
+    if (!_uiState.value.include) builder.excludeApplications(_uiState.value.checkedPackageNames)
+    return builder.build()
+  }
+
+  fun onSaveAllChanges(): Result<Event> {
+      return try {
+          val peerList = buildPeerListFromProxyPeers()
+          val wgInterface = buildInterfaceListFromProxyInterface()
+          val config = Config.Builder().addPeers(peerList).setInterface(wgInterface).build()
+          val tunnelConfig =
+              _uiState.value.tunnel?.copy(
+                  name = _uiState.value.tunnelName, wgQuick = config.toWgQuickString())
+          updateTunnelConfig(tunnelConfig)
+          Result.Success(Event.Message.ConfigSaved)
+      } catch (e: Exception) {
+          Result.Error(Event.Error.Exception(e))
+      }
+  }
+
+  fun onPeerPublicKeyChange(index: Int, value: String) {
+    _uiState.value =
+        _uiState.value.copy(
+            proxyPeers =
+                _uiState.value.proxyPeers.update(
+                    index, _uiState.value.proxyPeers[index].copy(publicKey = value)))
+  }
+
+  fun onPreSharedKeyChange(index: Int, value: String) {
+    _uiState.value =
+        _uiState.value.copy(
+            proxyPeers =
+                _uiState.value.proxyPeers.update(
+                    index, _uiState.value.proxyPeers[index].copy(preSharedKey = value)))
+  }
+
+  fun onEndpointChange(index: Int, value: String) {
+    _uiState.value =
+        _uiState.value.copy(
+            proxyPeers =
+                _uiState.value.proxyPeers.update(
+                    index, _uiState.value.proxyPeers[index].copy(endpoint = value)))
+  }
+
+  fun onAllowedIpsChange(index: Int, value: String) {
+    _uiState.value =
+        _uiState.value.copy(
+            proxyPeers =
+                _uiState.value.proxyPeers.update(
+                    index, _uiState.value.proxyPeers[index].copy(allowedIps = value)))
+  }
+
+  fun onPersistentKeepaliveChanged(index: Int, value: String) {
+    _uiState.value =
+        _uiState.value.copy(
+            proxyPeers =
+                _uiState.value.proxyPeers.update(
+                    index, _uiState.value.proxyPeers[index].copy(persistentKeepalive = value)))
+  }
+
+  fun onDeletePeer(index: Int) {
+      _uiState.value = _uiState.value.copy(
+          proxyPeers = _uiState.value.proxyPeers.removeAt(index)
+      )
+  }
+
+  fun addEmptyPeer() {
+    _uiState.value = _uiState.value.copy(proxyPeers = _uiState.value.proxyPeers + PeerProxy())
+  }
+
+  fun generateKeyPair() {
+    val keyPair = KeyPair()
+    _uiState.value =
+        _uiState.value.copy(
+            interfaceProxy =
+                _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))
+  }
+
+  fun onListenPortChanged(value: String) {
+    _uiState.value =
+        _uiState.value.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(listenPort = value))
+  }
+
+  fun onDnsServersChanged(value: String) {
+    _uiState.value =
+        _uiState.value.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(dnsServers = value))
+  }
+
+  fun onMtuChanged(value: String) {
+    _uiState.value =
+        _uiState.value.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(mtu = value))
+  }
+
+  private fun onInterfacePublicKeyChange(value: String) {
+    _uiState.value =
+        _uiState.value.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(publicKey = value))
+  }
+
+  fun onPrivateKeyChange(value: String) {
+    _uiState.value =
+        _uiState.value.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(privateKey = value))
+    if (NumberUtils.isValidKey(value)) {
+      val pair = KeyPair(Key.fromBase64(value))
+      onInterfacePublicKeyChange(pair.publicKey.toBase64())
+    } else {
+      onInterfacePublicKeyChange("")
+    }
+  }
+
+  fun emitQueriedPackages(query: String) {
+    val packages =
+        getAllInternetCapablePackages().filter {
+          getPackageLabel(it).lowercase().contains(query.lowercase())
+        }
+    _uiState.value = _uiState.value.copy(packages = packages)
+  }
+}
@@ -1,139 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.detail
-
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.ClipboardManager
-import androidx.compose.ui.platform.LocalClipboardManager
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import java.time.Duration
-import java.time.Instant
-
-@Composable
-fun DetailScreen(
-    viewModel: DetailViewModel = hiltViewModel(),
-    padding: PaddingValues,
-    id : String?
-) {
-
-    val clipboardManager: ClipboardManager = LocalClipboardManager.current
-    val tunnelStats by viewModel.tunnelStats.collectAsStateWithLifecycle(null)
-    val tunnel by viewModel.tunnel.collectAsStateWithLifecycle(null)
-    val tunnelName by viewModel.tunnelName.collectAsStateWithLifecycle()
-    val lastHandshake by viewModel.lastHandshake.collectAsStateWithLifecycle(emptyMap())
-
-
-    LaunchedEffect(Unit) {
-        viewModel.getTunnelById(id)
-    }
-
-    if(tunnel != null) {
-        val interfaceKey = tunnel?.`interface`?.keyPair?.publicKey?.toBase64().toString()
-        val addresses = tunnel?.`interface`?.addresses!!.joinToString()
-        val dnsServers = tunnel?.`interface`?.dnsServers!!.joinToString()
-        val optionalMtu = tunnel?.`interface`?.mtu
-        val mtu = if(optionalMtu?.isPresent == true) optionalMtu.get().toString() else "None"
-        Column(
-            horizontalAlignment = Alignment.Start,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .verticalScroll(rememberScrollState())
-                .padding(padding)
-        ) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 20.dp, vertical = 7.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween
-            ) {
-                Column {
-                    Text(stringResource(R.string.config_interface), fontWeight = FontWeight.Bold, fontSize = 20.sp)
-                    Text(stringResource(R.string.name), fontStyle = FontStyle.Italic)
-                    Text(text = tunnelName,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(tunnelName))
-                    })
-                    Text(stringResource(R.string.public_key), fontStyle = FontStyle.Italic)
-                    Text(text = interfaceKey,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(interfaceKey))
-                    })
-                    Text(stringResource(R.string.addresses), fontStyle = FontStyle.Italic)
-                    Text(text = addresses,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(addresses))
-                    })
-                    Text(stringResource(R.string.dns_servers), fontStyle = FontStyle.Italic)
-                    Text(text = dnsServers,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(dnsServers))
-                    })
-                    Text(stringResource(R.string.mtu), fontStyle = FontStyle.Italic)
-                    Text(text = mtu,  modifier = Modifier.clickable {
-                        clipboardManager.setText(AnnotatedString(mtu))
-                    })
-                    Box(modifier = Modifier.padding(10.dp))
-                    tunnel?.peers?.forEach{
-                        val peerKey = it.publicKey.toBase64().toString()
-                        val allowedIps = it.allowedIps.joinToString()
-                        val endpoint = if(it.endpoint.isPresent) it.endpoint.get().toString() else "None"
-                        Text(stringResource(R.string.peer), fontWeight = FontWeight.Bold, fontSize = 20.sp)
-                        Text(stringResource(R.string.public_key), fontStyle = FontStyle.Italic)
-                        Text(text = peerKey,  modifier = Modifier.clickable {
-                            clipboardManager.setText(AnnotatedString(peerKey))
-                        })
-                        Text(stringResource(id = R.string.allowed_ips), fontStyle = FontStyle.Italic)
-                        Text(text = allowedIps,  modifier = Modifier.clickable {
-                            clipboardManager.setText(AnnotatedString(allowedIps))
-                        })
-                        Text(stringResource(R.string.endpoint), fontStyle = FontStyle.Italic)
-                        Text(text = endpoint,  modifier = Modifier.clickable {
-                            clipboardManager.setText(AnnotatedString(endpoint))
-                        })
-                        if (tunnelStats != null) {
-                            val totalRx = tunnelStats?.totalRx() ?: 0
-                            val totalTx = tunnelStats?.totalTx() ?: 0
-                            if((totalRx + totalTx != 0L))  {
-                                val rxKB = NumberUtils.bytesToKB(tunnelStats!!.totalRx())
-                                val txKB = NumberUtils.bytesToKB(tunnelStats!!.totalTx())
-                                Text(stringResource(R.string.transfer), fontStyle = FontStyle.Italic)
-                                Text("rx: ${NumberUtils.formatDecimalTwoPlaces(rxKB)} KB tx: ${NumberUtils.formatDecimalTwoPlaces(txKB)} KB")
-                                Text(stringResource(R.string.last_handshake), fontStyle = FontStyle.Italic)
-                                val handshakeEpoch = lastHandshake[it.publicKey]
-                                if(handshakeEpoch != null) {
-                                    if(handshakeEpoch == 0L) {
-                                        Text("Never")
-                                    } else {
-                                        val time = Instant.ofEpochMilli(handshakeEpoch)
-                                        Text("${Duration.between(time, Instant.now()).seconds} seconds ago")
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
@@ -1,45 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.detail
-
-import androidx.lifecycle.ViewModel
-import com.wireguard.config.Config
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import timber.log.Timber
-import javax.inject.Inject
-
-@HiltViewModel
-class DetailViewModel @Inject constructor(private val tunnelRepo : Repository<TunnelConfig>, private val vpnService : VpnService
-
-) : ViewModel() {
-
-    private val _tunnel = MutableStateFlow<Config?>(null)
-    val tunnel get() = _tunnel.asStateFlow()
-
-    private val _tunnelName = MutableStateFlow<String>("")
-    val tunnelName = _tunnelName.asStateFlow()
-    val tunnelStats get() = vpnService.statistics
-    val lastHandshake get() = vpnService.lastHandshake
-
-    private var config : TunnelConfig? = null
-
-    suspend fun getTunnelById(id : String?) : TunnelConfig? {
-        return try {
-            if(id != null) {
-               config = tunnelRepo.getById(id.toLong())
-                if (config != null) {
-                    _tunnel.emit(TunnelConfig.configFromQuick(config!!.wgQuick))
-                    _tunnelName.emit(config!!.name)
-                }
-                return config
-            }
-            return null
-        } catch (e : Exception) {
-            Timber.e(e.message)
-            null
-        }
-    }
-}
@@ -1,30 +1,49 @@
 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.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.clickable
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.gestures.ScrollableDefaults
 import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.PaddingValues
 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
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.overscroll
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Create
 import androidx.compose.material.icons.filled.FileOpen
 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.Delete
 import androidx.compose.material.icons.rounded.Edit
+import androidx.compose.material.icons.rounded.Info
+import androidx.compose.material.icons.rounded.Star
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Divider
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.FabPosition
@@ -32,16 +51,18 @@ import androidx.compose.material3.FloatingActionButton
 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.SnackbarDuration
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.SnackbarResult
 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
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -50,13 +71,13 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
 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
@@ -65,224 +86,477 @@ import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
+import com.journeyapps.barcodescanner.ScanContract
+import com.journeyapps.barcodescanner.ScanOptions
 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.service.tunnel.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.ui.Routes
+import com.zaneschepke.wireguardautotunnel.ui.CaptureActivityPortrait
+import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.RowListItem
-import com.zaneschepke.wireguardautotunnel.ui.theme.brickRed
+import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
+import com.zaneschepke.wireguardautotunnel.ui.theme.corn
 import com.zaneschepke.wireguardautotunnel.ui.theme.mint
+import com.zaneschepke.wireguardautotunnel.util.Constants
+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 kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch

@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
-@OptIn(ExperimentalMaterial3Api::class)
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
@Composable
 fun MainScreen(
-    viewModel: MainViewModel = hiltViewModel(), padding: PaddingValues,
-    snackbarHostState: SnackbarHostState, navController: NavController
+    viewModel: MainViewModel = hiltViewModel(),
+    padding: PaddingValues,
+    focusRequester: FocusRequester,
+    showSnackbarMessage: (String) -> Unit,
+    navController: NavController
 ) {
+  val haptic = LocalHapticFeedback.current
+  val context = LocalContext.current
+  val isVisible = rememberSaveable { mutableStateOf(true) }
+  val scope = rememberCoroutineScope { Dispatchers.IO }

-    val haptic = LocalHapticFeedback.current
-    val context = LocalContext.current
-    val isVisible = rememberSaveable { mutableStateOf(true) }
-    val scope = rememberCoroutineScope()
+  val sheetState = rememberModalBottomSheetState()
+  var showBottomSheet by remember { mutableStateOf(false) }

-    val sheetState = rememberModalBottomSheetState()
-    var showBottomSheet by remember { mutableStateOf(false) }
-    val tunnels by viewModel.tunnels.collectAsStateWithLifecycle(mutableListOf())
-    val handshakeStatus by viewModel.handshakeStatus.collectAsStateWithLifecycle(HandshakeStatus.NOT_STARTED)
-    val viewState = viewModel.viewState.collectAsStateWithLifecycle()
-    var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
-    val state by viewModel.state.collectAsStateWithLifecycle(Tunnel.State.DOWN)
-    val tunnelName by viewModel.tunnelName.collectAsStateWithLifecycle("")
+  var showPrimaryChangeAlertDialog by remember { mutableStateOf(false) }
+  var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
+  val uiState by viewModel.uiState.collectAsStateWithLifecycle()

-    // 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
+  LaunchedEffect(uiState.loading) {
+    if (!uiState.loading && WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+      delay(Constants.FOCUS_REQUEST_DELAY)
+      focusRequester.requestFocus()
+    }
+  }
+
+  if (uiState.loading) {
+    LoadingScreen()
+    return
+  }
+
+  val tunnelFileImportResultLauncher =
+      rememberLauncherForActivityResult(
+          object : ActivityResultContracts.GetContent() {
+            override fun createIntent(context: Context, input: String): Intent {
+              val intent = super.createIntent(context, input)
+
+              /* AndroidTV now comes with stubs that do nothing but display a Toast less helpful than
+               * what we can do, so detect this and throw an exception that we can catch later. */
+              val activitiesToResolveIntent =
+                  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    context.packageManager.queryIntentActivities(
+                        intent,
+                        PackageManager.ResolveInfoFlags.of(
+                            PackageManager.MATCH_DEFAULT_ONLY.toLong()))
+                  } else {
+                    context.packageManager.queryIntentActivities(
+                        intent, PackageManager.MATCH_DEFAULT_ONLY)
+                  }
+              if (activitiesToResolveIntent.all {
+                val name = it.activityInfo.packageName
+                name.startsWith(Constants.GOOGLE_TV_EXPLORER_STUB) ||
+                    name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
+              }) {
+                showSnackbarMessage(Event.Error.FileExplorerRequired.message)
+              }
+              return intent
            }
-        }
-    }
-
-    LaunchedEffect(viewState.value) {
-        if (viewState.value.showSnackbarMessage) {
-            val result = snackbarHostState.showSnackbar(
-                message = viewState.value.snackbarMessage,
-                actionLabel = viewState.value.snackbarActionText,
-                duration = SnackbarDuration.Long,
-            )
-            when (result) {
-                SnackbarResult.ActionPerformed -> viewState.value.onSnackbarActionClick
-                SnackbarResult.Dismissed -> viewState.value.onSnackbarActionClick
+          }) { data ->
+            if (data == null) return@rememberLauncherForActivityResult
+            scope.launch {
+              viewModel.onTunnelFileSelected(data).let {
+                when (it) {
+                  is Result.Error -> showSnackbarMessage(it.error.message)
+                  is Result.Success -> {}
+                }
+              }
            }
-        }
-    }
+          }
+  val scanLauncher =
+      rememberLauncherForActivityResult(
+          contract = ScanContract(),
+          onResult = {
+            if (it.contents != null) {
+              scope.launch {
+                viewModel.onTunnelQrResult(it.contents).let { result ->
+                  when (result) {
+                    is Result.Success -> {}
+                    is Result.Error -> showSnackbarMessage(result.error.message)
+                  }
+                }
+              }
+            }
+          })

-    val pickFileLauncher = rememberLauncherForActivityResult(
-        ActivityResultContracts.GetContent()
-    ) { file ->
-        if (file != null) {
-            viewModel.onTunnelFileSelected(file)
-        }
-    }
-
-    Scaffold(
-        modifier = Modifier.pointerInput(Unit) {
-            detectTapGestures(onTap = {
+  AnimatedVisibility(showPrimaryChangeAlertDialog) {
+    AlertDialog(
+        onDismissRequest = { showPrimaryChangeAlertDialog = false },
+        confirmButton = {
+          TextButton(
+              onClick = {
+                viewModel.onDefaultTunnelChange(selectedTunnel)
+                showPrimaryChangeAlertDialog = false
                selectedTunnel = null
-            })
+              }) {
+                Text(text = stringResource(R.string.okay))
+              }
        },
-        floatingActionButtonPosition = FabPosition.End,
-        floatingActionButton =  {
-            AnimatedVisibility(
-                visible = isVisible.value,
-                enter = slideInVertically(initialOffsetY = { it * 2 }),
-                exit = slideOutVertically(targetOffsetY = { it * 2 }),
-            ) {
-                FloatingActionButton(
-                    modifier = Modifier.padding(bottom = 90.dp),
-                    onClick = {
-                        showBottomSheet = true
-                    },
-                    containerColor = MaterialTheme.colorScheme.secondary,
-                    shape = RoundedCornerShape(16.dp),
-                ) {
+        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)) })
+  }
+
+  fun onTunnelToggle(checked: Boolean, tunnel: TunnelConfig) {
+    if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
+  }
+
+  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)
+                          Text(
+                              "Auto-tunneling: ${if(uiState.settings.isAutoTunnelPaused) "paused" else "active" }",
+                              style = typography.bodyLarge,
+                              modifier = Modifier.padding(start = 10.dp))
+                        }
+                        if(uiState.settings.isAutoTunnelPaused) TextButton(
+                            onClick = { viewModel.resumeAutoTunneling()  },
+                            modifier = Modifier.padding(end = 10.dp)) {
+                              Text("Resume")
+                            } else TextButton(
+                            onClick = { viewModel.pauseAutoTunneling()  },
+                            modifier = Modifier.padding(end = 10.dp)) {
+                            Text("Pause")
+                        }
+                      }
+                },
+            )
+      },
+      floatingActionButton = {
+        AnimatedVisibility(
+            visible = isVisible.value,
+            enter = slideInVertically(initialOffsetY = { it * 2 }),
+            exit = slideOutVertically(targetOffsetY = { it * 2 })) {
+              val secondaryColor = MaterialTheme.colorScheme.secondary
+              val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
+              var fobColor by remember { mutableStateOf(secondaryColor) }
+              FloatingActionButton(
+                  modifier =
+                      (if (WireGuardAutoTunnel.isRunningOnAndroidTv() &&
+                              uiState.tunnels.isEmpty())
+                              Modifier.focusRequester(focusRequester)
+                          else Modifier)
+                          .padding(bottom = 90.dp)
+                          .onFocusChanged {
+                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                              fobColor = if (it.isFocused) hoverColor else secondaryColor
+                            }
+                          },
+                  onClick = { showBottomSheet = true },
+                  containerColor = fobColor,
+                  shape = RoundedCornerShape(16.dp)) {
                    Icon(
                        imageVector = Icons.Rounded.Add,
                        contentDescription = stringResource(id = R.string.add_tunnel),
-                        tint = Color.DarkGray,
-                    )
-                }
+                        tint = Color.DarkGray)
+                  }
            }
-        }
-    ) {
-        if (tunnels.isEmpty()) {
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center,
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(padding)
-            ) {
+      }) { innerPadding ->
+        AnimatedVisibility(uiState.tunnels.isEmpty(), exit = fadeOut(), enter = fadeIn()) {
+          Column(
+              horizontalAlignment = Alignment.CenterHorizontally,
+              verticalArrangement = Arrangement.Center,
+              modifier = Modifier.fillMaxSize().padding(padding)) {
                Text(text = stringResource(R.string.no_tunnels), fontStyle = FontStyle.Italic)
-            }
+              }
        }
        if (showBottomSheet) {
-            ModalBottomSheet(
-                onDismissRequest = {
-                    showBottomSheet = false
-                },
-                sheetState = sheetState
-            ) {
+          ModalBottomSheet(
+              onDismissRequest = { showBottomSheet = false }, sheetState = sheetState) {
                // Sheet content
                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .clickable {
-                            showBottomSheet = false
-                            pickFileLauncher.launch("*/*")
-                        }
-                        .padding(10.dp)
-                ) {
-                    Icon(
-                        Icons.Filled.FileOpen,
-                        contentDescription = stringResource(id = R.string.open_file),
-                        modifier = Modifier.padding(10.dp)
-                    )
-                    Text(
-                        stringResource(id = R.string.add_from_file),
-                        modifier = Modifier.padding(10.dp)
-                    )
+                    modifier =
+                        Modifier.fillMaxWidth()
+                            .clickable {
+                              showBottomSheet = false
+                              tunnelFileImportResultLauncher.launch(Constants.ALLOWED_FILE_TYPES)
+                            }
+                            .padding(10.dp)) {
+                      Icon(
+                          Icons.Filled.FileOpen,
+                          contentDescription = stringResource(id = R.string.open_file),
+                          modifier = Modifier.padding(10.dp))
+                      Text(
+                          stringResource(id = R.string.add_tunnels_text),
+                          modifier = Modifier.padding(10.dp))
+                    }
+                if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                  Divider()
+                  Row(
+                      modifier =
+                          Modifier.fillMaxWidth()
+                              .clickable {
+                                scope.launch {
+                                  showBottomSheet = false
+                                  val scanOptions = ScanOptions()
+                                  scanOptions.setDesiredBarcodeFormats(ScanOptions.QR_CODE)
+                                  scanOptions.setOrientationLocked(true)
+                                  scanOptions.setPrompt(context.getString(R.string.scanning_qr))
+                                  scanOptions.setBeepEnabled(false)
+                                  scanOptions.captureActivity = CaptureActivityPortrait::class.java
+                                  scanLauncher.launch(scanOptions)
+                                }
+                              }
+                              .padding(10.dp)) {
+                        Icon(
+                            Icons.Filled.QrCode,
+                            contentDescription = stringResource(id = R.string.qr_scan),
+                            modifier = Modifier.padding(10.dp))
+                        Text(
+                            stringResource(id = R.string.add_from_qr),
+                            modifier = Modifier.padding(10.dp))
+                      }
                }
                Divider()
-                Row(modifier = Modifier
-                    .fillMaxWidth()
-                    .clickable {
-                        scope.launch {
-                            showBottomSheet = false
-                            viewModel.onTunnelQRSelected()
-                        }
+                Row(
+                    modifier =
+                        Modifier.fillMaxWidth()
+                            .clickable {
+                              showBottomSheet = false
+                              navController.navigate(
+                                  "${Screen.Config.route}/${Constants.MANUAL_TUNNEL_CONFIG_ID}")
+                            }
+                            .padding(10.dp)) {
+                      Icon(
+                          Icons.Filled.Create,
+                          contentDescription = stringResource(id = R.string.create_import),
+                          modifier = Modifier.padding(10.dp))
+                      Text(
+                          stringResource(id = R.string.create_import),
+                          modifier = Modifier.padding(10.dp))
                    }
-                    .padding(10.dp)
-                ) {
-                    Icon(
-                        Icons.Filled.QrCode,
-                        contentDescription = stringResource(id = R.string.qr_scan),
-                        modifier = Modifier.padding(10.dp)
-                    )
-                    Text(
-                        stringResource(id = R.string.add_from_qr),
-                        modifier = Modifier.padding(10.dp)
-                    )
-                }
-            }
+              }
        }
-        Column(
+
+        LazyColumn(
            horizontalAlignment = Alignment.Start,
            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-
-            LazyColumn(modifier = Modifier.fillMaxSize()
-                .nestedScroll(nestedScrollConnection),) {
-                items(tunnels.toList()) { tunnel ->
-                    RowListItem(leadingIcon = Icons.Rounded.Circle,
-                        leadingIconColor = when (handshakeStatus) {
-                            HandshakeStatus.HEALTHY -> mint
-                            HandshakeStatus.UNHEALTHY -> brickRed
-                            HandshakeStatus.NOT_STARTED -> Color.Gray
-                            HandshakeStatus.NEVER_CONNECTED -> brickRed
+            modifier =
+                Modifier.fillMaxWidth().fillMaxHeight(.90f).overscroll(ScrollableDefaults.overscrollEffect()).padding(innerPadding),
+            state = rememberLazyListState(0, uiState.tunnels.count()),
+            userScrollEnabled = true,
+            reverseLayout = true,
+            flingBehavior = ScrollableDefaults.flingBehavior()) {
+              items(uiState.tunnels,
+                  key = { tunnel -> tunnel.id }) { tunnel ->
+                    val leadingIconColor =
+                        (if (uiState.vpnState.name == tunnel.name &&
+                            uiState.vpnState.status == Tunnel.State.UP) {
+                          uiState.vpnState.statistics
+                              ?.mapPeerStats()
+                              ?.map { it.value?.handshakeStatus() }
+                              .let { statuses ->
+                                when {
+                                  statuses?.all { it == HandshakeStatus.HEALTHY } == true -> mint
+                                  statuses?.any { it == HandshakeStatus.STALE } == true -> corn
+                                  statuses?.all { it == HandshakeStatus.NOT_STARTED } == true ->
+                                      Color.Gray
+                                  else -> {
+                                    Color.Gray
+                                  }
+                                }
+                              }
+                        } else {
+                          Color.Gray
+                        })
+                    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))
+                          } else {
+                            Icon(
+                                Icons.Rounded.Circle,
+                                stringResource(R.string.status),
+                                tint = leadingIconColor,
+                                modifier = Modifier.padding(end = 15.dp).size(15.dp))
+                          }
                        },
                        text = tunnel.name,
                        onHold = {
-                            if (state == Tunnel.State.UP && tunnel.name == tunnelName) {
-                                scope.launch {
-                                    viewModel.showSnackBarMessage(context.resources.getString(R.string.turn_off_tunnel))
-                                }
-                                return@RowListItem
-                            }
-                            haptic.performHapticFeedback(HapticFeedbackType.LongPress)
-                            selectedTunnel = tunnel;
+                          if ((uiState.vpnState.status == Tunnel.State.UP) &&
+                              (tunnel.name == uiState.vpnState.name)) {
+                            showSnackbarMessage(Event.Message.TunnelOffAction.message)
+                            return@RowListItem
+                          }
+                          haptic.performHapticFeedback(HapticFeedbackType.LongPress)
+                          selectedTunnel = tunnel
                        },
-                        onClick = { navController.navigate("${Routes.Detail.name}/${tunnel.id}") },
-                        rowButton = {
-                            if (tunnel.id == selectedTunnel?.id) {
-                                Row() {
-                                    IconButton(onClick = {
-                                        navController.navigate("${Routes.Config.name}/${selectedTunnel?.id}")
-                                    }) {
-                                        Icon(Icons.Rounded.Edit, stringResource(id = R.string.edit))
-                                    }
-                                    IconButton(onClick = { viewModel.onDelete(tunnel) }) {
-                                        Icon(
-                                            Icons.Rounded.Delete,
-                                            stringResource(id = R.string.delete)
-                                        )
-                                    }
-                                }
-                            } else {
-                                Switch(
-                                    checked = (state == Tunnel.State.UP && tunnel.name == tunnelName),
-                                    onCheckedChange = { checked ->
-                                        if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
-                                    }
-                                )
+                        onClick = {
+                          if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                            if (uiState.vpnState.status == Tunnel.State.UP &&
+                                (uiState.vpnState.name == tunnel.name)) {
+                              expanded.value = !expanded.value
                            }
+                          } else {
+                            selectedTunnel = tunnel
+                            focusRequester.requestFocus()
+                          }
+                        },
+                        statistics = uiState.vpnState.statistics,
+                        expanded = expanded.value,
+                        rowButton = {
+                          if (tunnel.id == selectedTunnel?.id &&
+                              !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) {
+                                          showSnackbarMessage(
+                                              Event.Message.AutoTunnelOffAction.message)
+                                      } else navController.navigate(
+                                        "${Screen.Config.route}/${selectedTunnel?.id}")
+                                  }) {
+                                    Icon(Icons.Rounded.Edit, stringResource(id = R.string.edit))
+                                  }
+                              IconButton(
+                                  modifier = Modifier.focusable(),
+                                  onClick = { viewModel.onDelete(tunnel) }) {
+                                    Icon(Icons.Rounded.Delete, stringResource(id = R.string.delete))
+                                  }
+                            }
+                          } else {
+                            val checked by remember {
+                              derivedStateOf {
+                                (uiState.vpnState.status == Tunnel.State.UP &&
+                                    tunnel.name == uiState.vpnState.name)
+                              }
+                            }
+                            if (!checked) expanded.value = false
+
+                            @Composable
+                            fun TunnelSwitch() =
+                                Switch(
+                                    modifier = Modifier.focusRequester(focusRequester),
+                                    checked = checked,
+                                    onCheckedChange = { checked ->
+                                      if (!checked) expanded.value = false
+                                      onTunnelToggle(checked, tunnel)
+                                    })
+                            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(
+                                    modifier = Modifier.focusRequester(focusRequester),
+                                    onClick = {
+                                      if (uiState.vpnState.status == Tunnel.State.UP &&
+                                          (uiState.vpnState.name == tunnel.name)) {
+                                        expanded.value = !expanded.value
+                                      } else {
+                                        showSnackbarMessage(Event.Message.TunnelOnAction.message)
+                                      }
+                                    }) {
+                                      Icon(Icons.Rounded.Info, stringResource(R.string.info))
+                                    }
+                                IconButton(
+                                    onClick = {
+                                      if (uiState.vpnState.status == Tunnel.State.UP &&
+                                          tunnel.name == uiState.vpnState.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)
+                                      } else {
+                                        viewModel.onDelete(tunnel)
+                                      }
+                                    }) {
+                                      Icon(
+                                          Icons.Rounded.Delete,
+                                          stringResource(id = R.string.delete))
+                                    }
+                                TunnelSwitch()
+                              }
+                            } else {
+                              TunnelSwitch()
+                            }
+                          }
                        })
-                }
+                  }
            }
-        }
-    }
+      }
 }
@@ -0,0 +1,12 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main
+
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnState
+import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+
+data class MainUiState(
+    val settings : Settings = Settings(),
+    val tunnels : TunnelConfigs = emptyList(),
+    val vpnState: VpnState = VpnState(),
+    val loading : Boolean = true
+)
@@ -1,189 +1,261 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.main

-import android.annotation.SuppressLint
 import android.app.Application
 import android.content.Context
+import android.database.Cursor
 import android.net.Uri
 import android.provider.OpenableColumns
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.wireguard.config.BadConfigException
 import com.wireguard.config.Config
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.barcode.CodeScanner
-import com.zaneschepke.wireguardautotunnel.service.foreground.Action
+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.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceState
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceTracker
 import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardConnectivityWatcherService
 import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.ui.ViewState
+import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.Event
+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.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
-import timber.log.Timber
+import kotlinx.coroutines.withContext
+import java.io.InputStream
+import java.util.zip.ZipInputStream
 import javax.inject.Inject

-
@HiltViewModel
-class MainViewModel @Inject constructor(private val application : Application,
-                                        private val tunnelRepo : Repository<TunnelConfig>,
-                                        private val settingsRepo : Repository<Settings>,
-                                        private val vpnService: VpnService,
-                                        private val codeScanner: CodeScanner
+class MainViewModel
+@Inject
+constructor(
+    private val application: Application,
+    private val tunnelConfigRepository: TunnelConfigRepository,
+    private val settingsRepository: SettingsRepository,
+    private val vpnService: VpnService
 ) : ViewModel() {

-    private val _viewState = MutableStateFlow(ViewState())
-    val viewState get() = _viewState.asStateFlow()
-    val tunnels get() = tunnelRepo.itemFlow
-    val state get() = vpnService.state
+  val uiState =
+      combine(
+              settingsRepository.getSettingsFlow(),
+              tunnelConfigRepository.getTunnelConfigsFlow(),
+              vpnService.vpnState,
+          ) { settings, tunnels, vpnState ->
+            validateWatcherServiceState(settings)
+            MainUiState(settings, tunnels, vpnState, false)
+          }
+          .stateIn(
+              viewModelScope,
+              SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
+              MainUiState())

-    val handshakeStatus get() = vpnService.handshakeStatus
-    val tunnelName get() = vpnService.tunnelName
-    private val _settings = MutableStateFlow(Settings())
-    val settings get() = _settings.asStateFlow()
-
-    private val defaultConfigName = {
-        "tunnel${(Math.random() * 100000).toInt()}"
+  private fun validateWatcherServiceState(settings: Settings) = viewModelScope.launch(Dispatchers.IO) {
+    val watcherState =
+        ServiceManager.getServiceState(
+            application.applicationContext, WireGuardConnectivityWatcherService::class.java)
+    if (settings.isAutoTunnelEnabled &&
+        watcherState == ServiceState.STOPPED) {
+      ServiceManager.startWatcherService(application.applicationContext)
    }
+  }

+    private fun stopWatcherService() = viewModelScope.launch(Dispatchers.IO) {
+        ServiceManager.stopWatcherService(application.applicationContext)
+    }
+  fun onDelete(tunnel: TunnelConfig) {
+    viewModelScope.launch(Dispatchers.IO) {
+      if (tunnelConfigRepository.count() == 1) {
+        stopWatcherService()
+        val settings = settingsRepository.getSettings()
+          settings.defaultTunnel = null
+          settings.isAutoTunnelEnabled = false
+          settings.isAlwaysOnVpnEnabled = false
+          saveSettings(settings)
+      }
+      tunnelConfigRepository.delete(tunnel)
+      WireGuardAutoTunnel.requestTileServiceStateUpdate()
+    }
+  }

-    init {
-        viewModelScope.launch {
-            settingsRepo.itemFlow.collect {
-                val settings = it.first()
-                validateWatcherServiceState(settings)
-                _settings.emit(settings)
-            }
+  fun onTunnelStart(tunnelConfig: TunnelConfig) = viewModelScope.launch(Dispatchers.IO) {
+        stopActiveTunnel().await()
+        startTunnel(tunnelConfig)
+  }
+
+  private fun startTunnel(tunnelConfig: TunnelConfig) = viewModelScope.launch(Dispatchers.IO) {
+      ServiceManager.startVpnService(application.applicationContext, tunnelConfig.toString())
+  }
+
+  private fun stopActiveTunnel() =
+      viewModelScope.async(Dispatchers.IO) {
+        if (ServiceManager.getServiceState(
+            application.applicationContext, WireGuardTunnelService::class.java) ==
+            ServiceState.STARTED) {
+          onTunnelStop()
+          delay(Constants.TOGGLE_TUNNEL_DELAY)
        }
-    }
+      }

-    private fun validateWatcherServiceState(settings: Settings) {
-        val watcherState = ServiceTracker.getServiceState(application, WireGuardConnectivityWatcherService::class.java)
-        if(settings.isAutoTunnelEnabled && watcherState == ServiceState.STOPPED && settings.defaultTunnel != null) {
-            startWatcherService(settings.defaultTunnel!!)
-        }
-    }
+  fun onTunnelStop() = viewModelScope.launch(Dispatchers.IO) {
+    ServiceManager.stopVpnService(application.applicationContext)
+  }

-    private fun startWatcherService(tunnel : String) {
-        ServiceTracker.actionOnService(
-            Action.START, application,
-            WireGuardConnectivityWatcherService::class.java,
-            mapOf(application.resources.getString(R.string.tunnel_extras_key) to tunnel))
-    }
+  private fun validateConfigString(config: String) {
+    TunnelConfig.configFromQuick(config)
+  }

-    fun onDelete(tunnel : TunnelConfig) {
-        viewModelScope.launch {
-            if(tunnelRepo.count() == 1L) {
-                ServiceTracker.actionOnService( Action.STOP, application, WireGuardConnectivityWatcherService::class.java)
-                val settings = settingsRepo.getAll()
-                if(!settings.isNullOrEmpty()) {
-                    val setting = settings[0]
-                    setting.defaultTunnel = null
-                    setting.isAutoTunnelEnabled = false
-                    settingsRepo.save(setting)
-                }
-            }
-            tunnelRepo.delete(tunnel)
-        }
-    }
-
-    fun onTunnelStart(tunnelConfig : TunnelConfig) = viewModelScope.launch {
-            ServiceTracker.actionOnService( Action.START, application, WireGuardTunnelService::class.java,
-                mapOf(application.resources.getString(R.string.tunnel_extras_key) to tunnelConfig.toString()))
-    }
-
-    fun onTunnelStop() {
-        ServiceTracker.actionOnService( Action.STOP, application, WireGuardTunnelService::class.java)
-    }
-
-    suspend fun onTunnelQRSelected() {
-        codeScanner.scan().collect {
-            if(!it.isNullOrEmpty() && it.contains(application.resources.getString(R.string.config_validation))) {
-                tunnelRepo.save(TunnelConfig(name = defaultConfigName(), wgQuick = it))
-            } else if(!it.isNullOrEmpty() && it.contains(application.resources.getString(R.string.barcode_downloading))) {
-                showSnackBarMessage(application.resources.getString(R.string.barcode_downloading_message))
-            } else {
-                showSnackBarMessage(application.resources.getString(R.string.barcode_error))
-            }
-        }
-    }
-
-    fun onTunnelFileSelected(uri : Uri) {
-        try {
-            val fileName = getFileName(application.applicationContext, uri)
-            val extension = getFileExtensionFromFileName(fileName)
-            if(extension != ".conf") {
-                viewModelScope.launch {
-                    showSnackBarMessage(application.resources.getString(R.string.file_extension_message))
-                }
-                return
-            }
-            val stream = application.applicationContext.contentResolver.openInputStream(uri)
-            stream ?: return
-            val bufferReader = stream.bufferedReader(charset = Charsets.UTF_8)
-                val config = Config.parse(bufferReader)
-                val tunnelName = getNameFromFileName(fileName)
-                viewModelScope.launch {
-                    tunnelRepo.save(TunnelConfig(name = tunnelName, wgQuick = config.toWgQuickString()))
-                }
-            stream.close()
-        } catch(_: BadConfigException) {
-            viewModelScope.launch {
-                showSnackBarMessage(application.applicationContext.getString(R.string.bad_config))
-            }
-        }
-    }
-
-    @SuppressLint("Range")
-    private fun getFileName(context: Context, uri: Uri): String {
-        if (uri.scheme == "content") {
-            val cursor = context.contentResolver.query(uri, null, null, null, null)
-            cursor ?: return defaultConfigName()
-            cursor.use {
-                if(cursor.moveToFirst()) {
-                    return cursor.getString(cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME))
-                }
-            }
-        }
-        return defaultConfigName()
-    }
-
-    suspend fun showSnackBarMessage(message : String) {
-        _viewState.emit(_viewState.value.copy(
-            showSnackbarMessage = true,
-            snackbarMessage = message,
-            snackbarActionText = "Okay",
-            onSnackbarActionClick = {
-                viewModelScope.launch {
-                    dismissSnackBar()
-                }
-            }
-        ))
-        delay(3000)
-        dismissSnackBar()
-    }
-
-    private suspend fun dismissSnackBar() {
-        _viewState.emit(_viewState.value.copy(
-            showSnackbarMessage = false
-        ))
-    }
-
-    private fun getNameFromFileName(fileName : String) : String {
-        return fileName.substring(0 , fileName.lastIndexOf('.') )
-    }
-
-    private fun getFileExtensionFromFileName(fileName : String) : String {
+  suspend fun onTunnelQrResult(result: String) : Result<Unit> {
        return try {
-            fileName.substring(fileName.lastIndexOf('.'))
-        } catch (e : Exception) {
-            ""
+          validateConfigString(result)
+          val tunnelConfig =
+              TunnelConfig(name = NumberUtils.generateRandomTunnelName(), wgQuick = result)
+          addTunnel(tunnelConfig)
+            Result.Success(Unit)
+        } catch (e: Exception) {
+            Result.Error(Event.Error.InvalidQrCode)
        }
+      }
+
+  private suspend fun saveTunnelConfigFromStream(stream: InputStream, fileName: String) {
+    val bufferReader = stream.bufferedReader(charset = Charsets.UTF_8)
+    val config = Config.parse(bufferReader)
+    val tunnelName = getNameFromFileName(fileName)
+    addTunnel(TunnelConfig(name = tunnelName, wgQuick = config.toWgQuickString()))
+    withContext(Dispatchers.IO) { stream.close() }
+  }
+
+  private fun getInputStreamFromUri(uri: Uri): InputStream? {
+    return application.applicationContext.contentResolver.openInputStream(uri)
+  }
+
+  suspend fun onTunnelFileSelected(uri: Uri) : Result<Unit> {
+        try {
+            if(isValidUriContentScheme(uri)){
+                val fileName = getFileName(application.applicationContext, uri)
+                when (getFileExtensionFromFileName(fileName)) {
+                    Constants.CONF_FILE_EXTENSION -> saveTunnelFromConfUri(fileName, uri).let {
+                        when(it) {
+                            is Result.Error -> return Result.Error(Event.Error.FileReadFailed)
+                            is Result.Success -> return it
+                        }
+                    }
+                    Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(uri)
+                    else -> return Result.Error(Event.Error.InvalidFileExtension)
+                }
+                return Result.Success(Unit)
+          } else {
+             return Result.Error(Event.Error.InvalidFileExtension)
+            }
+        } catch (e: Exception) {
+            return Result.Error(Event.Error.FileReadFailed)
+        }
+      }
+
+  private suspend fun saveTunnelsFromZipUri(uri: Uri) {
+    ZipInputStream(getInputStreamFromUri(uri)).use { zip ->
+      generateSequence { zip.nextEntry }
+          .filterNot {
+            it.isDirectory || getFileExtensionFromFileName(it.name) != Constants.CONF_FILE_EXTENSION
+          }
+          .forEach {
+            val name = getNameFromFileName(it.name)
+            val config = Config.parse(zip)
+            viewModelScope.launch(Dispatchers.IO) {
+              addTunnel(TunnelConfig(name = name, wgQuick = config.toWgQuickString()))
+            }
+          }
    }
-}
+  }
+
+  private suspend fun saveTunnelFromConfUri(name: String, uri: Uri) : Result<Unit> {
+      val stream = getInputStreamFromUri(uri)
+      return if(stream != null) {
+          saveTunnelConfigFromStream(stream, name)
+          Result.Success(Unit)
+      } else {
+          Result.Error(Event.Error.FileReadFailed)
+      }
+  }
+
+  private suspend fun addTunnel(tunnelConfig: TunnelConfig) {
+    saveTunnel(tunnelConfig)
+    WireGuardAutoTunnel.requestTileServiceStateUpdate()
+  }
+
+    fun pauseAutoTunneling() = viewModelScope.launch {
+        settingsRepository.save(uiState.value.settings.copy(isAutoTunnelPaused = true))
+    }
+
+    fun resumeAutoTunneling() = viewModelScope.launch {
+        settingsRepository.save(uiState.value.settings.copy(isAutoTunnelPaused = false))
+    }
+
+  private suspend fun saveTunnel(tunnelConfig: TunnelConfig) {
+    tunnelConfigRepository.save(tunnelConfig)
+  }
+
+  private fun getFileNameByCursor(context: Context, uri: Uri): String? {
+    context.contentResolver.query(uri, null, null, null, null)?.use {
+      return getDisplayNameByCursor(it)
+    }
+      return null
+  }
+
+  private fun getDisplayNameColumnIndex(cursor: Cursor): Int? {
+    val columnIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+    return if (columnIndex != -1) {
+      return columnIndex
+    } else {
+      null
+    }
+  }
+
+  private fun getDisplayNameByCursor(cursor: Cursor): String? {
+    return if (cursor.moveToFirst()) {
+      val index = getDisplayNameColumnIndex(cursor)
+      if (index != null) {
+        cursor.getString(index)
+      } else null
+    } else null
+  }
+
+  private fun isValidUriContentScheme(uri: Uri): Boolean {
+    return uri.scheme == Constants.URI_CONTENT_SCHEME
+  }
+  private fun getFileName(context: Context, uri: Uri): String {
+        return getFileNameByCursor(context, uri) ?: NumberUtils.generateRandomTunnelName()
+  }
+
+  private fun getNameFromFileName(fileName: String): String {
+    return fileName.substring(0, fileName.lastIndexOf('.'))
+  }
+
+  private fun getFileExtensionFromFileName(fileName: String): String {
+    return try {
+      fileName.substring(fileName.lastIndexOf('.'))
+    } catch (e: Exception) {
+      ""
+    }
+  }
+
+  private fun saveSettings(settings: Settings) =
+      viewModelScope.launch(Dispatchers.IO) { settingsRepository.save(settings) }
+
+  fun onDefaultTunnelChange(selectedTunnel: TunnelConfig?) = viewModelScope.launch {
+    if (selectedTunnel != null) {
+      saveSettings(uiState.value.settings.copy(defaultTunnel = selectedTunnel.toString())).join()
+      WireGuardAutoTunnel.requestTileServiceStateUpdate()
+    }
+  }
+}
@@ -3,20 +3,26 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.settings
 import android.Manifest
 import android.content.Intent
 import android.net.Uri
-import android.provider.Settings
+import android.os.Build
+import android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+import androidx.compose.animation.AnimatedVisibility
 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.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.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.foundation.verticalScroll
@@ -24,22 +30,16 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.outlined.Add
 import androidx.compose.material.icons.rounded.LocationOff
-import androidx.compose.material3.Button
-import androidx.compose.material3.DropdownMenuItem
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.ExposedDropdownMenuBox
-import androidx.compose.material3.ExposedDropdownMenuDefaults
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.SnackbarDuration
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.SnackbarResult
-import androidx.compose.material3.Switch
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
+import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -47,6 +47,9 @@ 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.focusProperties
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
@@ -59,263 +62,447 @@ 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.service.tunnel.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.ui.Routes
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 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 java.io.File

-@OptIn(ExperimentalMaterial3Api::class, ExperimentalPermissionsApi::class,
-    ExperimentalLayoutApi::class
-)
+@OptIn(
+    ExperimentalPermissionsApi::class,
+    ExperimentalLayoutApi::class)
@Composable
 fun SettingsScreen(
    viewModel: SettingsViewModel = hiltViewModel(),
    padding: PaddingValues,
-    navController: NavController,
-    snackbarHostState: SnackbarHostState = remember { SnackbarHostState() }
+    showSnackbarMessage: (String) -> Unit,
+    focusRequester: FocusRequester
 ) {
+  val scope = rememberCoroutineScope { Dispatchers.IO }
+  val context = LocalContext.current
+  val focusManager = LocalFocusManager.current
+  val scrollState = rememberScrollState()
+  val interactionSource = remember { MutableInteractionSource() }

-    val scope = rememberCoroutineScope()
-    val context = LocalContext.current
-    val focusManager = LocalFocusManager.current
-    val interactionSource = remember { MutableInteractionSource() }
+  val uiState by viewModel.uiState.collectAsStateWithLifecycle()

-    var expanded by remember { mutableStateOf(false) }
-    val viewState by viewModel.viewState.collectAsStateWithLifecycle()
-    val settings by viewModel.settings.collectAsStateWithLifecycle()
-    val trustedSSIDs by viewModel.trustedSSIDs.collectAsStateWithLifecycle()
-    val tunnels by viewModel.tunnels.collectAsStateWithLifecycle(mutableListOf())
-    val backgroundLocationState =
-        rememberPermissionState(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
-    var currentText by remember { mutableStateOf("") }
-    val scrollState = rememberScrollState()
+  val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
+  var currentText by remember { mutableStateOf("") }
+  var isBackgroundLocationGranted by remember { mutableStateOf(true) }
+    var showLocationServicesAlertDialog by remember { mutableStateOf(false) }
+  var didExportFiles by remember { mutableStateOf(false) }
+  var showAuthPrompt by remember { mutableStateOf(false) }
+    val focusRequester2 = remember { FocusRequester() }

-    LaunchedEffect(viewState) {
-        if (viewState.showSnackbarMessage) {
-            val result = snackbarHostState.showSnackbar(
-                message = viewState.snackbarMessage,
-                actionLabel = viewState.snackbarActionText,
-                duration = SnackbarDuration.Long,
-            )
-            when (result) {
-                SnackbarResult.ActionPerformed -> viewState.onSnackbarActionClick
-                SnackbarResult.Dismissed -> viewState.onSnackbarActionClick
-            }
-        }
+  val screenPadding = 5.dp
+  val fillMaxWidth = .85f
+
+  if (uiState.loading) {
+    LoadingScreen()
+      return
+  }
+
+  fun exportAllConfigs() {
+    try {
+      val files = uiState.tunnels.map { File(context.cacheDir, "${it.name}.conf") }
+      files.forEachIndexed { index, file ->
+        file.outputStream().use { it.write(uiState.tunnels[index].wgQuick.toByteArray()) }
+      }
+      FileUtils.saveFilesToZip(context, files)
+      didExportFiles = true
+      showSnackbarMessage(Event.Message.ConfigsExported.message)
+    } catch (e: Exception) {
+      showSnackbarMessage(Event.Error.Exception(e).message)
    }
+  }

-    fun saveTrustedSSID() {
-        if (currentText.isNotEmpty()) {
-            scope.launch {
-                viewModel.onSaveTrustedSSID(currentText)
-                currentText = ""
-            }
-        }
+  fun saveTrustedSSID() {
+    if (currentText.isNotEmpty()) {
+      viewModel.onSaveTrustedSSID(currentText).let {
+          when(it) {
+              is Result.Success -> currentText = ""
+              is Result.Error -> showSnackbarMessage(it.error.message)
+          }
+      }
    }
+  }

-    if(!backgroundLocationState.status.isGranted) {
-        Column(horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Top,
-            modifier = Modifier
-                .fillMaxSize()
-                .verticalScroll(scrollState)
-                .padding(padding)) {
-            Icon(Icons.Rounded.LocationOff, contentDescription = stringResource(id = R.string.map), modifier = Modifier
-                .padding(30.dp)
-                .size(128.dp))
-            Text(stringResource(R.string.prominent_background_location_title), textAlign = TextAlign.Center, modifier = Modifier.padding(30.dp), fontSize = 20.sp)
-            Text(stringResource(R.string.prominent_background_location_message), textAlign = TextAlign.Center, modifier = Modifier.padding(30.dp), fontSize = 15.sp)
-            //Spacer(modifier = Modifier.weight(1f))
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(30.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceEvenly
-            ) {
-                Button(onClick = {
-                    navController.navigate(Routes.Main.name)
-                }) {
-                    Text(stringResource(id = R.string.no_thanks))
-                }
-                Button(onClick = {
-                    scope.launch {
-                        val intentSettings =
-                            Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
-                        intentSettings.data =
-                            Uri.fromParts("package", context.packageName, null)
-                        context.startActivity(intentSettings)
-                    }
-                }) {
-                    Text(stringResource(id = R.string.turn_on))
-                }
-            }
-        }
-        return
+  fun openSettings() {
+    scope.launch {
+      val intentSettings = Intent(ACTION_APPLICATION_DETAILS_SETTINGS)
+      intentSettings.data = Uri.fromParts("package", context.packageName, null)
+      context.startActivity(intentSettings)
    }
+  }

-    if (tunnels.isEmpty()) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center,
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(padding)
-        ) {
-            Text(
-                stringResource(R.string.one_tunnel_required),
-                textAlign = TextAlign.Center,
-                modifier = Modifier.padding(15.dp),
-                fontStyle = FontStyle.Italic
-            )
+  fun checkFineLocationGranted() {
+    isBackgroundLocationGranted =
+        if (!fineLocationState.status.isGranted) {
+          false
+        } else {
+          viewModel.setLocationDisclosureShown()
+          true
        }
-        return
-    }
+  }

-    Column(
-        horizontalAlignment = Alignment.Start,
-        verticalArrangement = Arrangement.Top,
-        modifier = Modifier
-            .fillMaxSize()
-            .verticalScroll(scrollState)
-            .clickable(indication = null, interactionSource = interactionSource) {
-                focusManager.clearFocus()
-            }
-            .padding(padding)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(14.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Text(stringResource(R.string.enable_auto_tunnel))
-            Switch(
-                checked = settings.isAutoTunnelEnabled,
-                onCheckedChange = {
-                    scope.launch {
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      if(WireGuardAutoTunnel.isRunningOnAndroidTv() && Build.VERSION.SDK_INT == Build.VERSION_CODES.Q){
+          checkFineLocationGranted()
+      } else {
+          val backgroundLocationState =
+              rememberPermissionState(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+          isBackgroundLocationGranted =
+              if (!backgroundLocationState.status.isGranted) {
+                  false
+              } else {
+                  SideEffect { viewModel.setLocationDisclosureShown() }
+                  true
+              }
+      }
+  }
+
+  if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
+    checkFineLocationGranted()
+  }
+
+    AnimatedVisibility(showLocationServicesAlertDialog) {
+        AlertDialog(
+            onDismissRequest = { showLocationServicesAlertDialog = false },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        showLocationServicesAlertDialog = false
                        viewModel.toggleAutoTunnel()
-                    }
-                }
-            )
-        }
-        Text(
-            stringResource(id = R.string.select_tunnel),
-            textAlign = TextAlign.Center,
-            modifier = Modifier.padding(15.dp, bottom = 5.dp, top = 5.dp)
-        )
-        ExposedDropdownMenuBox(
-            expanded = expanded,
-            onExpandedChange = {
-                if(!settings.isAutoTunnelEnabled) {
-                expanded = !expanded }},
-            modifier = Modifier.padding(start = 15.dp, top = 5.dp, bottom = 10.dp),
-        ) {
-            TextField(
-                enabled = !settings.isAutoTunnelEnabled,
-                value = settings.defaultTunnel?.let {
-                    TunnelConfig.from(it).name }
-                    ?: "",
-                readOnly = true,
-                modifier = Modifier.menuAnchor(),
-                label = { Text(stringResource(R.string.tunnels)) },
-                onValueChange = { },
-                trailingIcon = {
-                    ExposedDropdownMenuDefaults.TrailingIcon(
-                        expanded = expanded
-                    )
-                }
-            )
-            ExposedDropdownMenu(
-                expanded = expanded,
-                onDismissRequest = {
-                    expanded = false
-                }
-            ) {
-                tunnels.forEach() { tunnel ->
-                    DropdownMenuItem(
-                        onClick = {
-                            scope.launch {
-                                viewModel.onDefaultTunnelSelected(tunnel)
-                            }
-                            expanded = false
-                        },
-                        text = { Text(text = tunnel.name) }
-                    )
-                }
-            }
-        }
-        Text(
-            stringResource(R.string.trusted_ssid),
-            textAlign = TextAlign.Center,
-            modifier = Modifier.padding(15.dp, bottom = 5.dp, top = 5.dp)
-        )
-        FlowRow(
-            modifier = Modifier.padding(15.dp),
-            horizontalArrangement = Arrangement.spacedBy(8.dp),
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            trustedSSIDs.forEach { ssid ->
-                ClickableIconButton(onIconClick = {
-                    scope.launch {
-                        viewModel.onDeleteTrustedSSID(ssid)
-                    }
-                }, text = ssid, icon = Icons.Filled.Close, enabled = !settings.isAutoTunnelEnabled)
-            }
-        }
-        OutlinedTextField(
-            enabled = !settings.isAutoTunnelEnabled,
-            value = currentText,
-            onValueChange = { currentText = it },
-            label = { Text(stringResource(R.string.add_trusted_ssid)) },
-            modifier = Modifier.padding(start = 15.dp, top = 5.dp),
-            maxLines = 1,
-            keyboardOptions = KeyboardOptions(
-                capitalization = KeyboardCapitalization.None,
-                imeAction = ImeAction.Done
-            ),
-            keyboardActions = KeyboardActions(
-                onDone = {
-                    saveTrustedSSID()
-                }
-            ),
-            trailingIcon = {
-                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 = if(currentText == "") Color.Transparent else Color.Green
-                    )
+                    }) {
+                    Text(text = stringResource(R.string.okay))
                }
            },
-        )
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(14.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Text(stringResource(R.string.tunnel_mobile_data))
-            Switch(
-                enabled = !settings.isAutoTunnelEnabled,
-                checked = settings.isTunnelOnMobileDataEnabled,
-                onCheckedChange = {
-                    scope.launch {
-                        viewModel.onToggleTunnelOnMobileData()
-                    }
+            dismissButton = {
+                TextButton(onClick = { showLocationServicesAlertDialog = false }) {
+                    Text(text = stringResource(R.string.cancel))
                }
-            )
-        }
+            },
+            title = { Text(text = stringResource(R.string.location_services_not_detected)) },
+            text = { Text(text = stringResource(R.string.location_services_missing_message)) })
    }
+
+  if (!uiState.isLocationDisclosureShown) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Top,
+        modifier = Modifier.fillMaxSize().verticalScroll(scrollState).padding(padding)) {
+          Icon(
+              Icons.Rounded.LocationOff,
+              contentDescription = stringResource(id = R.string.map),
+              modifier = Modifier.padding(30.dp).size(128.dp))
+          Text(
+              stringResource(R.string.prominent_background_location_title),
+              textAlign = TextAlign.Center,
+              modifier = Modifier.padding(30.dp),
+              fontSize = 20.sp)
+          Text(
+              stringResource(R.string.prominent_background_location_message),
+              textAlign = TextAlign.Center,
+              modifier = Modifier.padding(30.dp),
+              fontSize = 15.sp)
+          Row(
+              modifier =
+                  if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                    Modifier.fillMaxWidth().padding(10.dp)
+                  } else {
+                    Modifier.fillMaxWidth().padding(30.dp)
+                  },
+              verticalAlignment = Alignment.CenterVertically,
+              horizontalArrangement = Arrangement.SpaceEvenly) {
+                TextButton(onClick = { viewModel.setLocationDisclosureShown() }) {
+                  Text(stringResource(id = R.string.no_thanks))
+                }
+                TextButton(
+                    modifier = Modifier.focusRequester(focusRequester),
+                    onClick = {
+                      openSettings()
+                      viewModel.setLocationDisclosureShown()
+                    }) {
+                      Text(stringResource(id = R.string.turn_on))
+                    }
+              }
+        }
+  }
+
+  if(showAuthPrompt) {
+    AuthorizationPrompt(
+        onSuccess = {
+          showAuthPrompt = false
+          exportAllConfigs()
+        },
+        onError = { _ ->
+          showAuthPrompt = false
+          showSnackbarMessage(Event.Error.AuthenticationFailed.message)
+        },
+        onFailure = {
+          showAuthPrompt = false
+          showSnackbarMessage(Event.Error.AuthorizationFailed.message)
+        })
+  }
+
+  if (uiState.tunnels.isEmpty() && uiState.isLocationDisclosureShown) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center,
+        modifier = Modifier.fillMaxSize().padding(padding)) {
+          Text(
+              stringResource(R.string.one_tunnel_required),
+              textAlign = TextAlign.Center,
+              modifier = Modifier.padding(15.dp),
+              fontStyle = FontStyle.Italic)
+        }
+  }
+  if (uiState.isLocationDisclosureShown && uiState.tunnels.isNotEmpty()) {
+    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 = 60.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(id = R.string.tunnel_on_wifi),
+                          enabled =
+                              !(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 })
+                      AnimatedVisibility(visible = uiState.settings.isTunnelOnWifiEnabled) {
+                        Column {
+                          FlowRow(
+                              modifier = Modifier.padding(screenPadding).fillMaxWidth(),
+                              horizontalArrangement = Arrangement.spacedBy(5.dp)) {
+                                uiState.settings.trustedNetworkSSIDs.forEach { ssid ->
+                                  ClickableIconButton(
+                                      onClick = { if(WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                                          viewModel.onDeleteTrustedSSID(ssid)
+                                          focusRequester2.requestFocus()
+                                      }},
+                                      onIconClick = { viewModel.onDeleteTrustedSSID(ssid) },
+                                      text = ssid,
+                                      icon = Icons.Filled.Close,
+                                      enabled =
+                                          !(uiState.settings.isAutoTunnelEnabled ||
+                                              uiState.settings.isAlwaysOnVpnEnabled))
+                                }
+                                if (uiState.settings.trustedNetworkSSIDs.isEmpty()) {
+                                  Text(
+                                      stringResource(R.string.none),
+                                      fontStyle = FontStyle.Italic,
+                                      color = Color.Gray)
+                                }
+                              }
+                          OutlinedTextField(
+                              enabled =
+                                  !(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)
+                              ,
+                              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)
+                                  }
+                                }
+                              })
+                        }
+                      }
+                      ConfigurationToggle(
+                          stringResource(R.string.tunnel_mobile_data),
+                          enabled =
+                              !(uiState.settings.isAutoTunnelEnabled ||
+                                  uiState.settings.isAlwaysOnVpnEnabled),
+                          checked = uiState.settings.isTunnelOnMobileDataEnabled,
+                          padding = screenPadding,
+                          onCheckChanged = { viewModel.onToggleTunnelOnMobileData() })
+                      ConfigurationToggle(
+                          stringResource(id = R.string.tunnel_on_ethernet),
+                          enabled =
+                              !(uiState.settings.isAutoTunnelEnabled ||
+                                  uiState.settings.isAlwaysOnVpnEnabled),
+                          checked = uiState.settings.isTunnelOnEthernetEnabled,
+                          padding = screenPadding,
+                          onCheckChanged = { viewModel.onToggleTunnelOnEthernet() })
+                      ConfigurationToggle(
+                          stringResource(R.string.battery_saver),
+                          enabled =
+                              !(uiState.settings.isAutoTunnelEnabled ||
+                                  uiState.settings.isAlwaysOnVpnEnabled),
+                          checked = uiState.settings.isBatterySaverEnabled,
+                          padding = screenPadding,
+                          onCheckChanged = { viewModel.onToggleBatterySaver() })
+                      Row(
+                          verticalAlignment = Alignment.CenterVertically,
+                          modifier = (if(!uiState.settings.isAutoTunnelEnabled) Modifier else Modifier.focusRequester(focusRequester))
+                              .fillMaxSize().padding(top = 5.dp),
+                          horizontalArrangement = Arrangement.Center) {
+                            TextButton(
+                                enabled = !uiState.settings.isAlwaysOnVpnEnabled,
+                                onClick = {
+                                  if (uiState.settings.isTunnelOnWifiEnabled && !uiState.settings.isAutoTunnelEnabled) {
+                                      when(false) {
+                                          isBackgroundLocationGranted ->
+                                              showSnackbarMessage(Event.Error.BackgroundLocationRequired.message)
+                                          fineLocationState.status.isGranted ->
+                                              showSnackbarMessage(Event.Error.PreciseLocationRequired.message)
+                                          viewModel.isLocationEnabled(context) ->
+                                              showLocationServicesAlertDialog = true
+                                          else -> {
+                                              viewModel.toggleAutoTunnel()
+                                          }
+                                      }
+                                  } else {
+                                    viewModel.toggleAutoTunnel()
+                                  }
+                                }) {
+                                  val autoTunnelButtonText =
+                                      if (uiState.settings.isAutoTunnelEnabled) {
+                                        stringResource(R.string.disable_auto_tunnel)
+                                      } else {
+                                        stringResource(id = R.string.enable_auto_tunnel)
+                                      }
+                                  Text(autoTunnelButtonText)
+                                }
+                          }
+                    }
+              }
+          if (WgQuickBackend.hasKernelSupport()) {
+            Surface(
+                tonalElevation = 2.dp,
+                shadowElevation = 2.dp,
+                shape = RoundedCornerShape(12.dp),
+                color = MaterialTheme.colorScheme.surface,
+                modifier = Modifier.fillMaxWidth(fillMaxWidth).padding(vertical = 10.dp)) {
+                  Column(
+                      horizontalAlignment = Alignment.Start,
+                      verticalArrangement = Arrangement.Top,
+                      modifier = Modifier.padding(15.dp)) {
+                        SectionTitle(
+                            title = stringResource(id = R.string.kernel), padding = screenPadding)
+                        ConfigurationToggle(
+                            stringResource(R.string.use_kernel),
+                            enabled =
+                                !(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.Success -> {}
+                                }
+                            } })
+                      }
+                }
+          }
+          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)) {
+                  Column(
+                      horizontalAlignment = Alignment.Start,
+                      verticalArrangement = Arrangement.Top,
+                      modifier = Modifier.padding(15.dp)) {
+                        SectionTitle(
+                            title = stringResource(id = R.string.other), padding = screenPadding)
+                        ConfigurationToggle(
+                            stringResource(R.string.always_on_vpn_support),
+                            enabled = !uiState.settings.isAutoTunnelEnabled,
+                            checked = uiState.settings.isAlwaysOnVpnEnabled,
+                            padding = screenPadding,
+                            onCheckChanged = { viewModel.onToggleAlwaysOnVPN() })
+                        ConfigurationToggle(
+                            stringResource(R.string.enabled_app_shortcuts),
+                            enabled = true,
+                            checked = uiState.settings.isShortcutsEnabled,
+                            padding = screenPadding,
+                            onCheckChanged = { viewModel.onToggleShortcutsEnabled() })
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                            modifier = Modifier.fillMaxSize().padding(top = 5.dp),
+                            horizontalArrangement = Arrangement.Center) {
+                              TextButton(
+                                  enabled = !didExportFiles, onClick = { showAuthPrompt = true }) {
+                                    Text(stringResource(R.string.export_configs))
+                                  }
+                            }
+                      }
+                }
+          }
+          if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+            Spacer(modifier = Modifier.weight(.17f))
+          }
+        }
+  }
 }
-
-
@@ -0,0 +1,13 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.settings
+
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnState
+
+data class SettingsUiState(
+    val settings : Settings = Settings(),
+    val tunnels : List<TunnelConfig> = emptyList(),
+    val vpnState: VpnState = VpnState(),
+    val isLocationDisclosureShown : Boolean = true,
+    val loading : Boolean = true
+)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Zane Schepke	61e3751321	fix: start foreground Fixes issue where auto tunnel should be starting service foreground	2023-12-31 22:44:44 -05:00
Zane Schepke	dd16bd977f	fix pipeline sdk target	2023-12-31 20:35:57 -05:00
Zane Schepke	aeb4a13389	feat: androidtv navigation, auto-tunneling pause Improved AndroidTV navigation to be less clunky and more streamlined Added auto-tunneling pause feature to UI to allow of quick auto tunneling pauses. App shortcuts and quick tile also override auto tunneling by engaging pause for temporary override of VPN purposes. Fixed bug where auto start on reboot was not working on older devices and AndroidTV. Fixed bug where location services is prefenting some flavors of Android from using auto-tunneling. Fixed bug where location permissions were not being detected correctly on AndroidTV versions. Fixed bug where quick tile could become out of sync. Improved notifications to show proper state of auto-tunneling and vpn. Removed excessive vibration from notifications. Improved error handling. Closes #75 Closes #73 Closes #61 Closes #53 Closes #30	2023-12-31 17:59:30 -05:00
Zane Schepke	f0ec661223	fix: android 14 foreground permissions Closes #71	2023-12-21 12:22:55 -05:00
Zane Schepke	ffa7a207fb	feat: add basic kernel support Added basic kernel support to allow users to switch between userspace and kernel wireguard Improved location disclosure flow to only show once once per app install Fix airplane mode bug Improve database migration testing Fix auto-tunneling permission bug. Lint Closes #67 Closes #43	2023-12-20 23:17:15 -05:00
Zane Schepke	515e91d191	fix: airplane mode bug	2023-12-09 09:45:54 -05:00
Zane Schepke	16e65aec9f	feat: mobile data only auto-tunneling Added support for configuring auto-tunneling to only tunnel on mobile data with no location permissions necessary. Improved UI on support screen and updated support resource links. Changed UI on setting screen to hide trusted wifi networks configuration when not in use. Changed verbiage on settings screen to make auto-tunneling configuration more intuitive. Fixed UI bug where analytics expansion could show on deactivated tunnels. Closes #55 Closes #56	2023-12-05 01:19:00 -05:00
Zane Schepke	ff87bee3b4	docs: add support.md	2023-11-29 18:13:29 -05:00
Zane Schepke	9739d35eda	chore: update descriptions	2023-11-23 23:48:23 -05:00
Zane Schepke	11ad494fbb	feat: add statistics to main screen Removed Details screen and moved tunnel statistics to be shown on expansion of a tunnel config row Fixes bug where not scanning a QR code could cause app to crash when navigating back from camera view Remove vibrations from notifications Improve navigation of settings screen on AndroidTV	2023-11-23 21:04:26 -05:00
Zane Schepke	90b006acc5	change: build pipeline to fastlane deploy	2023-11-10 18:32:35 -05:00
Zane Schepke	eb7b39c379	fix: build warnings and deprecations	2023-11-08 23:43:46 -05:00
Zane Schepke	0a17593310	add: properties to template	2023-11-08 22:26:36 -05:00
Zane Schepke	c0e58125dd	add: build and release CI Add build and release pipeline for app Fixes bug where location permission screen was not appearing on < Android 9 Bump versions	2023-11-08 22:11:52 -05:00
Zane Schepke	3791261f91	add: build and release CI Add build and release pipeline for app Fixes bug where location permission screen was not appearing on < Android 9 Bump versions	2023-11-08 21:58:17 -05:00
Zane Schepke	d1e61be3ae	Update issue templates	2023-11-04 11:45:00 -04:00
Zane Schepke	afd4fb127f	Update issue templates	2023-11-04 11:41:25 -04:00
Zane Schepke	e0cce8fba4	fix: converter backwards compatibility Fixes database converter to allow for backwards compatabilty.	2023-10-27 00:11:31 -04:00
Zane Schepke	b70ecbdfff	fix: fdroid build and ssid comma Fixes bug where commas in SSID names were splitting into multiple SSIDs due to database type converters. Closes #48 Fixes bug where F-Droid pipeline was failing to build due to lack of proguard rule. Closes #47 Fixes bug where crashes could happen if config QR code or file has improperly configured data. Bump versions.	2023-10-26 22:05:20 -04:00
Zane Schepke	513d08998b	fix: config save bug Fixes a bug where config changes were saving on the wrong thread, causing a failure to save changes. Fixes a bug where the quick tile could cause a crash by initializing the tile state before it was ready.	2023-10-23 16:13:37 -04:00
Zane Schepke	79583e0e61	docs: update README	2023-10-21 15:17:09 -04:00
Zane Schepke	75790ec6d5	bump: app version to 3.1.6	2023-10-21 14:13:47 -04:00
Zane Schepke	a1941b7229	feat: shortcut intents and battery saver Added the ability to turn on and off tunnels via intents to the shortcut activity. Added a setting to enable or disable shortcut/intent control of tunnels. Added an experimental battery saver setting to auto-tunneling to fix the battery drain issue caused by wakelock. Fixes a bug where sometimes the config screen could crash if there are issues parsing the tunnel config data. Database migration	2023-10-21 14:03:36 -04:00
Zane Schepke	37bae82700	feat: zip file import export Added support for importing zip files containing multiple config files. Closes #33 Added support for exporting all config files to downloads folder as a zip with biometric or security pin approval. Added support for editing or viewing private key with biometric or security pin approval. Fixed a bug where VPN status indicator functionality was unintentionally disabled. Other various enhancements and refactors.	2023-10-16 22:43:28 -04:00
Zane Schepke	77cd328a71	fix: config screen edit bug Fixes a bug where config edit will break configs that have commas because a comma and space are required in tunnel configs #42	2023-10-14 01:32:46 -04:00
Zane Schepke	5a1430706b	fix: config edit whitespace bug Closes #42	2023-10-13 23:42:39 -04:00
Zane Schepke	321730536d	fix: file import handling Fixes bug causing crashes when importing a file that is not a .conf file. Fixes file import on AndroidTV and FireTV Closes #39 Fixes usability issue on AndroidTV where textboxes immediately open the keyboard on hover. Allows users two keypress access to turning on tunnels from app load. Closes #36 Improves service efficiencies by making coroutines lifecycle aware.	2023-10-12 20:20:53 -04:00
Zane Schepke	2912238f27	Merge pull request #41 from licaon-kter/patch-1 Gradle 8.3 was released	2023-10-11 09:31:02 -04:00
Licaon_Kter	bc7daacd13	Gradle 8.3 was released	2023-10-11 11:42:58 +00:00
Zane Schepke	c8f2cfd758	feat: ui update with full config edit feat: Change config screen UI to accommodate editing of all fields. Change config screen to allow the addition of new peers. Closes #31 Change main screen to denote primary tunnel with star. Change main screen tunnel options to allow changing tunnel to primary. feat: Change settings screen UI to improve usability. Closes #32 fix: Change application shortcuts to static shortcuts for the primary tunnel. Remove dynamic shortcuts. Closes #38 fix: Database changes from the previous version causing crashes. #40 #37 fix: bug on detail screen where tunnel name was not showing feat: Change button color when hovering on AndroidTV to improve visibility #36 fix: Change file importing method to fix bug on FireTV Closes #39 docs: update README with new screenshots	2023-10-10 13:19:20 -04:00
Zane Schepke	ca3f3fd439	fix: file selection AndroidTV Closes #35 Closes #34	2023-09-28 09:52:35 -04:00
Zane Schepke	235170508b	docs: Update README.md	2023-09-26 17:06:12 -04:00
Zane Schepke	11aea3f1c4	fix: trusted SSIDs bug Fixes bugs where trusted SSIDs were getting whitespace added every time they were saved to the DB. Fixes file explorer bug on AndroidTV where the app crashes if they do not have a file explorer installed on the device.	2023-09-25 06:49:07 -04:00
Zane Schepke	7fbc51af4c	feat: tunnel on ethernet Adds settings feature to enable auto tunneling on ethernet connections. Add alphabetical sorting for split tunneling packages Fix bug where search was not searching by displayed label but by package name Other refactoring and improvements. Closes #29 Closes #27 Closes #28	2023-09-24 07:40:17 -04:00
Zane Schepke	1714618f0c	refactor: bump release to 3.0.0 Bump release to 3.0.0 for F-Droid tag referencing for auto update	2023-09-16 10:46:30 -04:00
Zane Schepke	7cb798a111	refactor: change to static version codes for F-Droid auto-update	2023-09-16 02:06:55 -04:00
Zane Schepke	f8bc264f30	refactor: change qrcode scanner	2023-09-15 14:51:38 -04:00
Zane Schepke	2174c3f48c	fix: f-droid pipelines issues	2023-09-15 13:36:27 -04:00
Zane Schepke	413b9a37df	fix: f-droid build warnings	2023-09-15 13:03:35 -04:00
Zane Schepke	6c30c6bae6	refactor: change flavor to fdroid	2023-09-15 11:31:16 -04:00
Zane Schepke	3c5aff31aa	refactor: objectbox to room Migrated app from using ObjectBox library for db to Room as ObjectBox is not FLOSS compliant. Migrated app to using version catalog for managing dependancies. Added floss build flavor for F-Droid and general build flavor for all other builds. Floss build excludes google analytics and crashlytics. Other performance improvements and refactors.	2023-09-15 07:24:19 -04:00
Zane Schepke	991d1224ab	chore: add fastlane for F-Droid	2023-09-13 03:10:40 -04:00
Zane Schepke	69b07eec6f	feat: support Android 8 Add support for Android 8. Fix shortcuts bug where it was toggling auto-tunneling without setting enabled. Fix shortcuts name not updating with config edits. Bump versions. Closes #25	2023-09-12 12:48:54 -04:00
Zane Schepke	e81066f508	fix: FireTV file selection bug Fixes bug where FireTV devices were unable to launch a proper file browser to select tunnel configs.	2023-09-11 11:15:44 -04:00
Zane Schepke	64bb9f3b82	fix: foreground service start crashes Attempt to fix startForegrounService causing crashes on some devices by not meeting the 5 second notification rule. Add notification to onCreate of services. Limit startForeground to only be called where it is truly necessary in the TileService to allow starting the VPN while app is not running. Attempt to manually initialize mlkit for QR code scanning to remediate some crashes caused by config scanning.	2023-09-10 00:23:23 -04:00
Zane Schepke	c1b560e822	chore: update README.md	2023-09-08 12:43:41 -04:00
Zane Schepke	14fe5821cc	Merge branch 'main' of github.com:zaneschepke/wgtunnel	2023-09-04 05:52:27 -04:00
Zane Schepke	9d9b7bebca	fix: foreground service crash on older devices Fixes a bug where older device take a longer time to launch the foreground service and connect to the VPN. Combined with a delayed launch of foreground notification until VPN connection is confirmed, this would break foreground service,s 5 second notification rule. Fixed by adding a new attempting connection notification to launch on vpn initial connection attempt.	2023-09-04 05:52:15 -04:00
Zane Schepke	12d1ccc084	chore: update README.md	2023-09-04 02:51:05 -04:00
Zane Schepke	20cc2c09b0	feat: dynamic shortcuts and package search Add dynamic on and off shortcuts for each new tunnel added. Shortcuts will toggle auto tunneling to allow manual override. Add package search for split tunneling. Add tunnel toggling from tile even while app is closed and auto tunneling is disabled. Refactor and code cleanup. Closes #23 Closes #21	2023-09-04 02:42:49 -04:00
Zane Schepke	eeccc71469	fix: tile auto tunnel toggle and wifi internet connection check Change tile toggle behavior to also toggle auto tunnel service to allow user temporary override and re-enablement of auto tunnel from the tile. Add tunnel name to tile. Fix bug where wifi networks without internet access were impacting auto tunneling determinations. Closes #22	2023-09-01 13:05:17 -04:00
Zane Schepke	0e64bbb4e1	feat: add quick setting tile Add quick settings tile for easy tunnel toggling and auto-tunnel override. Fix bug on AndroidTV D-pad tunnel control for multiple tunnels. Closes #18 , Closes #20	2023-08-30 23:58:03 -04:00
Zane Schepke	f513297ba0	fix: file selection on older devices Fixes bug where file selection was causing app to crash on older devices.	2023-08-11 21:13:54 -04:00
Zane Schepke	135f8c0459	chore: add tv assets	2023-08-11 20:56:03 -04:00
Zane Schepke	7a811f4152	fix: bug causing crashes on older devices Fixes an issue where watcher service had the potential to crash on older devices if the job was not initialized fast enough. Optimize imports. Bump versions.	2023-08-11 20:21:28 -04:00
Zane Schepke	2abf681d17	feat: support Android 9 Added support for Android 9 by updating permission checks and wifi SSID logic. Fix bug where setting screen was cut off on AndroidTV by updating padding values. Bump wireguard-android library version. Closes #13, Closes #16	2023-08-04 16:43:36 -04:00
Zane Schepke	689c97f452	fix: auto tunneling failure with rapid network changes Fixes issue where rapid network switching could cause unexpected VPN connections and disconnection. Fixed by changing from real time network VPN triggers to three second interval checks. Attempts to optimize battery drain while VPN connected by switching VPN statistics gathering to 10 second intervals. Closes #11, Closes #12, Closes #10	2023-08-01 17:39:11 -04:00
Zane Schepke	08d11a53b4	fix: AndroidTV D-pad control and banner Fix Android TV D-pad access to elements on screen without reloading screen Update AndroidTV banner	2023-07-31 23:38:51 -04:00
Zane Schepke	9952e97e1c	Merge branch 'main' of github.com:zaneschepke/wgtunnel	2023-07-29 18:18:26 -04:00
Zane Schepke	4cdc974778	fix: AndroidTV D-pad support and precise location check Allows app be fully navigated via D-pad on AndroidTV (with some quirks) Adds precise location check to setting screen as WiFi-SSID is not readable without this permission. Closes #2	2023-07-29 18:18:24 -04:00
Zane Schepke	e31a4c03cd	docs: update README.md	2023-07-27 17:21:01 -04:00
Zane Schepke	5b94f22359	docs: update README.md	2023-07-27 17:19:25 -04:00
Zane Schepke	c673a8dc91	feat: support for Always-On VPN and Android TV Added support for Android TV Added support for Always-On VPN in settings Fixes bug where handshake notification is not dismissed after successful handshake Fixes bug that allowed you to use Auto tunneling without Location Services enabled. Now checks for Location Services before allowing access to feature. Closes #2, Closes #5, Closes #8	2023-07-23 00:51:19 -04:00