add package build types

increase auto tunnel delay to 3 seconds

optimize stats job by killing it when app is backgrounded

fix tunnel launch from background

add restart of services and tunnels after update

.editorconfig

@@ -1,8 +1,14 @@
-[{*.kt,*.kts}]
-indent_style = space
-insert_final_newline = true
-max_line_length = 100
+root = true
+
+[*]
+charset = utf-8
 indent_size = 4
+indent_style = tab
+max_line_length = 150
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[{*.kt,*.kts}]
 ij_continuation_indent_size = 4
 ij_java_names_count_to_use_import_on_demand = 9999
 ij_kotlin_align_in_columns_case_branch = false
@@ -11,8 +17,6 @@ ij_kotlin_align_multiline_extends_list = false
 ij_kotlin_align_multiline_method_parentheses = false
 ij_kotlin_align_multiline_parameters = true
 ij_kotlin_align_multiline_parameters_in_calls = false
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true
 ij_kotlin_assignment_wrap = normal
 ij_kotlin_blank_lines_after_class_header = 0
 ij_kotlin_blank_lines_around_block_when_branches = 0
@@ -20,10 +24,7 @@ ij_kotlin_blank_lines_before_declaration_with_comment_or_annotation_on_separate_
 ij_kotlin_block_comment_at_first_column = true
 ij_kotlin_call_parameters_new_line_after_left_paren = true
 ij_kotlin_call_parameters_right_paren_on_new_line = false
-ij_kotlin_call_parameters_wrap = on_every_item
 ij_kotlin_catch_on_new_line = false
-ij_kotlin_class_annotation_wrap = split_into_lines
-ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
 ij_kotlin_continuation_indent_for_chained_calls = true
 ij_kotlin_continuation_indent_for_expression_bodies = true
 ij_kotlin_continuation_indent_in_argument_lists = true
@@ -52,7 +53,6 @@ ij_kotlin_method_annotation_wrap = split_into_lines
 ij_kotlin_method_call_chain_wrap = normal
 ij_kotlin_method_parameters_new_line_after_left_paren = true
 ij_kotlin_method_parameters_right_paren_on_new_line = true
-ij_kotlin_method_parameters_wrap = on_every_item
 ij_kotlin_name_count_to_use_star_import = 9999
 ij_kotlin_name_count_to_use_star_import_for_members = 9999
 ij_kotlin_parameter_annotation_wrap = off
@@ -83,3 +83,15 @@ ij_kotlin_while_on_new_line = false
 ij_kotlin_wrap_elvis_expressions = 1
 ij_kotlin_wrap_expression_body_functions = 1
 ij_kotlin_wrap_first_method_in_call_chain = false
+#compose
+ktlint_standard_filename = disabled
+ktlint_standard_no-wildcard-imports = disabled
+ktlint_standard_function-naming = disabled
+ktlint_standard_property-naming = disabled
+ktlint_standard_package-naming = disabled
+ktlint_function_naming_ignore_when_annotated_with = Composable
+ktlint_code_style = android_studio
+ktlint_standard_import-ordering = disabled
+ktlint_standard_package-naming = disabled
+ij_kotlin_allow_trailing_comma = true
+ij_kotlin_allow_trailing_comma_on_call_site = true

.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: ci-android
+
+on:
+    workflow_dispatch:
+    pull_request:
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: gradle
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      - name: Run ktlint
+        run: ./gradlew ktlintCheck

.github/workflows/pre-release.yml

@@ -1,124 +0,0 @@
-name: Android CI Tag Deployment (Pre-release)
-
-on:
-  workflow_dispatch:
-  push:
-    tags:
-      - '*.*.*-**'
-
-jobs:
-  build:
-    name: Build Signed APK
-
-    runs-on: ubuntu-latest
-
-    env:
-      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
-      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
-      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
-      KEY_STORE_FILE: 'android_keystore.jks'
-      KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
-      GH_USER: ${{ secrets.GH_USER }}
-      GH_TOKEN: ${{ secrets.GH_TOKEN }}
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        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: ${{ env.KEY_STORE_FILE }}
-          fileDir: ${{ env.KEY_STORE_LOCATION }}
-          encodedString: ${{ secrets.KEYSTORE }}
-
-      # create keystore path for gradle to read
-      - name: Create keystore path env var
-        run: |
-          store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
-          echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
-
-      - 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
-      - name: Get version code
-        run: |
-          version_code=$(grep "VERSION_CODE" buildSrc/src/main/kotlin/Constants.kt | awk '{print $5}' | tr -d '\n')
-          echo "VERSION_CODE=$version_code" >> $GITHUB_ENV
-      # 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@v4.3.3
-        with:
-          name: wgtunnel
-          path: ${{ steps.apk-path.outputs.path }}
-      - name: Download APK from build
-        uses: actions/download-artifact@v4
-        with:
-          name: wgtunnel
-      - name: Create Release with Fastlane changelog notes
-        id: create_release
-        uses: softprops/action-gh-release@v2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          # fix hardcode changelog file name
-          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt
-          tag_name: ${{ github.ref_name }}
-          name: ${{ github.ref_name }}
-          draft: false
-          prerelease: true
-          files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
-
-      - name: Install apksigner
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y apksigner
-
-      - name: Get checksum
-        id: checksum
-        run: echo "checksum=$(apksigner verify -print-certs ${{ steps.apk-path.outputs.path }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
-
-      - name: Append checksum
-        id: append_checksum
-        uses: softprops/action-gh-release@v2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          body: |
-            
-            SHA256 fingerprint:
-            ```${{ steps.checksum.outputs.checksum }}```
-          tag_name: ${{ github.ref_name }}
-          name: ${{ github.ref_name }}
-          draft: false
-          prerelease: true
-          append_body: true
-
-      - name: Deploy with fastlane
-        uses: ruby/setup-ruby@v1
-        with:
-          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)
-

.github/workflows/release.yml

@@ -1,17 +1,40 @@
-# name of the workflow
-name: Android CI Tag Deployment (Release)
+name: release-android
 
 on:
+  schedule:
+    - cron: "4 3 * * *"
   workflow_dispatch:
-  push:
-    tags:
-      - '*.*.*'
-      - '!*.*.*-**'
+    inputs:
+      track:
+        type: choice
+        description: "Google play release track"
+        options:
+          - none
+          - internal
+          - alpha
+          - beta
+          - production
+        default: alpha
+        required: true
+      release_type:
+        type: choice
+        description: "GitHub release type"
+        options:
+          - none
+          - prerelease
+          - nightly
+          - release
+        default: release
+        required: true
+      tag_name:
+        description: "Tag name for release"
+        required: false
+        default: nightly
 
 jobs:
   build:
     name: Build Signed APK
-
+    if: ${{ inputs.release_type != 'none' }}
     runs-on: ubuntu-latest
 
     env:
@@ -21,7 +44,9 @@ jobs:
       KEY_STORE_FILE: 'android_keystore.jks'
       KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
       GH_USER: ${{ secrets.GH_USER }}
+      # GH needed for gh cli
       GH_TOKEN: ${{ secrets.GH_TOKEN }}
+      GH_REPO: ${{ github.repository }}
 
     steps:
       - uses: actions/checkout@v4
@@ -34,6 +59,10 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 
+      - name: Install system dependencies
+        run: |
+          sudo apt update && sudo apt install -y gh apksigner
+
       # 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
@@ -57,75 +86,151 @@ jobs:
       # Build and sign APK ("-x test" argument is used to skip tests)
       # add fdroid flavor for apk upload
       - name: Build Fdroid Release APK
+        if: ${{ inputs.release_type != '' && inputs.release_type == 'release' }}
         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
+      - name: Build Fdroid Prerelease APK
+        if: ${{ inputs.release_type != '' && inputs.release_type == 'prerelease' }}
+        run: ./gradlew :app:assembleFdroidPrerelease -x test
+
+      - name: Build Fdroid Nightly APK
+        if: ${{ inputs.release_type == '' || inputs.release_type == 'nightly' }}
+        run: ./gradlew :app:assembleFdroidNightly -x test
+
+      - if: ${{ inputs.release_type == '' || inputs.release_type == 'nightly' }}
+        run: echo "APK_PATH=$(find . -regex '^.*/build/outputs/apk/fdroid/nightly/.*\.apk$' -type f | head -1)" >> $GITHUB_ENV
+      - if: ${{ inputs.release_type != '' && inputs.release_type == 'release' }}
+        run: echo "APK_PATH=$(find . -regex '^.*/build/outputs/apk/fdroid/release/.*\.apk$' -type f | head -1)" >> $GITHUB_ENV
+      - if: ${{ inputs.release_type != '' && inputs.release_type == 'prerelease' }}
+        run: echo "APK_PATH=$(find . -regex '^.*/build/outputs/apk/fdroid/prerelease/.*\.apk$' -type f | head -1)" >> $GITHUB_ENV
+
       - name: Get version code
+        if: ${{ inputs.release_type == 'release' }}
         run: |
           version_code=$(grep "VERSION_CODE" buildSrc/src/main/kotlin/Constants.kt | awk '{print $5}' | tr -d '\n')
           echo "VERSION_CODE=$version_code" >> $GITHUB_ENV
+
       # 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@v4.3.3
+        uses: actions/upload-artifact@v4.3.6
         with:
           name: wgtunnel
-          path: ${{ steps.apk-path.outputs.path }}
+          path: ${{ env.APK_PATH }}
+
       - name: Download APK from build
         uses: actions/download-artifact@v4
         with:
           name: wgtunnel
+
       - name: Repository Dispatch for my F-Droid repo
         uses: peter-evans/repository-dispatch@v3
+        if: ${{ inputs.release_type == 'release' }}
         with:
           token: ${{ secrets.PAT }}
           repository: zaneschepke/fdroid
           event-type: fdroid-update
+
+      # Setup TAG_NAME, which is used as a general "name"
+      - if: github.event_name == 'workflow_dispatch'
+        run: echo "TAG_NAME=${{ github.event.inputs.tag_name }}" >> $GITHUB_ENV
+      - if: github.event_name == 'schedule'
+        run: echo "TAG_NAME=nightly" >> $GITHUB_ENV
+
+      - name: Set version release notes
+        if: ${{ inputs.release_type == 'release' }}
+        run: |
+          RELEASE_NOTES="$(cat ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt)"
+          echo "RELEASE_NOTES<<EOF" >> $GITHUB_ENV
+          echo "$RELEASE_NOTES" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: On nightly release notes
+        if: ${{ contains(env.TAG_NAME, 'nightly') }}
+        run: |
+          echo "RELEASE_NOTES=Nightly build for the latest development version of the app." >> $GITHUB_ENV
+          gh release delete nightly --yes || true
+
+      - name: On prerelease release notes
+        if: ${{ inputs.release_type == 'prerelease' }}
+        run: |
+          echo "RELEASE_NOTES=Testing version of app for specific feature." >> $GITHUB_ENV
+          gh release delete ${{ github.event.inputs.tag_name }} --yes || true
+
+      - name: Get checksum
+        id: checksum
+        run: echo "checksum=$(apksigner verify -print-certs ${{ env.APK_PATH }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
+
+
       - name: Create Release with Fastlane changelog notes
         id: create_release
         uses: softprops/action-gh-release@v2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt
-          tag_name: ${{ github.ref_name }}
-          name: ${{ github.ref_name }}
-          draft: false
-          prerelease: false
-          files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
-
-      - name: Install apksigner
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y apksigner
-
-      - name: Get checksum
-        id: checksum
-        run: echo "checksum=$(apksigner verify -print-certs ${{ steps.apk-path.outputs.path }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
-
-      - name: Append checksum
-        id: append_checksum
-        uses: softprops/action-gh-release@v2
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           body: |
+            ${{ env.RELEASE_NOTES }}
 
             SHA256 fingerprint:
             ```${{ steps.checksum.outputs.checksum }}```
-          tag_name: ${{ github.ref_name }}
-          name: ${{ github.ref_name }}
+          tag_name: ${{ env.TAG_NAME }}
+          name: ${{ env.TAG_NAME }}
           draft: false
-          prerelease: false
-          append_body: true
+          prerelease: ${{ inputs.release_type == 'prerelease' || inputs.release_type == '' || inputs.release_type == 'nightly' }}
+          make_latest: ${{ inputs.release_type == 'release' }}
+          files: ${{ github.workspace }}/${{ env.APK_PATH }}
+
+  publish-play:
+    if: ${{ inputs.track != 'none' && inputs.track != '' }}
+    name: Publish to Google Play
+    runs-on: ubuntu-latest
+
+    env:
+      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
+      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
+      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
+      KEY_STORE_FILE: 'android_keystore.jks'
+      KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
+      GH_USER: ${{ secrets.GH_USER }}
+      GH_TOKEN: ${{ secrets.GH_TOKEN }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        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: ${{ env.KEY_STORE_FILE }}
+          fileDir: ${{ env.KEY_STORE_LOCATION }}
+          encodedString: ${{ secrets.KEYSTORE }}
+
+      # create keystore path for gradle to read
+      - name: Create keystore path env var
+        run: |
+          store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
+          echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
+
+      - name: Create service_account.json
+        id: createServiceAccount
+        run: echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
 
       - 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 Prod track 🚀
-        run: (cd ${{ github.workspace }} && bundle install && bundle exec fastlane production)
+
+      - name: Distribute app to Prod track 🚀
+        run: (cd ${{ github.workspace }} && bundle install && bundle exec fastlane ${{ inputs.track }})
 

.gitignore

@@ -71,3 +71,4 @@ app/release/output.json
 .idea/codeStyles/
 # where we keep our signing secrets locally
 app/signing.properties
+/.kotlin/

README.md

@@ -55,13 +55,13 @@ and on while on different networks. This app was created to offer a free solutio
 * Split tunneling by application with search
 * WireGuard support for kernel and userspace modes
 * Amnezia support for userspace mode for DPI/censorship protection
+* Pre/Post Up/Down scripts support for all modes on a rooted device
 * Always-On VPN support
 * Export Amnezia and WireGuard tunnels to zip
 * Quick tile support for tunnel toggling, auto-tunneling
 * Static shortcuts support for tunnel toggling, auto-tunneling
 * Intent automation support for all tunnels
-* Automatic auto-tunneling service restart after reboot
-* Automatic tunnel restart after reboot
+* Automatic auto-tunneling service and/or tunnel restart after reboot or app update
 * Battery preservation measures
 * Restart tunnel on ping failure (beta)
 

app/build.gradle.kts

@@ -1,11 +1,11 @@
-import java.util.Properties
-
 plugins {
 	alias(libs.plugins.android.application)
 	alias(libs.plugins.kotlin.android)
 	alias(libs.plugins.hilt.android)
 	alias(libs.plugins.kotlinxSerialization)
 	alias(libs.plugins.ksp)
+	alias(libs.plugins.compose.compiler)
+	alias(libs.plugins.grgit)
 }
 
 android {
@@ -20,8 +20,8 @@ android {
 		applicationId = Constants.APP_ID
 		minSdk = Constants.MIN_SDK
 		targetSdk = Constants.TARGET_SDK
-        versionCode = Constants.VERSION_CODE
-        versionName = Constants.VERSION_NAME
+		versionCode = determineVersionCode()
+		versionName = determineVersionName()
 
 		ksp { arg("room.schemaLocation", "$projectDir/schemas") }
 
@@ -35,44 +35,10 @@ 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),
-                    )
+			storeFile = getStoreFile()
+			storePassword = getSigningProperty(Constants.STORE_PASS_VAR)
+			keyAlias = getSigningProperty(Constants.KEY_ALIAS_VAR)
+			keyPassword = getSigningProperty(Constants.KEY_PASS_VAR)
 		}
 	}
 
@@ -82,16 +48,6 @@ android {
 			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 = true
@@ -102,7 +58,38 @@ android {
 			)
 			signingConfig = signingConfigs.getByName(Constants.RELEASE)
 		}
-        debug { isDebuggable = true }
+		debug {
+			applicationIdSuffix = ".debug"
+			versionNameSuffix = "-debug"
+			resValue("string", "app_name", "WG Tunnel - Debug")
+			isDebuggable = true
+		}
+
+		create(Constants.PRERELEASE) {
+			initWith(buildTypes.getByName(Constants.RELEASE))
+			applicationIdSuffix = ".prerelease"
+			versionNameSuffix = "-pre"
+			resValue("string", "app_name", "WG Tunnel - Pre")
+		}
+
+		create(Constants.NIGHTLY) {
+			initWith(buildTypes.getByName(Constants.RELEASE))
+			applicationIdSuffix = ".nightly"
+			versionNameSuffix = "-nightly"
+			resValue("string", "app_name", "WG Tunnel - Nightly")
+		}
+
+		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
+				}
+		}
 	}
 	flavorDimensions.add(Constants.TYPE)
 	productFlavors {
@@ -124,7 +111,6 @@ android {
 		compose = true
 		buildConfig = true
 	}
-    composeOptions { kotlinCompilerExtensionVersion = Constants.COMPOSE_COMPILER_EXTENSION_VERSION }
 	packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
@@ -159,6 +145,7 @@ dependencies {
 	debugImplementation(libs.androidx.compose.manifest)
 
 	// get tunnel lib from github packages or mavenLocal
+// 	implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
 	implementation(libs.tunnel)
 	implementation(libs.amneziawg.android)
 	coreLibraryDesugaring(libs.desugar.jdk.libs)
@@ -166,7 +153,6 @@ dependencies {
 	// logging
 	implementation(libs.timber)
 
-
 	// compose navigation
 	implementation(libs.androidx.navigation.compose)
 	implementation(libs.androidx.hilt.navigation.compose)
@@ -212,3 +198,24 @@ dependencies {
 	// splash
 	implementation(libs.androidx.core.splashscreen)
 }
+
+fun determineVersionCode(): Int {
+	return with(getBuildTaskName().lowercase()) {
+		when {
+			contains(Constants.NIGHTLY) -> Constants.VERSION_CODE + Constants.NIGHTLY_CODE
+			contains(Constants.PRERELEASE) -> Constants.VERSION_CODE + Constants.PRERELEASE_CODE
+			else -> Constants.VERSION_CODE
+		}
+	}
+}
+
+fun determineVersionName(): String {
+	return with(getBuildTaskName().lowercase()) {
+		when {
+			contains(Constants.NIGHTLY) || contains(Constants.PRERELEASE) ->
+				Constants.VERSION_NAME +
+					"-${grgitService.service.get().grgit.head().abbreviatedId}"
+			else -> Constants.VERSION_NAME
+		}
+	}
+}

app/schemas/com.zaneschepke.wireguardautotunnel.data.AppDatabase/9.json

@@ -0,0 +1,197 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 9,
+    "identityHash": "e2c91dbf1885a9da592d3f54f1e08302",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_enabled` INTEGER NOT NULL DEFAULT false, `is_restore_on_boot_enabled` INTEGER NOT NULL DEFAULT false, `is_multi_tunnel_enabled` INTEGER NOT NULL DEFAULT false, `is_auto_tunnel_paused` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false, `is_amnezia_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnWifiEnabled",
+            "columnName": "is_tunnel_on_wifi_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelEnabled",
+            "columnName": "is_kernel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isRestoreOnBootEnabled",
+            "columnName": "is_restore_on_boot_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isMultiTunnelEnabled",
+            "columnName": "is_multi_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isAutoTunnelPaused",
+            "columnName": "is_auto_tunnel_paused",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPingEnabled",
+            "columnName": "is_ping_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isAmneziaEnabled",
+            "columnName": "is_amnezia_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "tunnelNetworks",
+            "columnName": "tunnel_networks",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isMobileDataTunnel",
+            "columnName": "is_mobile_data_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPrimaryTunnel",
+            "columnName": "is_primary_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "amQuick",
+            "columnName": "am_quick",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isActive",
+            "columnName": "is_Active",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "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, 'e2c91dbf1885a9da592d3f54f1e08302')"
+    ]
+  }
+}

app/src/main/AndroidManifest.xml

@@ -31,6 +31,12 @@
     <!--start service on boot permission-->
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <!--android tv support-->
+
+	<permission
+		android:name="${applicationId}.permission.CONTROL_TUNNELS"
+		android:icon="@mipmap/ic_launcher"
+		android:protectionLevel="dangerous" />
+
     <uses-feature
         android:name="android.software.leanback"
         android:required="false" />
@@ -71,7 +77,7 @@
 
                 <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"
@@ -80,21 +86,21 @@
         <activity
             android:name=".ui.MainActivity"
             android:exported="true"
-            android:screenOrientation="portrait"
             android:theme="@style/Theme.WireguardAutoTunnel">
-            <intent-filter>
-                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
-            </intent-filter>
         </activity>
         <activity
             android:name="com.journeyapps.barcodescanner.CaptureActivity"
             android:screenOrientation="portrait"
             tools:replace="screenOrientation" />
+
         <activity
             android:name=".service.shortcut.ShortcutsActivity"
             android:enabled="true"
             android:exported="true"
+			android:noHistory="true"
+			android:excludeFromRecents="true"
 			android:finishOnTaskLaunch="true"
+			android:launchMode="singleInstance"
             android:theme="@android:style/Theme.NoDisplay" />
 
         <service
@@ -138,7 +144,7 @@
             </intent-filter>
         </service>
 		<service
-            android:name=".service.foreground.WireGuardTunnelService"
+			android:name=".service.tunnel.AlwaysOnVpnService"
 			android:enabled="true"
 			android:exported="false"
 			android:foregroundServiceType="systemExempted"
@@ -153,7 +159,7 @@
 				android:value="true" />
 		</service>
         <service
-            android:name=".service.foreground.WireGuardConnectivityWatcherService"
+            android:name=".service.foreground.AutoTunnelService"
             android:enabled="true"
             android:exported="false"
             android:foregroundServiceType="systemExempted"
@@ -161,6 +167,16 @@
             android:stopWithTask="false"
             tools:node="merge" />
 
+		<service
+			android:name=".service.foreground.TunnelBackgroundService"
+			android:exported="false"
+			android:foregroundServiceType="systemExempted"
+			android:permission="android.permission.BIND_VPN_SERVICE">
+			<intent-filter>
+				<action android:name="android.net.VpnService" />
+			</intent-filter>
+		</service>
+
         <receiver
             android:name=".receiver.BootReceiver"
             android:enabled="true"
@@ -175,7 +191,23 @@
             </intent-filter>
         </receiver>
 		<receiver
-            android:name=".receiver.NotificationActionReceiver"
-            android:exported="false" />
+			android:name=".receiver.BackgroundActionReceiver"
+			android:enabled="true"
+			android:exported="false"/>
+		<receiver
+			android:name=".receiver.AppUpdateReceiver"
+			android:exported="false">
+			<intent-filter>
+				<action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+			</intent-filter>
+		</receiver>
+		<receiver
+			android:name=".receiver.KernelReceiver"
+			android:exported="false"
+			android:permission="${applicationId}.permission.CONTROL_TUNNELS">
+			<intent-filter>
+				<action android:name="com.wireguard.android.action.REFRESH_TUNNEL_STATES" />
+			</intent-filter>
+		</receiver>
     </application>
 </manifest>

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

@@ -1,20 +1,34 @@
 package com.zaneschepke.wireguardautotunnel
 
 import android.app.Application
-import android.content.ComponentName
-import android.content.pm.PackageManager
 import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
-import android.service.quicksettings.TileService
-import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
-import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
+import com.zaneschepke.logcatter.LocalLogCollector
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import timber.log.Timber
+import javax.inject.Inject
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
 
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	@Inject
+	lateinit var localLogCollector: LocalLogCollector
+
+	@Inject
+	@IoDispatcher
+	lateinit var ioDispatcher: CoroutineDispatcher
+
 	override fun onCreate() {
 		super.onCreate()
 		instance = this
@@ -28,30 +42,18 @@ class WireGuardAutoTunnel : Application() {
 					.penaltyLog()
 					.build(),
 			)
-        } else Timber.plant(ReleaseTree())
+		} else {
+			Timber.plant(ReleaseTree())
+		}
+		if (!isRunningOnTv()) {
+			applicationScope.launch(ioDispatcher) {
+				localLogCollector.start()
+			}
+		}
 	}
 
 	companion object {
-
 		lateinit var instance: WireGuardAutoTunnel
 			private set
-
-        fun isRunningOnAndroidTv(): Boolean {
-            return instance.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
-        }
-
-        fun requestTunnelTileServiceStateUpdate() {
-            TileService.requestListeningState(
-                instance,
-                ComponentName(instance, TunnelControlTile::class.java),
-            )
-        }
-
-        fun requestAutoTunnelTileServiceUpdate() {
-            TileService.requestListeningState(
-                instance,
-                ComponentName(instance, AutoTunnelControlTile::class.java),
-            )
-        }
 	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/AppDatabase.kt

@@ -11,7 +11,7 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 
 @Database(
 	entities = [Settings::class, TunnelConfig::class],
-    version = 8,
+	version = 9,
 	autoMigrations =
 	[
 		AutoMigration(from = 1, to = 2),
@@ -34,6 +34,7 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 			spec = RemoveLegacySettingColumnsMigration::class,
 		),
 		AutoMigration(7, 8),
+		AutoMigration(8, 9),
 	],
 	exportSchema = true,
 )

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

@@ -6,7 +6,7 @@ import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 @Dao
@@ -23,6 +23,9 @@ interface TunnelConfigDao {
 	@Query("SELECT * FROM TunnelConfig WHERE name=:name")
 	suspend fun getByName(name: String): TunnelConfig?
 
+	@Query("SELECT * FROM TunnelConfig WHERE is_Active=1")
+	suspend fun getActive(): TunnelConfigs
+
 	@Query("SELECT * FROM TunnelConfig")
 	suspend fun getAll(): TunnelConfigs
 

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/datastore/DataStoreManager.kt

@@ -19,14 +19,12 @@ import java.io.IOException
 
 class DataStoreManager(
 	private val context: Context,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) {
 	companion object {
 		val LOCATION_DISCLOSURE_SHOWN = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
 		val BATTERY_OPTIMIZE_DISABLE_SHOWN = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
-        val TUNNEL_RUNNING_FROM_MANUAL_START =
-            booleanPreferencesKey("TUNNEL_RUNNING_FROM_MANUAL_START")
-        val ACTIVE_TUNNEL = intPreferencesKey("ACTIVE_TUNNEL")
+		val LAST_ACTIVE_TUNNEL = intPreferencesKey("LAST_ACTIVE_TUNNEL")
 		val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
 		val IS_PIN_LOCK_ENABLED = booleanPreferencesKey("PIN_LOCK_ENABLED")
 	}
@@ -60,7 +58,6 @@ class DataStoreManager(
 		}
 	}
 
-
 	fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map { it[key] }
 
 	suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
@@ -74,7 +71,6 @@ class DataStoreManager(
 		}
 	}
 
-
 	fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
 		context.dataStore.data.map { it[key] }.first()
 	}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/domain/GeneralState.kt

@@ -3,14 +3,12 @@ package com.zaneschepke.wireguardautotunnel.data.domain
 data class GeneralState(
 	val isLocationDisclosureShown: Boolean = LOCATION_DISCLOSURE_SHOWN_DEFAULT,
 	val isBatteryOptimizationDisableShown: Boolean = BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-    val isTunnelRunningFromManualStart: Boolean = TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
 	val isPinLockEnabled: Boolean = PIN_LOCK_ENABLED_DEFAULT,
-    val activeTunnelId: Int? = null
+	val lastActiveTunnelId: Int? = null,
 ) {
 	companion object {
 		const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
 		const val BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT = false
-        const val TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT = false
 		const val PIN_LOCK_ENABLED_DEFAULT = false
 	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/domain/TunnelConfig.kt

@@ -32,8 +32,17 @@ data class TunnelConfig(
 		defaultValue = "",
 	)
 	val amQuick: String = AM_QUICK_DEFAULT,
+	@ColumnInfo(
+		name = "is_Active",
+		defaultValue = "false",
+	)
+	val isActive: Boolean = false,
 ) {
 	companion object {
+		fun findDefault(tunnels: List<TunnelConfig>): TunnelConfig? {
+			return tunnels.find { it.isPrimaryTunnel } ?: tunnels.firstOrNull()
+		}
+
 		fun configFromWgQuick(wgQuick: String): Config {
 			val inputStream: InputStream = wgQuick.byteInputStream()
 			return inputStream.bufferedReader(Charsets.UTF_8).use {

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

@@ -4,9 +4,8 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 
 interface AppDataRepository {
 	suspend fun getPrimaryOrFirstTunnel(): TunnelConfig?
-    suspend fun getStartTunnelConfig(): TunnelConfig?
 
-    suspend fun toggleWatcherServicePause()
+	suspend fun getStartTunnelConfig(): TunnelConfig?
 
 	val settings: SettingsRepository
 	val tunnels: TunnelConfigRepository

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

@@ -3,32 +3,20 @@ package com.zaneschepke.wireguardautotunnel.data.repository
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import javax.inject.Inject
 
-class AppDataRoomRepository @Inject constructor(
+class AppDataRoomRepository
+@Inject
+constructor(
 	override val settings: SettingsRepository,
 	override val tunnels: TunnelConfigRepository,
-    override val appState: AppStateRepository
+	override val appState: AppStateRepository,
 ) : AppDataRepository {
 	override suspend fun getPrimaryOrFirstTunnel(): TunnelConfig? {
 		return tunnels.findPrimary().firstOrNull() ?: tunnels.getAll().firstOrNull()
 	}
 
 	override suspend fun getStartTunnelConfig(): TunnelConfig? {
-        return if (appState.isTunnelRunningFromManualStart()) {
-            appState.getActiveTunnelId()?.let {
+		return appState.getLastActiveTunnelId()?.let {
 			tunnels.getById(it)
-            }
-        } else null
-    }
-
-    override suspend fun toggleWatcherServicePause() {
-        val settings = settings.getSettings()
-        if (settings.isAutoTunnelEnabled) {
-            val pauseAutoTunnel = !settings.isAutoTunnelPaused
-            this.settings.save(
-                settings.copy(
-                    isAutoTunnelPaused = pauseAutoTunnel,
-                ),
-            )
-        }
+		} ?: getPrimaryOrFirstTunnel()
 	}
 }

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

@@ -5,25 +5,24 @@ import kotlinx.coroutines.flow.Flow
 
 interface AppStateRepository {
 	suspend fun isLocationDisclosureShown(): Boolean
+
 	suspend fun setLocationDisclosureShown(shown: Boolean)
 
 	suspend fun isPinLockEnabled(): Boolean
+
 	suspend fun setPinLockEnabled(enabled: Boolean)
 
 	suspend fun isBatteryOptimizationDisableShown(): Boolean
+
 	suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
 
-    suspend fun isTunnelRunningFromManualStart(): Boolean
-    suspend fun setTunnelRunningFromManualStart(id: Int)
+	suspend fun getLastActiveTunnelId(): Int?
 
-    suspend fun setManualStop()
-
-    suspend fun getActiveTunnelId(): Int?
+	suspend fun setLastActiveTunnelId(id: Int)
 
 	suspend fun getCurrentSsid(): String?
 
 	suspend fun setCurrentSsid(ssid: String)
 
 	val generalStateFlow: Flow<GeneralState>
-
 }

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

@@ -2,71 +2,65 @@ package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
 import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
 import timber.log.Timber
 
-class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager) :
+class DataStoreAppStateRepository(
+	private val dataStoreManager: DataStoreManager,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+) :
 	AppStateRepository {
 	override suspend fun isLocationDisclosureShown(): Boolean {
-        return dataStoreManager.getFromStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN)
+		return withContext(ioDispatcher) {
+			dataStoreManager.getFromStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN)
 				?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
 		}
+	}
 
 	override suspend fun setLocationDisclosureShown(shown: Boolean) {
-        dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown)
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown) }
 	}
 
 	override suspend fun isPinLockEnabled(): Boolean {
-        return dataStoreManager.getFromStore(DataStoreManager.IS_PIN_LOCK_ENABLED)
+		return withContext(ioDispatcher) {
+			dataStoreManager.getFromStore(DataStoreManager.IS_PIN_LOCK_ENABLED)
 				?: GeneralState.PIN_LOCK_ENABLED_DEFAULT
 		}
+	}
 
 	override suspend fun setPinLockEnabled(enabled: Boolean) {
-        dataStoreManager.saveToDataStore(DataStoreManager.IS_PIN_LOCK_ENABLED, enabled)
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.IS_PIN_LOCK_ENABLED, enabled) }
 	}
 
 	override suspend fun isBatteryOptimizationDisableShown(): Boolean {
-        return dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
+		return withContext(ioDispatcher) {
+			dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
 				?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
 		}
+	}
 
 	override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
-        dataStoreManager.saveToDataStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN, shown)
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN, shown) }
 	}
 
-    override suspend fun isTunnelRunningFromManualStart(): Boolean {
-        return dataStoreManager.getFromStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START)
-            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT
+	override suspend fun getLastActiveTunnelId(): Int? {
+		return withContext(ioDispatcher) { dataStoreManager.getFromStore(DataStoreManager.LAST_ACTIVE_TUNNEL) }
 	}
 
-    override suspend fun setTunnelRunningFromManualStart(id: Int) {
-        setTunnelRunningFromManualStart(true)
-        setActiveTunnelId(id)
-    }
-
-    override suspend fun setManualStop() {
-        setTunnelRunningFromManualStart(false)
-    }
-
-    private suspend fun setTunnelRunningFromManualStart(running: Boolean) {
-        dataStoreManager.saveToDataStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START, running)
-    }
-
-    override suspend fun getActiveTunnelId(): Int? {
-        return dataStoreManager.getFromStore(DataStoreManager.ACTIVE_TUNNEL)
-    }
-
-    private suspend fun setActiveTunnelId(id: Int) {
-        dataStoreManager.saveToDataStore(DataStoreManager.ACTIVE_TUNNEL, id)
+	override suspend fun setLastActiveTunnelId(id: Int) {
+		return withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.LAST_ACTIVE_TUNNEL, id) }
 	}
 
 	override suspend fun getCurrentSsid(): String? {
-        return dataStoreManager.getFromStore(DataStoreManager.CURRENT_SSID)
+		return withContext(ioDispatcher) { dataStoreManager.getFromStore(DataStoreManager.CURRENT_SSID) }
 	}
 
 	override suspend fun setCurrentSsid(ssid: String) {
-        dataStoreManager.saveToDataStore(DataStoreManager.CURRENT_SSID, ssid)
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.CURRENT_SSID, ssid) }
 	}
 
 	override val generalStateFlow: Flow<GeneralState> =
@@ -74,14 +68,16 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
 			prefs?.let { pref ->
 				try {
 					GeneralState(
-                        isLocationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
+						isLocationDisclosureShown =
+						pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
 							?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-                        isBatteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
+						isBatteryOptimizationDisableShown =
+						pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
 							?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-                        isTunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
-                            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
-                        isPinLockEnabled = pref[DataStoreManager.IS_PIN_LOCK_ENABLED]
-                            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
+						isPinLockEnabled =
+						pref[DataStoreManager.IS_PIN_LOCK_ENABLED]
+							?: GeneralState.PIN_LOCK_ENABLED_DEFAULT,
+						lastActiveTunnelId = pref[DataStoreManager.LAST_ACTIVE_TUNNEL],
 					)
 				} catch (e: IllegalArgumentException) {
 					Timber.e(e)

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

@@ -2,23 +2,29 @@ package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
 
-class RoomSettingsRepository(private val settingsDoa: SettingsDao) : SettingsRepository {
-
+class RoomSettingsRepository(private val settingsDoa: SettingsDao, @IoDispatcher private val ioDispatcher: CoroutineDispatcher) : SettingsRepository {
 	override suspend fun save(settings: Settings) {
+		withContext(ioDispatcher) {
 			settingsDoa.save(settings)
 		}
+	}
 
 	override fun getSettingsFlow(): Flow<Settings> {
 		return settingsDoa.getSettingsFlow()
 	}
 
 	override suspend fun getSettings(): Settings {
-        return settingsDoa.getAll().firstOrNull() ?: Settings()
+		return withContext(ioDispatcher) {
+			settingsDoa.getAll().firstOrNull() ?: Settings()
+		}
 	}
 
 	override suspend fun getAll(): List<Settings> {
-        return settingsDoa.getAll()
+		return withContext(ioDispatcher) { settingsDoa.getAll() }
 	}
 }

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

@@ -1,25 +1,38 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
 
-class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
+class RoomTunnelConfigRepository(
+	private val tunnelConfigDao: TunnelConfigDao,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+) :
 	TunnelConfigRepository {
 	override fun getTunnelConfigsFlow(): Flow<TunnelConfigs> {
 		return tunnelConfigDao.getAllFlow()
 	}
 
 	override suspend fun getAll(): TunnelConfigs {
-        return tunnelConfigDao.getAll()
+		return withContext(ioDispatcher) { tunnelConfigDao.getAll() }
 	}
 
 	override suspend fun save(tunnelConfig: TunnelConfig) {
+		withContext(ioDispatcher) {
 			tunnelConfigDao.save(tunnelConfig)
+		}.also {
+			WireGuardAutoTunnel.instance.requestTunnelTileServiceStateUpdate()
+		}
 	}
 
 	override suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?) {
+		withContext(ioDispatcher) {
 			tunnelConfigDao.resetPrimaryTunnel()
 			tunnelConfig?.let {
 				save(
@@ -28,10 +41,11 @@ class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
 					),
 				)
 			}
-
+		}
 	}
 
 	override suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?) {
+		withContext(ioDispatcher) {
 			tunnelConfigDao.resetMobileDataTunnel()
 			tunnelConfig?.let {
 				save(
@@ -41,32 +55,43 @@ class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
 				)
 			}
 		}
+	}
 
 	override suspend fun delete(tunnelConfig: TunnelConfig) {
+		withContext(ioDispatcher) {
 			tunnelConfigDao.delete(tunnelConfig)
+		}.also {
+			WireGuardAutoTunnel.instance.requestTunnelTileServiceStateUpdate()
+		}
 	}
 
 	override suspend fun getById(id: Int): TunnelConfig? {
-        return tunnelConfigDao.getById(id.toLong())
+		return withContext(ioDispatcher) { tunnelConfigDao.getById(id.toLong()) }
+	}
+
+	override suspend fun getActive(): TunnelConfigs {
+		return withContext(ioDispatcher) {
+			tunnelConfigDao.getActive()
+		}
 	}
 
 	override suspend fun count(): Int {
-        return tunnelConfigDao.count().toInt()
+		return withContext(ioDispatcher) { tunnelConfigDao.count().toInt() }
 	}
 
 	override suspend fun findByTunnelName(name: String): TunnelConfig? {
-        return tunnelConfigDao.getByName(name)
+		return withContext(ioDispatcher) { tunnelConfigDao.getByName(name) }
 	}
 
 	override suspend fun findByTunnelNetworksName(name: String): TunnelConfigs {
-        return tunnelConfigDao.findByTunnelNetworkName(name)
+		return withContext(ioDispatcher) { tunnelConfigDao.findByTunnelNetworkName(name) }
 	}
 
 	override suspend fun findByMobileDataTunnel(): TunnelConfigs {
-        return tunnelConfigDao.findByMobileDataTunnel()
+		return withContext(ioDispatcher) { tunnelConfigDao.findByMobileDataTunnel() }
 	}
 
 	override suspend fun findPrimary(): TunnelConfigs {
-        return tunnelConfigDao.findByPrimary()
+		return withContext(ioDispatcher) { tunnelConfigDao.findByPrimary() }
 	}
 }

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

@@ -1,11 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 interface TunnelConfigRepository {
-
 	fun getTunnelConfigsFlow(): Flow<TunnelConfigs>
 
 	suspend fun getAll(): TunnelConfigs
@@ -20,6 +19,8 @@ interface TunnelConfigRepository {
 
 	suspend fun getById(id: Int): TunnelConfig?
 
+	suspend fun getActive(): TunnelConfigs
+
 	suspend fun count(): Int
 
 	suspend fun findByTunnelName(name: String): TunnelConfig?

app/src/main/java/com/zaneschepke/wireguardautotunnel/module/AppModule.kt

@@ -2,7 +2,7 @@ package com.zaneschepke.wireguardautotunnel.module
 
 import android.content.Context
 import com.zaneschepke.logcatter.LocalLogCollector
-import com.zaneschepke.logcatter.LogcatHelper
+import com.zaneschepke.logcatter.LogcatUtil
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -25,6 +25,6 @@ class AppModule {
 	@Singleton
 	@Provides
 	fun provideLogCollect(@ApplicationContext context: Context): LocalLogCollector {
-        return LogcatHelper.init(context = context)
+		return LogcatUtil.init(context = context)
 	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/module/RepositoryModule.kt

@@ -54,29 +54,26 @@ class RepositoryModule {
 
 	@Singleton
 	@Provides
-    fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao): TunnelConfigRepository {
-        return RoomTunnelConfigRepository(tunnelConfigDao)
+	fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): TunnelConfigRepository {
+		return RoomTunnelConfigRepository(tunnelConfigDao, ioDispatcher)
 	}
 
 	@Singleton
 	@Provides
-    fun provideSettingsRepository(settingsDao: SettingsDao): SettingsRepository {
-        return RoomSettingsRepository(settingsDao)
+	fun provideSettingsRepository(settingsDao: SettingsDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): SettingsRepository {
+		return RoomSettingsRepository(settingsDao, ioDispatcher)
 	}
 
 	@Singleton
 	@Provides
-    fun providePreferencesDataStore(
-        @ApplicationContext context: Context,
-        @IoDispatcher ioDispatcher: CoroutineDispatcher
-    ): DataStoreManager {
+	fun providePreferencesDataStore(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): DataStoreManager {
 		return DataStoreManager(context, ioDispatcher)
 	}
 
 	@Provides
 	@Singleton
-    fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
-        return DataStoreAppStateRepository(dataStoreManager)
+	fun provideGeneralStateRepository(dataStoreManager: DataStoreManager, @IoDispatcher ioDispatcher: CoroutineDispatcher): AppStateRepository {
+		return DataStoreAppStateRepository(dataStoreManager, ioDispatcher)
 	}
 
 	@Provides
@@ -84,10 +81,8 @@ class RepositoryModule {
 	fun provideAppDataRepository(
 		settingsRepository: SettingsRepository,
 		tunnelConfigRepository: TunnelConfigRepository,
-        appStateRepository: AppStateRepository
+		appStateRepository: AppStateRepository,
 	): AppDataRepository {
 		return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
 	}
-
-
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/module/ServiceModule.kt

@@ -17,9 +17,7 @@ import dagger.hilt.android.scopes.ServiceScoped
 abstract class ServiceModule {
 	@Binds
 	@ServiceScoped
-    abstract fun provideNotificationService(
-        wireGuardNotification: WireGuardNotification
-    ): NotificationService
+	abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification): NotificationService
 
 	@Binds
 	@ServiceScoped
@@ -27,13 +25,9 @@ abstract class ServiceModule {
 
 	@Binds
 	@ServiceScoped
-    abstract fun provideMobileDataService(
-        mobileDataService: MobileDataService
-    ): NetworkService<MobileDataService>
+	abstract fun provideMobileDataService(mobileDataService: MobileDataService): NetworkService<MobileDataService>
 
 	@Binds
 	@ServiceScoped
-    abstract fun provideEthernetService(
-        ethernetService: EthernetService
-    ): NetworkService<EthernetService>
+	abstract fun provideEthernetService(ethernetService: EthernetService): NetworkService<EthernetService>
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/module/TunnelModule.kt

@@ -3,12 +3,13 @@ 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.RootTunnelActionHandler
 import com.wireguard.android.backend.WgQuickBackend
 import com.wireguard.android.util.RootShell
 import com.wireguard.android.util.ToolsInstaller
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
 import dagger.Provides
@@ -29,24 +30,30 @@ class TunnelModule {
 		return RootShell(context)
 	}
 
+	@Provides
+	@Singleton
+	fun provideRootShellAm(@ApplicationContext context: Context): org.amnezia.awg.util.RootShell {
+		return org.amnezia.awg.util.RootShell(context)
+	}
+
 	@Provides
 	@Singleton
 	@Userspace
-    fun provideUserspaceBackend(@ApplicationContext context: Context): Backend {
-        return GoBackend(context)
+	fun provideUserspaceBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
+		return GoBackend(context, RootTunnelActionHandler(rootShell))
 	}
 
 	@Provides
 	@Singleton
 	@Kernel
 	fun provideKernelBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
-        return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
+		return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell), RootTunnelActionHandler(rootShell))
 	}
 
 	@Provides
 	@Singleton
-    fun provideAmneziaBackend(@ApplicationContext context: Context): org.amnezia.awg.backend.Backend {
-        return org.amnezia.awg.backend.GoBackend(context)
+	fun provideAmneziaBackend(@ApplicationContext context: Context, rootShell: org.amnezia.awg.util.RootShell): org.amnezia.awg.backend.Backend {
+		return org.amnezia.awg.backend.GoBackend(context, org.amnezia.awg.backend.RootTunnelActionHandler(rootShell))
 	}
 
 	@Provides
@@ -57,8 +64,8 @@ class TunnelModule {
 		@Kernel kernelBackend: Provider<Backend>,
 		appDataRepository: AppDataRepository,
 		@ApplicationScope applicationScope: CoroutineScope,
-        @IoDispatcher ioDispatcher: CoroutineDispatcher
-    ): VpnService {
+		@IoDispatcher ioDispatcher: CoroutineDispatcher,
+	): TunnelService {
 		return WireGuardTunnel(
 			amneziaBackend,
 			userspaceBackend,
@@ -71,10 +78,7 @@ class TunnelModule {
 
 	@Provides
 	@Singleton
-    fun provideServiceManager(
-        appDataRepository: AppDataRepository,
-        @IoDispatcher ioDispatcher: CoroutineDispatcher
-    ): ServiceManager {
-        return ServiceManager(appDataRepository, ioDispatcher)
+	fun provideServiceManager(): ServiceManager {
+		return ServiceManager()
 	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/module/ViewModelModule.kt

@@ -13,13 +13,9 @@ import kotlinx.coroutines.CoroutineDispatcher
 @Module
 @InstallIn(ViewModelComponent::class)
 class ViewModelModule {
-
 	@ViewModelScoped
 	@Provides
-    fun provideFileUtils(
-        @ApplicationContext context: Context,
-        @IoDispatcher ioDispatcher: CoroutineDispatcher
-    ): FileUtils {
+	fun provideFileUtils(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): FileUtils {
 		return FileUtils(context, ioDispatcher)
 	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/receiver/AppUpdateReceiver.kt

@@ -0,0 +1,47 @@
+package com.zaneschepke.wireguardautotunnel.receiver
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.startTunnelBackground
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class AppUpdateReceiver : BroadcastReceiver() {
+
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
+
+	@Inject
+	lateinit var serviceManager: ServiceManager
+
+	@Inject
+	lateinit var tunnelService: TunnelService
+
+	override fun onReceive(context: Context, intent: Intent) {
+		if (intent.action != Intent.ACTION_MY_PACKAGE_REPLACED) return
+		applicationScope.launch {
+			val settings = appDataRepository.settings.getSettings()
+			if (settings.isAutoTunnelEnabled) {
+				Timber.i("Restarting services after upgrade")
+				serviceManager.startWatcherServiceForeground(context)
+			}
+			if (!settings.isAutoTunnelEnabled || settings.isAutoTunnelPaused) {
+				val tunnels = appDataRepository.tunnels.getAll().filter { it.isActive }
+				if (tunnels.isNotEmpty()) context.startTunnelBackground(tunnels.first().id)
+			}
+		}
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/receiver/BackgroundActionReceiver.kt

@@ -0,0 +1,64 @@
+package com.zaneschepke.wireguardautotunnel.receiver
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+import javax.inject.Provider
+
+@AndroidEntryPoint
+class BackgroundActionReceiver : BroadcastReceiver() {
+
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
+
+	@Inject
+	lateinit var tunnelConfigRepository: TunnelConfigRepository
+
+	@Inject
+	lateinit var serviceManager: ServiceManager
+
+	override fun onReceive(context: Context, intent: Intent) {
+		val id = intent.getIntExtra(TUNNEL_ID_EXTRA_KEY, 0)
+		if (id == 0) return
+		when (intent.action) {
+			ACTION_CONNECT -> {
+				Timber.d("Connect actions")
+				applicationScope.launch {
+					val tunnel = tunnelConfigRepository.getById(id)
+					tunnel?.let {
+						serviceManager.startTunnelBackgroundService(context)
+						tunnelService.get().startTunnel(it)
+					}
+				}
+			}
+			ACTION_DISCONNECT -> {
+				applicationScope.launch {
+					val tunnel = tunnelConfigRepository.getById(id)
+					tunnel?.let {
+						serviceManager.stopTunnelBackgroundService(context)
+						tunnelService.get().stopTunnel(it)
+					}
+				}
+			}
+		}
+	}
+
+	companion object {
+		const val ACTION_CONNECT = "ACTION_CONNECT"
+		const val ACTION_DISCONNECT = "ACTION_DISCONNECT"
+		const val TUNNEL_ID_EXTRA_KEY = "tunnelId"
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/receiver/BootReceiver.kt

@@ -6,18 +6,23 @@ import android.content.Intent
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.startTunnelBackground
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 @AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {
-
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
+
 	@Inject
 	lateinit var serviceManager: ServiceManager
 
@@ -25,32 +30,19 @@ class BootReceiver : BroadcastReceiver() {
 	@ApplicationScope
 	lateinit var applicationScope: CoroutineScope
 
-    override fun onReceive(context: Context?, intent: Intent?) {
-        if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return
-        context?.run {
+	override fun onReceive(context: Context, intent: Intent) {
+		if (Intent.ACTION_BOOT_COMPLETED != intent.action) return
 		applicationScope.launch {
 			val settings = appDataRepository.settings.getSettings()
-                if(settings.isRestoreOnBootEnabled) {
+			if (settings.isRestoreOnBootEnabled) {
+				appDataRepository.getStartTunnelConfig()?.let {
+					context.startTunnelBackground(it.id)
+				}
+			}
 			if (settings.isAutoTunnelEnabled) {
 				Timber.i("Starting watcher service from boot")
 				serviceManager.startWatcherServiceForeground(context)
 			}
-                    if (appDataRepository.appState.isTunnelRunningFromManualStart()) {
-                        appDataRepository.appState.getActiveTunnelId()?.let {
-                            Timber.i("Starting tunnel that was active before reboot")
-                            serviceManager.startVpnServiceForeground(
-                                context,
-                                appDataRepository.tunnels.getById(it)?.id,
-                            )
-                            return@launch
-                        }
-                    }
-                    if (settings.isAlwaysOnVpnEnabled) {
-                        Timber.i("Starting vpn service from boot AOVPN")
-                        serviceManager.startVpnServiceForeground(context)
-                    }
-                }
-            }
 		}
 	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/receiver/KernelReceiver.kt

@@ -0,0 +1,48 @@
+package com.zaneschepke.wireguardautotunnel.receiver
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+import javax.inject.Provider
+
+@AndroidEntryPoint
+class KernelReceiver : BroadcastReceiver() {
+
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
+
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	@Inject
+	lateinit var tunnelConfigRepository: TunnelConfigRepository
+
+	override fun onReceive(context: Context, intent: Intent) {
+		val action = intent.action ?: return
+		applicationScope.launch {
+			if (action == REFRESH_TUNNELS_ACTION) {
+				tunnelService.get().runningTunnelNames().forEach { name ->
+					// TODO can optimize later
+					val tunnel = tunnelConfigRepository.findByTunnelName(name)
+					tunnel?.let {
+						tunnelConfigRepository.save(it.copy(isActive = true))
+					}
+				}
+				context.requestTunnelTileServiceStateUpdate()
+			}
+		}
+	}
+
+	companion object {
+		const val REFRESH_TUNNELS_ACTION = "com.wireguard.android.action.REFRESH_TUNNEL_STATES"
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/receiver/NotificationActionReceiver.kt

@@ -1,44 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.receiver
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class NotificationActionReceiver : BroadcastReceiver() {
-    @Inject
-    lateinit var settingsRepository: SettingsRepository
-
-    @Inject
-    lateinit var serviceManager: ServiceManager
-
-    @Inject
-    @ApplicationScope
-    lateinit var applicationScope: CoroutineScope
-
-    override fun onReceive(context: Context, intent: Intent?) {
-        applicationScope.launch {
-            try {
-                //TODO fix for manual start changes when enabled
-                serviceManager.stopVpnServiceForeground(context)
-                delay(Constants.TOGGLE_TUNNEL_DELAY)
-                serviceManager.startVpnServiceForeground(context)
-            } catch (e: Exception) {
-                Timber.e(e)
-            } finally {
-                cancel()
-            }
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/Action.kt

@@ -4,5 +4,5 @@ enum class Action {
 	START,
 	START_FOREGROUND,
 	STOP,
-    STOP_FOREGROUND
+	STOP_FOREGROUND,
 }

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

@@ -0,0 +1,467 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import android.content.Context
+import android.os.Bundle
+import android.os.PowerManager
+import androidx.core.app.ServiceCompat
+import androidx.lifecycle.lifecycleScope
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
+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.TunnelService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+import java.net.InetAddress
+import javax.inject.Inject
+import javax.inject.Provider
+
+@AndroidEntryPoint
+class AutoTunnelService : ForegroundService() {
+	private val foregroundId = 122
+
+	@Inject
+	lateinit var wifiService: NetworkService<WifiService>
+
+	@Inject
+	lateinit var mobileDataService: NetworkService<MobileDataService>
+
+	@Inject
+	lateinit var ethernetService: NetworkService<EthernetService>
+
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
+
+	@Inject
+	lateinit var notificationService: NotificationService
+
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
+
+	@Inject
+	@IoDispatcher
+	lateinit var ioDispatcher: CoroutineDispatcher
+
+	@Inject
+	@MainImmediateDispatcher
+	lateinit var mainImmediateDispatcher: CoroutineDispatcher
+
+	private val networkEventsFlow = MutableStateFlow(AutoTunnelState())
+
+	private var wakeLock: PowerManager.WakeLock? = null
+	private val tag = this.javaClass.name
+
+	private var running: Boolean = false
+
+	override fun onCreate() {
+		super.onCreate()
+		lifecycleScope.launch(mainImmediateDispatcher) {
+			kotlin.runCatching {
+				launchNotification()
+			}.onFailure {
+				Timber.e(it)
+			}
+		}
+	}
+
+	private suspend fun launchNotification() {
+		if (appDataRepository.settings.getSettings().isAutoTunnelPaused) {
+			launchWatcherPausedNotification()
+		} else {
+			launchWatcherNotification()
+		}
+	}
+
+	override fun startService(extras: Bundle?) {
+		super.startService(extras)
+		if (running) return
+		kotlin.runCatching {
+			lifecycleScope.launch(mainImmediateDispatcher) {
+				launchNotification()
+				initWakeLock()
+			}
+			startWatcherJob()
+		}.onFailure {
+			Timber.e(it)
+		}
+	}
+
+	override fun stopService() {
+		super.stopService()
+		wakeLock?.let {
+			if (it.isHeld) {
+				it.release()
+			}
+		}
+	}
+
+	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),
+				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))
+	}
+
+	private fun initWakeLock() {
+		wakeLock =
+			(getSystemService(Context.POWER_SERVICE) as PowerManager).run {
+				newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
+					try {
+						Timber.i("Initiating wakelock with 10 min timeout")
+						acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
+					} finally {
+						release()
+					}
+				}
+			}
+	}
+
+	private fun startWatcherJob() = lifecycleScope.launch {
+		val setting = appDataRepository.settings.getSettings()
+		launch {
+			Timber.i("Starting wifi watcher")
+			watchForWifiConnectivityChanges()
+		}
+		if (setting.isTunnelOnMobileDataEnabled) {
+			launch {
+				Timber.i("Starting mobile data watcher")
+				watchForMobileDataConnectivityChanges()
+			}
+		}
+		if (setting.isTunnelOnEthernetEnabled) {
+			launch {
+				Timber.i("Starting ethernet data watcher")
+				watchForEthernetConnectivityChanges()
+			}
+		}
+		launch {
+			Timber.i("Starting settings watcher")
+			watchForSettingsChanges()
+		}
+		if (setting.isPingEnabled) {
+			launch {
+				Timber.i("Starting ping watcher")
+				watchForPingFailure()
+			}
+		}
+		launch {
+			Timber.i("Starting management watcher")
+			manageVpn()
+		}
+		running = true
+	}
+
+	private suspend fun watchForMobileDataConnectivityChanges() {
+		withContext(ioDispatcher) {
+			mobileDataService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Mobile data connection")
+						networkEventsFlow.update {
+							it.copy(
+								isMobileDataConnected = true,
+							)
+						}
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						networkEventsFlow.update {
+							it.copy(
+								isMobileDataConnected = true,
+							)
+						}
+						Timber.i("Mobile data capabilities changed")
+					}
+
+					is NetworkStatus.Unavailable -> {
+						networkEventsFlow.update {
+							it.copy(
+								isMobileDataConnected = false,
+							)
+						}
+						Timber.i("Lost mobile data connection")
+					}
+				}
+			}
+		}
+	}
+
+	private suspend fun watchForPingFailure() {
+		withContext(ioDispatcher) {
+			try {
+				do {
+					if (tunnelService.get().vpnState.value.status == TunnelState.UP) {
+						val tunnelConfig = tunnelService.get().vpnState.value.tunnelConfig
+						tunnelConfig?.let {
+							val config = TunnelConfig.configFromWgQuick(it.wgQuick)
+							val results =
+								config.peers.map { peer ->
+									val host =
+										if (peer.endpoint.isPresent &&
+											peer.endpoint.get().resolved.isPresent
+										) {
+											peer.endpoint.get().resolved.get().host
+										} else {
+											Constants.DEFAULT_PING_IP
+										}
+									Timber.i("Checking reachability of: $host")
+									val reachable =
+										InetAddress.getByName(host)
+											.isReachable(Constants.PING_TIMEOUT.toInt())
+									Timber.i("Result: reachable - $reachable")
+									reachable
+								}
+							if (results.contains(false)) {
+								Timber.i("Restarting VPN for ping failure")
+								tunnelService.get().stopTunnel(it)
+								delay(Constants.VPN_RESTART_DELAY)
+								tunnelService.get().startTunnel(it)
+								delay(Constants.PING_COOLDOWN)
+							}
+						}
+					}
+					delay(Constants.PING_INTERVAL)
+				} while (true)
+			} catch (e: Exception) {
+				Timber.e(e)
+			}
+		}
+	}
+
+	private suspend fun watchForSettingsChanges() {
+		appDataRepository.settings.getSettingsFlow().collect { settings ->
+			if (networkEventsFlow.value.settings.isAutoTunnelPaused
+				!= settings.isAutoTunnelPaused
+			) {
+				when (settings.isAutoTunnelPaused) {
+					true -> launchWatcherPausedNotification()
+					false -> launchWatcherNotification()
+				}
+			}
+			networkEventsFlow.update {
+				it.copy(
+					settings = settings,
+				)
+			}
+		}
+	}
+
+	private suspend fun watchForEthernetConnectivityChanges() {
+		withContext(ioDispatcher) {
+			ethernetService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Ethernet connection")
+						networkEventsFlow.update {
+							it.copy(
+								isEthernetConnected = true,
+							)
+						}
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						Timber.i("Ethernet capabilities changed")
+						networkEventsFlow.update {
+							it.copy(
+								isEthernetConnected = true,
+							)
+						}
+					}
+
+					is NetworkStatus.Unavailable -> {
+						networkEventsFlow.update {
+							it.copy(
+								isEthernetConnected = false,
+							)
+						}
+						Timber.i("Lost Ethernet connection")
+					}
+				}
+			}
+		}
+	}
+
+	private suspend fun watchForWifiConnectivityChanges() {
+		withContext(ioDispatcher) {
+			wifiService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Wi-Fi connection")
+						networkEventsFlow.update {
+							it.copy(
+								isWifiConnected = true,
+							)
+						}
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						Timber.i("Wifi capabilities changed")
+						networkEventsFlow.update {
+							it.copy(
+								isWifiConnected = true,
+							)
+						}
+						val ssid = wifiService.getNetworkName(status.networkCapabilities)
+						ssid?.let { name ->
+							if (name.contains(Constants.UNREADABLE_SSID)) {
+								Timber.w("SSID unreadable: missing permissions")
+							} else {
+								Timber.i("Detected valid SSID")
+							}
+							appDataRepository.appState.setCurrentSsid(name)
+							networkEventsFlow.update {
+								it.copy(
+									currentNetworkSSID = name,
+								)
+							}
+						} ?: Timber.w("Failed to read ssid")
+					}
+
+					is NetworkStatus.Unavailable -> {
+						networkEventsFlow.update {
+							it.copy(
+								isWifiConnected = false,
+							)
+						}
+						Timber.i("Lost Wi-Fi connection")
+					}
+				}
+			}
+		}
+	}
+
+	private suspend fun getMobileDataTunnel(): TunnelConfig? {
+		return appDataRepository.tunnels.findByMobileDataTunnel().firstOrNull()
+	}
+
+	private suspend fun getSsidTunnel(ssid: String): TunnelConfig? {
+		return appDataRepository.tunnels.findByTunnelNetworksName(ssid).firstOrNull()
+	}
+
+	private fun isTunnelDown(): Boolean {
+		return tunnelService.get().vpnState.value.status == TunnelState.DOWN
+	}
+
+	private suspend fun manageVpn() {
+		withContext(ioDispatcher) {
+			networkEventsFlow.collectLatest { watcherState ->
+				val autoTunnel = "Auto-tunnel watcher"
+				if (!watcherState.settings.isAutoTunnelPaused) {
+					// delay for rapid network state changes and then collect latest
+					delay(Constants.WATCHER_COLLECTION_DELAY)
+					val activeTunnel = tunnelService.get().vpnState.value.tunnelConfig
+					val defaultTunnel = appDataRepository.getPrimaryOrFirstTunnel()
+					when {
+						watcherState.isEthernetConditionMet() -> {
+							Timber.i("$autoTunnel - tunnel on on ethernet condition met")
+							if (isTunnelDown()) {
+								defaultTunnel?.let {
+									tunnelService.get().startTunnel(it)
+								}
+							}
+						}
+
+						watcherState.isMobileDataConditionMet() -> {
+							Timber.i("$autoTunnel - tunnel on mobile data condition met")
+							val mobileDataTunnel = getMobileDataTunnel()
+							val tunnel =
+								mobileDataTunnel ?: defaultTunnel
+							if (isTunnelDown() || activeTunnel?.isMobileDataTunnel == false) {
+								tunnel?.let {
+									tunnelService.get().startTunnel(it)
+								}
+							}
+						}
+
+						watcherState.isTunnelOffOnMobileDataConditionMet() -> {
+							Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
+							if (!isTunnelDown()) {
+								activeTunnel?.let {
+									tunnelService.get().stopTunnel(it)
+								}
+							}
+						}
+
+						watcherState.isUntrustedWifiConditionMet() -> {
+							if (activeTunnel?.tunnelNetworks?.contains(watcherState.currentNetworkSSID) == false ||
+								activeTunnel == null
+							) {
+								Timber.i(
+									"$autoTunnel - tunnel on ssid not associated with current tunnel condition met",
+								)
+								getSsidTunnel(watcherState.currentNetworkSSID)?.let {
+									Timber.i("Found tunnel associated with this SSID, bringing tunnel up: ${it.name}")
+									if (isTunnelDown() || activeTunnel?.id != it.id) {
+										tunnelService.get().startTunnel(it)
+									}
+								} ?: suspend {
+									Timber.i("No tunnel associated with this SSID, using defaults")
+									val default = appDataRepository.getPrimaryOrFirstTunnel()
+									if (default?.name != tunnelService.get().name || isTunnelDown()) {
+										default?.let {
+											tunnelService.get().startTunnel(it)
+										}
+									}
+								}.invoke()
+							}
+						}
+
+						watcherState.isTrustedWifiConditionMet() -> {
+							Timber.i(
+								"$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off",
+							)
+							if (!isTunnelDown()) activeTunnel?.let { tunnelService.get().stopTunnel(it) }
+						}
+
+						watcherState.isTunnelOffOnWifiConditionMet() -> {
+							Timber.i(
+								"$autoTunnel - tunnel off on wifi condition met, turning vpn off",
+							)
+							if (!isTunnelDown()) activeTunnel?.let { tunnelService.get().stopTunnel(it) }
+						}
+
+						watcherState.isTunnelOffOnNoConnectivityMet() -> {
+							Timber.i(
+								"$autoTunnel - tunnel off on no connectivity met, turning vpn off",
+							)
+							if (!isTunnelDown()) activeTunnel?.let { tunnelService.get().stopTunnel(it) }
+						}
+
+						else -> {
+							Timber.i("$autoTunnel - no condition met")
+						}
+					}
+				}
+			}
+		}
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/AutoTunnelState.kt

@@ -0,0 +1,73 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+
+data class AutoTunnelState(
+	val isWifiConnected: Boolean = false,
+	val isEthernetConnected: Boolean = false,
+	val isMobileDataConnected: Boolean = false,
+	val currentNetworkSSID: String = "",
+	val settings: Settings = Settings(),
+) {
+	fun isEthernetConditionMet(): Boolean {
+		return (
+			isEthernetConnected &&
+				settings.isTunnelOnEthernetEnabled
+			)
+	}
+
+	fun isMobileDataConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				settings.isTunnelOnMobileDataEnabled &&
+				!isWifiConnected &&
+				isMobileDataConnected
+			)
+	}
+
+	fun isTunnelOffOnMobileDataConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				!settings.isTunnelOnMobileDataEnabled &&
+				isMobileDataConnected &&
+				!isWifiConnected
+			)
+	}
+
+	fun isUntrustedWifiConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				isWifiConnected &&
+				!settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
+				settings.isTunnelOnWifiEnabled
+			)
+	}
+
+	fun isTrustedWifiConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				(
+					isWifiConnected &&
+						settings.trustedNetworkSSIDs.contains(currentNetworkSSID)
+					)
+			)
+	}
+
+	fun isTunnelOffOnWifiConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				(
+					isWifiConnected &&
+						!settings.isTunnelOnWifiEnabled
+					)
+			)
+	}
+
+	fun isTunnelOffOnNoConnectivityMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				!isWifiConnected &&
+				!isMobileDataConnected
+			)
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/ForegroundService.kt

@@ -23,7 +23,8 @@ open class ForegroundService : LifecycleService() {
 			val action = intent.action
 			when (action) {
 				Action.START.name,
-                Action.START_FOREGROUND.name -> startService(intent.extras)
+				Action.START_FOREGROUND.name,
+				-> startService(intent.extras)
 
 				Action.STOP.name, Action.STOP_FOREGROUND.name -> stopService()
 				Constants.ALWAYS_ON_VPN_ACTION -> {

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

@@ -3,24 +3,10 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 import android.app.Service
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.withContext
 import timber.log.Timber
 
-class ServiceManager(
-    private val appDataRepository: AppDataRepository,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
-) {
-
-    private fun <T : Service> actionOnService(
-        action: Action,
-        context: Context,
-        cls: Class<T>,
-        extras: Map<String, Int>? = null
-    ) {
+class ServiceManager {
+	private fun <T : Service> actionOnService(action: Action, context: Context, cls: Class<T>, extras: Map<String, Int>? = null) {
 		val intent =
 			Intent(context, cls).also {
 				it.action = action.name
@@ -29,7 +15,8 @@ class ServiceManager(
 		intent.component?.javaClass
 		try {
 			when (action) {
-                Action.START_FOREGROUND, Action.STOP_FOREGROUND -> context.startForegroundService(
+				Action.START_FOREGROUND, Action.STOP_FOREGROUND ->
+					context.startForegroundService(
 						intent,
 					)
 
@@ -40,77 +27,11 @@ class ServiceManager(
 		}
 	}
 
-    suspend fun startVpnService(
-        context: Context,
-        tunnelId: Int? = null,
-        isManualStart: Boolean = false
-    ) {
-        if (isManualStart) onManualStart(tunnelId)
-        actionOnService(
-            Action.START,
-            context,
-            WireGuardTunnelService::class.java,
-            tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
-        )
-    }
-
-    suspend fun stopVpnServiceForeground(context: Context, isManualStop: Boolean = false) {
-        withContext(ioDispatcher) {
-            if (isManualStop) onManualStop()
-            Timber.i("Stopping vpn service")
-            actionOnService(
-                Action.STOP_FOREGROUND,
-                context,
-                WireGuardTunnelService::class.java,
-            )
-        }
-    }
-
-    suspend fun stopVpnService(context: Context, isManualStop: Boolean = false) {
-        withContext(ioDispatcher) {
-            if (isManualStop) onManualStop()
-            Timber.i("Stopping vpn service")
-            actionOnService(
-                Action.STOP,
-                context,
-                WireGuardTunnelService::class.java,
-            )
-        }
-    }
-
-    private suspend fun onManualStop() {
-        appDataRepository.appState.setManualStop()
-    }
-
-    private suspend fun onManualStart(tunnelId: Int?) {
-        tunnelId?.let {
-            appDataRepository.appState.setTunnelRunningFromManualStart(it)
-        }
-    }
-
-    suspend fun startVpnServiceForeground(
-        context: Context,
-        tunnelId: Int? = null,
-        isManualStart: Boolean = false
-    ) {
-        withContext(ioDispatcher) {
-            if (isManualStart) onManualStart(tunnelId)
+	fun startWatcherServiceForeground(context: Context) {
 		actionOnService(
 			Action.START_FOREGROUND,
 			context,
-                WireGuardTunnelService::class.java,
-                tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
-            )
-        }
-    }
-
-    fun startWatcherServiceForeground(
-        context: Context,
-    ) {
-        actionOnService(
-            Action.START_FOREGROUND,
-            context,
-            WireGuardConnectivityWatcherService::class.java,
+			AutoTunnelService::class.java,
 		)
 	}
 
@@ -118,7 +39,7 @@ class ServiceManager(
 		actionOnService(
 			Action.START,
 			context,
-            WireGuardConnectivityWatcherService::class.java,
+			AutoTunnelService::class.java,
 		)
 	}
 
@@ -126,7 +47,23 @@ class ServiceManager(
 		actionOnService(
 			Action.STOP,
 			context,
-            WireGuardConnectivityWatcherService::class.java,
+			AutoTunnelService::class.java,
+		)
+	}
+
+	fun startTunnelBackgroundService(context: Context) {
+		actionOnService(
+			Action.START_FOREGROUND,
+			context,
+			TunnelBackgroundService::class.java,
+		)
+	}
+
+	fun stopTunnelBackgroundService(context: Context) {
+		actionOnService(
+			Action.STOP,
+			context,
+			TunnelBackgroundService::class.java,
 		)
 	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/TunnelBackgroundService.kt

@@ -0,0 +1,41 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import android.app.Notification
+import android.os.Bundle
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class TunnelBackgroundService : ForegroundService() {
+
+	@Inject
+	lateinit var notificationService: NotificationService
+
+	private val foregroundId = 123
+
+	override fun onCreate() {
+		super.onCreate()
+		startForeground(foregroundId, createNotification())
+	}
+
+	override fun startService(extras: Bundle?) {
+		super.startService(extras)
+		startForeground(foregroundId, createNotification())
+	}
+
+	override fun stopService() {
+		super.stopService()
+		stopForeground(STOP_FOREGROUND_REMOVE)
+	}
+
+	private fun createNotification(): Notification {
+		return notificationService.createNotification(
+			getString(R.string.vpn_channel_id),
+			getString(R.string.vpn_channel_name),
+			getString(R.string.tunnel_start_text),
+			description = "",
+		)
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WatcherState.kt

@@ -1,56 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
-
-data class WatcherState(
-    val isWifiConnected: Boolean = false,
-    val isEthernetConnected: Boolean = false,
-    val isMobileDataConnected: Boolean = false,
-    val currentNetworkSSID: String = "",
-    val settings: Settings = Settings()
-) {
-    fun isEthernetConditionMet(): Boolean {
-        return (isEthernetConnected &&
-            settings.isTunnelOnEthernetEnabled)
-    }
-
-    fun isMobileDataConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            settings.isTunnelOnMobileDataEnabled &&
-            !isWifiConnected &&
-            isMobileDataConnected)
-    }
-
-    fun isTunnelOffOnMobileDataConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            !settings.isTunnelOnMobileDataEnabled &&
-            isMobileDataConnected &&
-            !isWifiConnected)
-    }
-
-    fun isUntrustedWifiConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            isWifiConnected &&
-            !settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
-            settings.isTunnelOnWifiEnabled)
-    }
-
-    fun isTrustedWifiConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            (isWifiConnected &&
-                settings.trustedNetworkSSIDs.contains(currentNetworkSSID)))
-    }
-
-    fun isTunnelOffOnWifiConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            (isWifiConnected &&
-                !settings.isTunnelOnWifiEnabled))
-    }
-
-    fun isTunnelOffOnNoConnectivityMet(): Boolean {
-        return (!isEthernetConnected &&
-            !isWifiConnected &&
-            !isMobileDataConnected)
-    }
-}
-

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardConnectivityWatcherService.kt

@@ -1,456 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import android.content.Context
-import android.os.Bundle
-import android.os.PowerManager
-import androidx.core.app.ServiceCompat
-import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
-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.TunnelState
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-import java.net.InetAddress
-import javax.inject.Inject
-
-
-@AndroidEntryPoint
-class WireGuardConnectivityWatcherService : ForegroundService() {
-    private val foregroundId = 122
-
-    @Inject
-    lateinit var wifiService: NetworkService<WifiService>
-
-    @Inject
-    lateinit var mobileDataService: NetworkService<MobileDataService>
-
-    @Inject
-    lateinit var ethernetService: NetworkService<EthernetService>
-
-    @Inject
-    lateinit var appDataRepository: AppDataRepository
-
-    @Inject
-    lateinit var notificationService: NotificationService
-
-    @Inject
-    lateinit var vpnService: VpnService
-
-    @Inject
-    lateinit var serviceManager: ServiceManager
-
-    @Inject
-    @IoDispatcher
-    lateinit var ioDispatcher: CoroutineDispatcher
-
-    @Inject
-    @MainImmediateDispatcher
-    lateinit var mainImmediateDispatcher: CoroutineDispatcher
-
-    private val networkEventsFlow = MutableStateFlow(WatcherState())
-
-    private var watcherJob: Job? = null
-
-    private var wakeLock: PowerManager.WakeLock? = null
-    private val tag = this.javaClass.name
-
-    override fun onCreate() {
-        super.onCreate()
-        lifecycleScope.launch(mainImmediateDispatcher) {
-            try {
-                if (appDataRepository.settings.getSettings().isAutoTunnelPaused) {
-                    launchWatcherPausedNotification()
-                } else launchWatcherNotification()
-            } catch (e: Exception) {
-                Timber.e("Failed to start watcher service, not enough permissions")
-            }
-        }
-    }
-
-    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")
-        }
-    }
-
-    override fun stopService() {
-        super.stopService()
-        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),
-                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))
-    }
-
-    private fun initWakeLock() {
-        wakeLock =
-            (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
-                newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
-                    try {
-                        Timber.i("Initiating wakelock with 10 min timeout")
-                        acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
-                    } finally {
-                        release()
-                    }
-                }
-            }
-    }
-
-    private fun cancelWatcherJob() {
-        try {
-            watcherJob?.cancel()
-        } catch (e: CancellationException) {
-            Timber.i("Watcher job cancelled")
-        }
-    }
-
-    private fun startWatcherJob() {
-        watcherJob =
-            lifecycleScope.launch {
-                val setting = appDataRepository.settings.getSettings()
-                launch {
-                    Timber.i("Starting wifi watcher")
-                    watchForWifiConnectivityChanges()
-                }
-                if (setting.isTunnelOnMobileDataEnabled) {
-                    launch {
-                        Timber.i("Starting mobile data watcher")
-                        watchForMobileDataConnectivityChanges()
-                    }
-                }
-                if (setting.isTunnelOnEthernetEnabled) {
-                    launch {
-                        Timber.i("Starting ethernet data watcher")
-                        watchForEthernetConnectivityChanges()
-                    }
-                }
-                launch {
-                    Timber.i("Starting settings watcher")
-                    watchForSettingsChanges()
-                }
-                if (setting.isPingEnabled) {
-                    launch {
-                        Timber.i("Starting ping watcher")
-                        watchForPingFailure()
-                    }
-                }
-                launch {
-                    Timber.i("Starting management watcher")
-                    manageVpn()
-                }
-
-            }
-    }
-
-    private suspend fun watchForMobileDataConnectivityChanges() {
-        withContext(ioDispatcher) {
-            mobileDataService.networkStatus.collect { status ->
-                when (status) {
-                    is NetworkStatus.Available -> {
-                        Timber.i("Gained Mobile data connection")
-                        networkEventsFlow.update {
-                            it.copy(
-                                isMobileDataConnected = true,
-                            )
-                        }
-                    }
-
-                    is NetworkStatus.CapabilitiesChanged -> {
-                        networkEventsFlow.update {
-                            it.copy(
-                                isMobileDataConnected = true,
-                            )
-                        }
-                        Timber.i("Mobile data capabilities changed")
-                    }
-
-                    is NetworkStatus.Unavailable -> {
-                        networkEventsFlow.update {
-                            it.copy(
-                                isMobileDataConnected = false,
-                            )
-                        }
-                        Timber.i("Lost mobile data connection")
-                    }
-                }
-            }
-        }
-    }
-
-    private suspend fun watchForPingFailure() {
-        val context = this
-        withContext(ioDispatcher) {
-            try {
-                do {
-                    if (vpnService.vpnState.value.status == TunnelState.UP) {
-                        val tunnelConfig = vpnService.vpnState.value.tunnelConfig
-                        tunnelConfig?.let {
-                            val config = TunnelConfig.configFromWgQuick(it.wgQuick)
-                            val results = config.peers.map { peer ->
-                                val host = if (peer.endpoint.isPresent &&
-                                    peer.endpoint.get().resolved.isPresent)
-                                    peer.endpoint.get().resolved.get().host
-                                else Constants.DEFAULT_PING_IP
-                                Timber.i("Checking reachability of: $host")
-                                val reachable = InetAddress.getByName(host)
-                                    .isReachable(Constants.PING_TIMEOUT.toInt())
-                                Timber.i("Result: reachable - $reachable")
-                                reachable
-                            }
-                            if (results.contains(false)) {
-                                Timber.i("Restarting VPN for ping failure")
-                                serviceManager.stopVpnServiceForeground(context)
-                                delay(Constants.VPN_RESTART_DELAY)
-                                serviceManager.startVpnServiceForeground(context, it.id)
-                                delay(Constants.PING_COOLDOWN)
-                            }
-                        }
-                    }
-                    delay(Constants.PING_INTERVAL)
-                } while (true)
-            } catch (e: Exception) {
-                Timber.e(e)
-            }
-        }
-    }
-
-    private suspend fun watchForSettingsChanges() {
-        appDataRepository.settings.getSettingsFlow().collect { settings ->
-            if (networkEventsFlow.value.settings.isAutoTunnelPaused != settings.isAutoTunnelPaused) {
-                when (settings.isAutoTunnelPaused) {
-                    true -> launchWatcherPausedNotification()
-                    false -> launchWatcherNotification()
-                }
-            }
-            networkEventsFlow.update {
-                it.copy(
-                    settings = settings,
-                )
-            }
-        }
-    }
-
-    private suspend fun watchForEthernetConnectivityChanges() {
-        withContext(ioDispatcher) {
-            ethernetService.networkStatus.collect { status ->
-                when (status) {
-                    is NetworkStatus.Available -> {
-                        Timber.i("Gained Ethernet connection")
-                        networkEventsFlow.update {
-                            it.copy(
-                                isEthernetConnected = true,
-                            )
-                        }
-                    }
-
-                    is NetworkStatus.CapabilitiesChanged -> {
-                        Timber.i("Ethernet capabilities changed")
-                        networkEventsFlow.update {
-                            it.copy(
-                                isEthernetConnected = true,
-                            )
-                        }
-                    }
-
-                    is NetworkStatus.Unavailable -> {
-                        networkEventsFlow.update {
-                            it.copy(
-                                isEthernetConnected = false,
-                            )
-                        }
-                        Timber.i("Lost Ethernet connection")
-                    }
-                }
-            }
-        }
-    }
-
-    private suspend fun watchForWifiConnectivityChanges() {
-        withContext(ioDispatcher) {
-            wifiService.networkStatus.collect { status ->
-                when (status) {
-                    is NetworkStatus.Available -> {
-                        Timber.i("Gained Wi-Fi connection")
-                        networkEventsFlow.update {
-                            it.copy(
-                                isWifiConnected = true,
-                            )
-                        }
-                    }
-
-                    is NetworkStatus.CapabilitiesChanged -> {
-                        Timber.i("Wifi capabilities changed")
-                        networkEventsFlow.update {
-                            it.copy(
-                                isWifiConnected = true,
-                            )
-                        }
-                        val ssid = wifiService.getNetworkName(status.networkCapabilities)
-                        ssid?.let { name ->
-                            if (name.contains(Constants.UNREADABLE_SSID)) {
-                                Timber.w("SSID unreadable: missing permissions")
-                            } else Timber.i("Detected valid SSID")
-                            appDataRepository.appState.setCurrentSsid(name)
-                            networkEventsFlow.update {
-                                it.copy(
-                                    currentNetworkSSID = name,
-                                )
-                            }
-                        } ?: Timber.w("Failed to read ssid")
-                    }
-
-                    is NetworkStatus.Unavailable -> {
-                        networkEventsFlow.update {
-                            it.copy(
-                                isWifiConnected = false,
-                            )
-                        }
-                        Timber.i("Lost Wi-Fi connection")
-                    }
-                }
-            }
-        }
-    }
-
-    private suspend fun getMobileDataTunnel(): TunnelConfig? {
-        return appDataRepository.tunnels.findByMobileDataTunnel().firstOrNull()
-    }
-
-    private suspend fun getSsidTunnel(ssid: String): TunnelConfig? {
-        return appDataRepository.tunnels.findByTunnelNetworksName(ssid).firstOrNull()
-    }
-
-    private fun isTunnelDown(): Boolean {
-        return vpnService.vpnState.value.status == TunnelState.DOWN
-    }
-
-    private suspend fun manageVpn() {
-        val context = this
-        withContext(ioDispatcher) {
-            networkEventsFlow.collectLatest { watcherState ->
-                val autoTunnel = "Auto-tunnel watcher"
-                if (!watcherState.settings.isAutoTunnelPaused) {
-                    //delay for rapid network state changes and then collect latest
-                    delay(Constants.WATCHER_COLLECTION_DELAY)
-                    val tunnelConfig = vpnService.vpnState.value.tunnelConfig
-                    when {
-                        watcherState.isEthernetConditionMet() -> {
-                            Timber.i("$autoTunnel - tunnel on on ethernet condition met")
-                            if (isTunnelDown()) serviceManager.startVpnServiceForeground(context)
-                        }
-
-                        watcherState.isMobileDataConditionMet() -> {
-                            Timber.i("$autoTunnel - tunnel on mobile data condition met")
-                            val mobileDataTunnel = getMobileDataTunnel()
-                            val tunnel =
-                                mobileDataTunnel ?: appDataRepository.getPrimaryOrFirstTunnel()
-                            if (isTunnelDown() || tunnelConfig?.isMobileDataTunnel == false) {
-                                serviceManager.startVpnServiceForeground(
-                                    context,
-                                    tunnel?.id,
-                                )
-                            }
-                        }
-
-                        watcherState.isTunnelOffOnMobileDataConditionMet() -> {
-                            Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
-                            if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
-                        }
-
-                        watcherState.isUntrustedWifiConditionMet() -> {
-                            if (tunnelConfig?.tunnelNetworks?.contains(watcherState.currentNetworkSSID) == false ||
-                                tunnelConfig == null) {
-                                Timber.i("$autoTunnel - tunnel on ssid not associated with current tunnel condition met")
-                                getSsidTunnel(watcherState.currentNetworkSSID)?.let {
-                                    Timber.i("Found tunnel associated with this SSID, bringing tunnel up: ${it.name}")
-                                    if (isTunnelDown() || tunnelConfig?.id != it.id) serviceManager.startVpnServiceForeground(
-                                        context,
-                                        it.id,
-                                    )
-                                } ?: suspend {
-                                    Timber.i("No tunnel associated with this SSID, using defaults")
-                                    val default = appDataRepository.getPrimaryOrFirstTunnel()
-                                    if (default?.name != vpnService.name) {
-                                        default?.let {
-                                            serviceManager.startVpnServiceForeground(context, it.id)
-                                        }
-
-                                    }
-                                }.invoke()
-                            }
-                        }
-
-                        watcherState.isTrustedWifiConditionMet() -> {
-                            Timber.i("$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off")
-                            if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
-                        }
-
-                        watcherState.isTunnelOffOnWifiConditionMet() -> {
-                            Timber.i("$autoTunnel - tunnel off on wifi condition met, turning vpn off")
-                            if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
-                        }
-
-                        watcherState.isTunnelOffOnNoConnectivityMet() -> {
-                            Timber.i("$autoTunnel - tunnel off on no connectivity met, turning vpn off")
-                            if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
-                        }
-
-                        else -> {
-                            Timber.i("$autoTunnel - no condition met")
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/WireGuardTunnelService.kt

@@ -1,201 +0,0 @@
-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.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
-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.TunnelState
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
-import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class WireGuardTunnelService : ForegroundService() {
-    private val foregroundId = 123
-
-    @Inject
-    lateinit var vpnService: VpnService
-
-    @Inject
-    lateinit var appDataRepository: AppDataRepository
-
-    @Inject
-    lateinit var notificationService: NotificationService
-
-    @Inject
-    @MainImmediateDispatcher
-    lateinit var mainImmediateDispatcher: CoroutineDispatcher
-
-    @Inject
-    @IoDispatcher
-    lateinit var ioDispatcher: CoroutineDispatcher
-
-    private var job: Job? = null
-
-    private var didShowConnected = false
-
-    override fun onCreate() {
-        super.onCreate()
-        lifecycleScope.launch(mainImmediateDispatcher) {
-            //TODO fix this to not launch if AOVPN
-            if (appDataRepository.tunnels.count() != 0) {
-                launchVpnNotification()
-            }
-        }
-    }
-
-    override fun startService(extras: Bundle?) {
-        super.startService(extras)
-        cancelJob()
-        job =
-            lifecycleScope.launch {
-                launch {
-                    val tunnelId = extras?.getInt(Constants.TUNNEL_EXTRA_KEY)
-                    if (vpnService.getState() == TunnelState.UP) {
-                        vpnService.stopTunnel()
-                    }
-                    vpnService.startTunnel(
-                        tunnelId?.let {
-                            appDataRepository.tunnels.getById(it)
-                        },
-                    )
-                }
-                launch {
-                    handshakeNotifications()
-                }
-            }
-    }
-
-    //TODO improve tunnel notifications
-    private suspend fun handshakeNotifications() {
-        withContext(ioDispatcher) {
-            var tunnelName: String? = null
-            vpnService.vpnState.collect { state ->
-                state.statistics
-                    ?.mapPeerStats()
-                    ?.map { it.value?.handshakeStatus() }
-                    .let { statuses ->
-                        when {
-                            statuses?.all { it == HandshakeStatus.HEALTHY } == true -> {
-                                if (!didShowConnected) {
-                                    delay(Constants.VPN_CONNECTED_NOTIFICATION_DELAY)
-                                    tunnelName = state.tunnelConfig?.name
-                                    launchVpnNotification(
-                                        getString(R.string.tunnel_start_title),
-                                        "${getString(R.string.tunnel_start_text)} - $tunnelName",
-                                    )
-                                    didShowConnected = true
-                                }
-                            }
-
-                            statuses?.any { it == HandshakeStatus.STALE } == true -> {}
-                            statuses?.all { it == HandshakeStatus.NOT_STARTED } ==
-                                true -> {
-                            }
-
-                            else -> {}
-                        }
-                    }
-                if (state.status == TunnelState.UP && state.tunnelConfig?.name != tunnelName) {
-                    tunnelName = state.tunnelConfig?.name
-                    launchVpnNotification(
-                        getString(R.string.tunnel_start_title),
-                        "${getString(R.string.tunnel_start_text)} - $tunnelName",
-                    )
-                }
-            }
-        }
-    }
-
-    private fun launchAlwaysOnDisabledNotification() {
-        launchVpnNotification(
-            title = this.getString(R.string.vpn_connection_failed),
-            description = this.getString(R.string.always_on_disabled),
-        )
-    }
-
-    override fun stopService() {
-        super.stopService()
-        lifecycleScope.launch {
-            vpnService.stopTunnel()
-            didShowConnected = false
-        }
-        cancelJob()
-        stopSelf()
-    }
-
-    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,
-        )
-    }
-
-    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,
-        )
-    }
-
-    private fun cancelJob() {
-        try {
-            job?.cancel()
-        } catch (e: CancellationException) {
-            Timber.i("Tunnel job cancelled")
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/BaseNetworkService.kt

@@ -16,7 +16,7 @@ import kotlinx.coroutines.flow.map
 
 abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 	val context: Context,
-    networkCapability: Int
+	networkCapability: Int,
 ) : NetworkService<T> {
 	private val connectivityManager =
 		context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
@@ -24,7 +24,8 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 	private val wifiManager =
 		context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
 
-    override val networkStatus = callbackFlow {
+	override val networkStatus =
+		callbackFlow {
 			val networkStatusCallback =
 				when (Build.VERSION.SDK_INT) {
 					in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
@@ -40,10 +41,7 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 								trySend(NetworkStatus.Unavailable(network))
 							}
 
-                        override fun onCapabilitiesChanged(
-                            network: Network,
-                            networkCapabilities: NetworkCapabilities
-                        ) {
+							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
 								trySend(
 									NetworkStatus.CapabilitiesChanged(
 										network,
@@ -64,10 +62,7 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 								trySend(NetworkStatus.Unavailable(network))
 							}
 
-                        override fun onCapabilitiesChanged(
-                            network: Network,
-                            networkCapabilities: NetworkCapabilities
-                        ) {
+							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
 								trySend(
 									NetworkStatus.CapabilitiesChanged(
 										network,
@@ -118,7 +113,7 @@ inline fun <Result> Flow<NetworkStatus>.map(
 	crossinline onUnavailable: suspend (network: Network) -> Result,
 	crossinline onAvailable: suspend (network: Network) -> Result,
 	crossinline onCapabilitiesChanged:
-    suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result
+	suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result,
 ): Flow<Result> = map { status ->
 	when (status) {
 		is NetworkStatus.Unavailable -> onUnavailable(status.network)

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/EthernetService.kt

@@ -5,5 +5,9 @@ import android.net.NetworkCapabilities
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class EthernetService @Inject constructor(@ApplicationContext context: Context) :
+class EthernetService
+@Inject
+constructor(
+	@ApplicationContext context: Context,
+) :
 	BaseNetworkService<EthernetService>(context, NetworkCapabilities.TRANSPORT_ETHERNET)

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/MobileDataService.kt

@@ -5,5 +5,9 @@ import android.net.NetworkCapabilities
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class MobileDataService @Inject constructor(@ApplicationContext context: Context) :
+class MobileDataService
+@Inject
+constructor(
+	@ApplicationContext context: Context,
+) :
 	BaseNetworkService<MobileDataService>(context, NetworkCapabilities.TRANSPORT_CELLULAR)

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/network/WifiService.kt

@@ -5,5 +5,9 @@ import android.net.NetworkCapabilities
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WifiService @Inject constructor(@ApplicationContext context: Context) :
+class WifiService
+@Inject
+constructor(
+	@ApplicationContext context: Context,
+) :
 	BaseNetworkService<WifiService>(context, NetworkCapabilities.TRANSPORT_WIFI)

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/notification/WireGuardNotification.kt

@@ -9,11 +9,15 @@ 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 com.zaneschepke.wireguardautotunnel.ui.SplashActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WireGuardNotification @Inject constructor(@ApplicationContext private val context: Context) :
+class WireGuardNotification
+@Inject
+constructor(
+	@ApplicationContext private val context: Context,
+) :
 	NotificationService {
 	private val notificationManager =
 		context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -59,7 +63,7 @@ class WireGuardNotification @Inject constructor(@ApplicationContext private val
 				}
 		notificationManager.createNotificationChannel(channel)
 		val pendingIntent: PendingIntent =
-            Intent(context, MainActivity::class.java).let { notificationIntent ->
+			Intent(context, SplashActivity::class.java).let { notificationIntent ->
 				PendingIntent.getActivity(
 					context,
 					0,

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

@@ -5,22 +5,24 @@ import androidx.activity.ComponentActivity
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.Action
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardConnectivityWatcherService
-import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
+import com.zaneschepke.wireguardautotunnel.service.foreground.AutoTunnelService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.startTunnelBackground
+import com.zaneschepke.wireguardautotunnel.util.extensions.stopTunnelBackground
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 @AndroidEntryPoint
 class ShortcutsActivity : ComponentActivity() {
-
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
 	@Inject
-    lateinit var serviceManager: ServiceManager
+	lateinit var tunnelService: Provider<TunnelService>
 
 	@Inject
 	@ApplicationScope
@@ -32,34 +34,32 @@ class ShortcutsActivity : ComponentActivity() {
 			val settings = appDataRepository.settings.getSettings()
 			if (settings.isShortcutsEnabled) {
 				when (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)) {
-                    WireGuardTunnelService::class.java.simpleName -> {
+					LEGACY_TUNNEL_SERVICE_NAME, TunnelService::class.java.simpleName -> {
 						val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
+						Timber.d("Tunnel name extra: $tunnelName")
 						val tunnelConfig = tunnelName?.let {
-                            appDataRepository.tunnels.getAll().firstOrNull {
-                                it.name == tunnelName
-                            }
-                        }
+							appDataRepository.tunnels.getAll()
+								.firstOrNull { it.name == tunnelName }
+						} ?: appDataRepository.getStartTunnelConfig()
+						Timber.d("Shortcut action on name: ${tunnelConfig?.name}")
+						tunnelConfig?.let {
 							when (intent.action) {
-                            Action.START.name -> serviceManager.startVpnServiceForeground(
-                                this@ShortcutsActivity, tunnelConfig?.id, isManualStart = true,
-                            )
-
-                            Action.STOP.name -> serviceManager.stopVpnServiceForeground(
-                                this@ShortcutsActivity,
-                                isManualStop = true,
-                            )
+								Action.START.name -> this@ShortcutsActivity.startTunnelBackground(it.id)
+								Action.STOP.name -> this@ShortcutsActivity.stopTunnelBackground(it.id)
+								else -> Unit
 							}
 						}
-
-                    WireGuardConnectivityWatcherService::class.java.simpleName -> {
+					}
+					AutoTunnelService::class.java.simpleName, LEGACY_AUTO_TUNNEL_SERVICE_NAME -> {
 						when (intent.action) {
-                            Action.START.name -> appDataRepository.settings.save(
+							Action.START.name ->
+								appDataRepository.settings.save(
 									settings.copy(
 										isAutoTunnelPaused = false,
 									),
 								)
-
-                            Action.STOP.name -> appDataRepository.settings.save(
+							Action.STOP.name ->
+								appDataRepository.settings.save(
 									settings.copy(
 										isAutoTunnelPaused = true,
 									),
@@ -73,6 +73,8 @@ class ShortcutsActivity : ComponentActivity() {
 	}
 
 	companion object {
+		const val LEGACY_TUNNEL_SERVICE_NAME = "WireGuardTunnelService"
+		const val LEGACY_AUTO_TUNNEL_SERVICE_NAME = "WireGuardConnectivityWatcherService"
 		const val TUNNEL_NAME_EXTRA_KEY = "tunnelName"
 		const val CLASS_NAME_EXTRA_KEY = "className"
 	}

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

@@ -1,23 +1,26 @@
 package com.zaneschepke.wireguardautotunnel.service.tile
 
+import android.content.Intent
 import android.os.Build
+import android.os.IBinder
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
-class AutoTunnelControlTile : TileService() {
-
+class AutoTunnelControlTile : TileService(), LifecycleOwner {
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
@@ -28,15 +31,29 @@ class AutoTunnelControlTile : TileService() {
 	@ApplicationScope
 	lateinit var applicationScope: CoroutineScope
 
-    private var manualStartConfig: TunnelConfig? = null
+	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
+
+	/* This works around an annoying unsolved frameworks bug some people are hitting. */
+	override fun onBind(intent: Intent): IBinder? {
+		var ret: IBinder? = null
+		try {
+			ret = super.onBind(intent)
+		} catch (e: Throwable) {
+			Timber.e("Failed to bind to AutoTunnelTile")
+		}
+		return ret
+	}
+
+	override fun onCreate() {
+		super.onCreate()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
 
-    override fun onStartListening() {
-        super.onStartListening()
 		applicationScope.launch {
-            val settings = appDataRepository.settings.getSettings()
-            when (settings.isAutoTunnelEnabled) {
+			appDataRepository.settings.getSettingsFlow().collect {
+				kotlin.runCatching {
+					when (it.isAutoTunnelEnabled) {
 						true -> {
-                    if (settings.isAutoTunnelPaused) {
+							if (it.isAutoTunnelPaused) {
 								setInactive()
 								setTileDescription(this@AutoTunnelControlTile.getString(R.string.paused))
 							} else {
@@ -50,46 +67,73 @@ class AutoTunnelControlTile : TileService() {
 							setUnavailable()
 						}
 					}
+				}.onFailure {
+					Timber.e(it)
+				}
+			}
 		}
 	}
 
-    override fun onTileAdded() {
-        super.onTileAdded()
-        onStartListening()
+	override fun onStopListening() {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
+	}
+
+	override fun onDestroy() {
+		super.onDestroy()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+	}
+
+	override fun onStartListening() {
+		super.onStartListening()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
 	}
 
 	override fun onClick() {
 		super.onClick()
 		unlockAndRun {
-            applicationScope.launch {
-                try {
-                    appDataRepository.toggleWatcherServicePause()
-                } catch (e: Exception) {
-                    Timber.e(e.message)
-                } finally {
-                    cancel()
+			lifecycleScope.launch {
+				kotlin.runCatching {
+					val settings = appDataRepository.settings.getSettings()
+					if (settings.isAutoTunnelPaused) {
+						return@launch appDataRepository.settings.save(
+							settings.copy(
+								isAutoTunnelPaused = false,
+							),
+						)
+					}
+					appDataRepository.settings.save(
+						settings.copy(
+							isAutoTunnelPaused = true,
+						),
+					)
 				}
 			}
 		}
 	}
 
 	private fun setActive() {
+		kotlin.runCatching {
 			qsTile.state = Tile.STATE_ACTIVE
 			qsTile.updateTile()
 		}
+	}
 
 	private fun setInactive() {
+		kotlin.runCatching {
 			qsTile.state = Tile.STATE_INACTIVE
 			qsTile.updateTile()
 		}
+	}
 
 	private fun setUnavailable() {
-        manualStartConfig = null
+		kotlin.runCatching {
 			qsTile.state = Tile.STATE_UNAVAILABLE
 			qsTile.updateTile()
 		}
+	}
 
 	private fun setTileDescription(description: String) {
+		kotlin.runCatching {
 			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
 				qsTile.subtitle = description
 			}
@@ -98,4 +142,8 @@ class AutoTunnelControlTile : TileService() {
 			}
 			qsTile.updateTile()
 		}
+	}
+
+	override val lifecycle: Lifecycle
+		get() = lifecycleRegistry
 }

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

@@ -3,108 +3,107 @@ package com.zaneschepke.wireguardautotunnel.service.tile
 import android.os.Build
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.startTunnelBackground
+import com.zaneschepke.wireguardautotunnel.util.extensions.stopTunnelBackground
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 @AndroidEntryPoint
-class TunnelControlTile : TileService() {
-
+class TunnelControlTile : TileService(), LifecycleOwner {
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
 	@Inject
-    lateinit var vpnService: VpnService
-
-    @Inject
-    lateinit var serviceManager: ServiceManager
+	lateinit var tunnelService: Provider<TunnelService>
 
 	@Inject
 	@ApplicationScope
 	lateinit var applicationScope: CoroutineScope
 
-    private var manualStartConfig: TunnelConfig? = null
+	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
+
+	override fun onCreate() {
+		super.onCreate()
+		Timber.d("onCreate for tile service")
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+	}
+
+	override fun onStopListening() {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
+	}
+
+	override fun onDestroy() {
+		super.onDestroy()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+	}
 
 	override fun onStartListening() {
 		super.onStartListening()
-        Timber.d("On start listening called")
-        applicationScope.launch {
-            when (vpnService.getState()) {
-                TunnelState.UP -> {
-                    setActive()
-                    setTileDescription(vpnService.name)
-                }
-
-                TunnelState.DOWN -> {
-                    setInactive()
-                    val config = appDataRepository.getStartTunnelConfig()?.also { config ->
-                        manualStartConfig = config
-                    } ?: appDataRepository.getPrimaryOrFirstTunnel()
-                    config?.let {
-                        setTileDescription(it.name)
-                    } ?: setUnavailable()
-                }
-
-                else -> setInactive()
-            }
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
+		lifecycleScope.launch {
+			if (appDataRepository.tunnels.getAll().isEmpty()) return@launch setUnavailable()
+			updateTileState()
 		}
 	}
 
-    override fun onTileAdded() {
-        super.onTileAdded()
-        onStartListening()
+	private suspend fun updateTileState() {
+		val lastActive = appDataRepository.getStartTunnelConfig()
+		lastActive?.let {
+			updateTile(it)
+		}
 	}
 
 	override fun onClick() {
 		super.onClick()
 		unlockAndRun {
-            applicationScope.launch {
-                try {
-                    if (vpnService.getState() == TunnelState.UP) {
-                        serviceManager.stopVpnServiceForeground(
-                            this@TunnelControlTile,
-                            isManualStop = true,
-                        )
-                    } else {
-                        serviceManager.startVpnServiceForeground(
-                            this@TunnelControlTile, manualStartConfig?.id, isManualStart = true,
-                        )
-                    }
-                } catch (e: Exception) {
-                    Timber.e(e.message)
-                } finally {
-                    cancel()
+			Timber.d("Click")
+			lifecycleScope.launch {
+				val context = this@TunnelControlTile
+				val lastActive = appDataRepository.getStartTunnelConfig()
+				lastActive?.let { tunnel ->
+					if (tunnel.isActive) return@launch context.stopTunnelBackground(tunnel.id)
+					context.startTunnelBackground(tunnel.id)
 				}
 			}
 		}
 	}
 
 	private fun setActive() {
+		kotlin.runCatching {
 			qsTile.state = Tile.STATE_ACTIVE
 			qsTile.updateTile()
 		}
+	}
 
 	private fun setInactive() {
+		kotlin.runCatching {
 			qsTile.state = Tile.STATE_INACTIVE
 			qsTile.updateTile()
 		}
+	}
 
 	private fun setUnavailable() {
-        manualStartConfig = null
+		kotlin.runCatching {
 			qsTile.state = Tile.STATE_UNAVAILABLE
+			setTileDescription("")
 			qsTile.updateTile()
 		}
+	}
 
 	private fun setTileDescription(description: String) {
+		kotlin.runCatching {
 			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
 				qsTile.subtitle = description
 			}
@@ -113,4 +112,18 @@ class TunnelControlTile : TileService() {
 			}
 			qsTile.updateTile()
 		}
+	}
+
+	private fun updateTile(tunnelConfig: TunnelConfig?) {
+		kotlin.runCatching {
+			tunnelConfig?.let {
+				setTileDescription(it.name)
+				if (it.isActive) return setActive()
+				setInactive()
+			}
+		}
+	}
+
+	override val lifecycle: Lifecycle
+		get() = lifecycleRegistry
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/AlwaysOnVpnService.kt

@@ -0,0 +1,46 @@
+package com.zaneschepke.wireguardautotunnel.service.tunnel
+
+import android.content.Intent
+import android.os.IBinder
+import androidx.lifecycle.LifecycleService
+import androidx.lifecycle.lifecycleScope
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+import javax.inject.Provider
+
+@AndroidEntryPoint
+class AlwaysOnVpnService : LifecycleService() {
+
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
+
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
+
+	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 {
+		if (intent == null || intent.component == null || intent.component!!.packageName != packageName) {
+			Timber.i("Always-on VPN requested started")
+			lifecycleScope.launch {
+				val settings = appDataRepository.settings.getSettings()
+				if (settings.isAlwaysOnVpnEnabled) {
+					val tunnel = appDataRepository.getPrimaryOrFirstTunnel()
+					tunnel?.let {
+						tunnelService.get().startTunnel(it)
+					}
+				} else {
+					Timber.w("Always-on VPN is not enabled in app settings")
+				}
+			}
+		}
+		return super.onStartCommand(intent, flags, startId)
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/HandshakeStatus.kt

@@ -4,7 +4,8 @@ enum class HandshakeStatus {
 	HEALTHY,
 	STALE,
 	UNKNOWN,
-    NOT_STARTED;
+	NOT_STARTED,
+	;
 
 	companion object {
 		private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 180

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

@@ -0,0 +1,20 @@
+package com.zaneschepke.wireguardautotunnel.service.tunnel
+
+import com.wireguard.android.backend.Tunnel
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import kotlinx.coroutines.flow.StateFlow
+
+interface TunnelService : Tunnel, org.amnezia.awg.backend.Tunnel {
+	suspend fun startTunnel(tunnelConfig: TunnelConfig): Result<TunnelState>
+
+	suspend fun stopTunnel(tunnelConfig: TunnelConfig): Result<TunnelState>
+
+	val vpnState: StateFlow<VpnState>
+
+	suspend fun runningTunnelNames(): Set<String>
+
+	suspend fun getState(): TunnelState
+
+	fun cancelStatsJob()
+	fun startStatsJob()
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/TunnelState.kt

@@ -5,7 +5,8 @@ import com.wireguard.android.backend.Tunnel
 enum class TunnelState {
 	UP,
 	DOWN,
-    TOGGLE;
+	TOGGLE,
+	;
 
 	fun toWgState(): Tunnel.State {
 		return when (this) {

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/VpnService.kt

@@ -1,15 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.tunnel
-
-import com.wireguard.android.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import kotlinx.coroutines.flow.StateFlow
-
-interface VpnService : Tunnel, org.amnezia.awg.backend.Tunnel {
-    suspend fun startTunnel(tunnelConfig: TunnelConfig? = null): TunnelState
-
-    suspend fun stopTunnel()
-
-    val vpnState: StateFlow<VpnState>
-
-    fun getState(): TunnelState
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/VpnState.kt

@@ -6,5 +6,5 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStati
 data class VpnState(
 	val status: TunnelState = TunnelState.DOWN,
 	val tunnelConfig: TunnelConfig? = null,
-    val statistics: TunnelStatistics? = null
+	val statistics: TunnelStatistics? = null,
 )

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/tunnel/WireGuardTunnel.kt

@@ -1,7 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel
 
 import com.wireguard.android.backend.Backend
-import com.wireguard.android.backend.BackendException
 import com.wireguard.android.backend.Tunnel.State
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
@@ -14,7 +13,7 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.AmneziaStat
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.WireGuardStatistics
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import kotlinx.coroutines.CancellationException
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
@@ -32,96 +31,83 @@ import javax.inject.Provider
 class WireGuardTunnel
 @Inject
 constructor(
-    private val userspaceAmneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
+	private val amneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
 	@Userspace private val userspaceBackend: Provider<Backend>,
 	@Kernel private val kernelBackend: Provider<Backend>,
 	private val appDataRepository: AppDataRepository,
 	@ApplicationScope private val applicationScope: CoroutineScope,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
-) : VpnService {
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+) : TunnelService {
 	private val _vpnState = MutableStateFlow(VpnState())
 	override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()
 
+	override suspend fun runningTunnelNames(): Set<String> {
+		return when (val backend = backend()) {
+			is Backend -> backend.runningTunnelNames
+			is org.amnezia.awg.backend.Backend -> backend.runningTunnelNames
+			else -> emptySet()
+		}
+	}
 
 	private var statsJob: Job? = null
 
-    private var backendIsWgUserspace = true
-
-    private var backendIsAmneziaUserspace = false
-
-    init {
-        applicationScope.launch(ioDispatcher) {
-            appDataRepository.settings.getSettingsFlow().collect {
-                if (it.isKernelEnabled && (backendIsWgUserspace || backendIsAmneziaUserspace)) {
-                    Timber.i("Setting kernel backend")
-                    backendIsWgUserspace = false
-                    backendIsAmneziaUserspace = false
-                } else if (!it.isKernelEnabled && !it.isAmneziaEnabled && !backendIsWgUserspace) {
-                    Timber.i("Setting WireGuard userspace backend")
-                    backendIsWgUserspace = true
-                    backendIsAmneziaUserspace = false
-                } else if (it.isAmneziaEnabled && !backendIsAmneziaUserspace) {
-                    Timber.i("Setting Amnezia userspace backend")
-                    backendIsAmneziaUserspace = true
-                    backendIsWgUserspace = false
-                }
-            }
-        }
-    }
-
-    private fun setState(tunnelConfig: TunnelConfig?, tunnelState: TunnelState): TunnelState {
-        return if (backendIsAmneziaUserspace) {
-            Timber.i("Using Amnezia backend")
-            val config = tunnelConfig?.let {
-                if (it.amQuick != "") TunnelConfig.configFromAmQuick(it.amQuick) else {
-                    Timber.w("Using backwards compatible wg config, amnezia specific config not found.")
-                    TunnelConfig.configFromAmQuick(it.wgQuick)
-                }
-            }
-            val state =
-                userspaceAmneziaBackend.get().setState(this, tunnelState.toAmState(), config)
-            TunnelState.from(state)
-        } else {
-            Timber.i("Using Wg backend")
-            val wgConfig = tunnelConfig?.let { TunnelConfig.configFromWgQuick(it.wgQuick) }
-            val state = backend().setState(
-                this,
-                tunnelState.toWgState(),
-                wgConfig,
+	private suspend fun setState(tunnelConfig: TunnelConfig, tunnelState: TunnelState): Result<TunnelState> {
+		return runCatching {
+			when (val backend = backend()) {
+				is Backend -> backend.setState(this, tunnelState.toWgState(), TunnelConfig.configFromWgQuick(tunnelConfig.wgQuick)).let { TunnelState.from(it) }
+				is org.amnezia.awg.backend.Backend -> {
+					val config = if (tunnelConfig.amQuick.isBlank()) {
+						TunnelConfig.configFromAmQuick(
+							tunnelConfig.wgQuick,
 						)
-            TunnelState.from(state)
+					} else {
+						TunnelConfig.configFromAmQuick(tunnelConfig.amQuick)
+					}
+					backend.setState(this, tunnelState.toAmState(), config).let {
+						TunnelState.from(it)
+					}
+				}
+				else -> throw NotImplementedError()
+			}
+		}.onFailure {
+			Timber.e(it)
 		}
 	}
 
-    override suspend fun startTunnel(tunnelConfig: TunnelConfig?): TunnelState {
+	private suspend fun backend(): Any {
+		val settings = appDataRepository.settings.getSettings()
+		if (settings.isKernelEnabled) return kernelBackend.get()
+		if (settings.isAmneziaEnabled) return amneziaBackend.get()
+		return userspaceBackend.get()
+	}
+
+	override suspend fun startTunnel(tunnelConfig: TunnelConfig): Result<TunnelState> {
 		return withContext(ioDispatcher) {
-            try {
-                //TODO we need better error handling here
-                // need to bubble up these errors to the UI
-                val config = tunnelConfig ?: appDataRepository.getPrimaryOrFirstTunnel()
-                if (config != null) {
-                    emitTunnelConfig(config)
-                    setState(config, TunnelState.UP)
-                } else throw Exception("No tunnels")
-            } catch (e: BackendException) {
-                Timber.e("Failed to start tunnel with error: ${e.message}")
-                TunnelState.from(State.DOWN)
+			if (_vpnState.value.status == TunnelState.UP) vpnState.value.tunnelConfig?.let { stopTunnel(it) }
+			appDataRepository.tunnels.save(tunnelConfig.copy(isActive = true))
+			appDataRepository.appState.setLastActiveTunnelId(tunnelConfig.id)
+			emitTunnelConfig(tunnelConfig)
+			setState(tunnelConfig, TunnelState.UP).onSuccess {
+				emitTunnelState(it)
+				WireGuardAutoTunnel.instance.requestTunnelTileServiceStateUpdate()
+			}.onFailure {
+				appDataRepository.tunnels.save(tunnelConfig.copy(isActive = false))
+				WireGuardAutoTunnel.instance.requestTunnelTileServiceStateUpdate()
 			}
 		}
 	}
 
-    private fun backend(): Backend {
-        return when {
-            backendIsWgUserspace -> {
-                userspaceBackend.get()
-            }
-
-            !backendIsWgUserspace && !backendIsAmneziaUserspace -> {
-                kernelBackend.get()
-            }
-
-            else -> {
-                userspaceBackend.get()
+	override suspend fun stopTunnel(tunnelConfig: TunnelConfig): Result<TunnelState> {
+		return withContext(ioDispatcher) {
+			appDataRepository.tunnels.save(tunnelConfig.copy(isActive = false))
+			setState(tunnelConfig, TunnelState.DOWN).onSuccess {
+				emitTunnelState(it)
+				resetBackendStatistics()
+				WireGuardAutoTunnel.instance.requestTunnelTileServiceStateUpdate()
+			}.onFailure {
+				Timber.e(it)
+				appDataRepository.tunnels.save(tunnelConfig.copy(isActive = true))
+				WireGuardAutoTunnel.instance.requestTunnelTileServiceStateUpdate()
 			}
 		}
 	}
@@ -142,75 +128,69 @@ constructor(
 		)
 	}
 
-    private suspend fun emitTunnelConfig(tunnelConfig: TunnelConfig?) {
-        _vpnState.emit(
+	private fun emitTunnelConfig(tunnelConfig: TunnelConfig?) {
+		_vpnState.tryEmit(
 			_vpnState.value.copy(
 				tunnelConfig = tunnelConfig,
 			),
 		)
 	}
 
-    private fun resetVpnState() {
-        _vpnState.tryEmit(VpnState())
-    }
-
-    override suspend fun stopTunnel() {
-        withContext(ioDispatcher) {
-            try {
-                if (getState() == TunnelState.UP) {
-                    val state = setState(null, TunnelState.DOWN)
-                    resetVpnState()
-                    emitTunnelState(state)
-                }
-            } catch (e: BackendException) {
-                Timber.e("Failed to stop wireguard tunnel with error: ${e.message}")
-            } catch (e: org.amnezia.awg.backend.BackendException) {
-                Timber.e("Failed to stop amnezia tunnel with error: ${e.message}")
-            }
-        }
-    }
-
-    override fun getState(): TunnelState {
-        return if (backendIsAmneziaUserspace) TunnelState.from(
-            userspaceAmneziaBackend.get().getState(this),
+	private fun resetBackendStatistics() {
+		_vpnState.tryEmit(
+			_vpnState.value.copy(
+				statistics = null,
+			),
 		)
-        else TunnelState.from(backend().getState(this))
+	}
+
+	override suspend fun getState(): TunnelState {
+		return when (val backend = backend()) {
+			is Backend -> backend.getState(this).let { TunnelState.from(it) }
+			is org.amnezia.awg.backend.Backend -> backend.getState(this).let { TunnelState.from(it) }
+			else -> TunnelState.DOWN
+		}
+	}
+
+	override fun cancelStatsJob() {
+		statsJob?.cancel()
+	}
+
+	override fun startStatsJob() {
+		statsJob = startTunnelStatisticsJob()
 	}
 
 	override fun getName(): String {
 		return _vpnState.value.tunnelConfig?.name ?: ""
 	}
 
-
 	override fun onStateChange(newState: Tunnel.State) {
 		handleStateChange(TunnelState.from(newState))
 	}
 
 	private fun handleStateChange(state: TunnelState) {
 		emitTunnelState(state)
-        WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
-        if (state == TunnelState.UP) {
-            statsJob = startTunnelStatisticsJob()
-        }
-        if (state == TunnelState.DOWN) {
-            try {
-                statsJob?.cancel()
-            } catch (e: CancellationException) {
-                Timber.i("Stats job cancelled")
-            }
+		WireGuardAutoTunnel.instance.requestTunnelTileServiceStateUpdate()
+		when (state) {
+			TunnelState.UP -> startStatsJob()
+			else -> cancelStatsJob()
 		}
 	}
 
 	private fun startTunnelStatisticsJob() = applicationScope.launch(ioDispatcher) {
+		val backend = backend()
 		while (true) {
-            if (backendIsAmneziaUserspace) {
+			when (backend) {
+				is Backend -> emitBackendStatistics(
+					WireGuardStatistics(backend.getStatistics(this@WireGuardTunnel)),
+				)
+				is org.amnezia.awg.backend.Backend -> {
 					emitBackendStatistics(
 						AmneziaStatistics(
-                        userspaceAmneziaBackend.get().getStatistics(this@WireGuardTunnel),
+							backend.getStatistics(this@WireGuardTunnel),
 						),
 					)
-            } else {
-                emitBackendStatistics(WireGuardStatistics(backend().getStatistics(this@WireGuardTunnel)))
+				}
 			}
 			delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
 		}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/AppUiState.kt

@@ -3,7 +3,6 @@ package com.zaneschepke.wireguardautotunnel.ui
 data class AppUiState(
 	val snackbarMessage: String = "",
 	val snackbarMessageConsumed: Boolean = true,
-    val vpnPermissionAccepted: Boolean = false,
 	val notificationPermissionAccepted: Boolean = false,
-    val requestPermissions: Boolean = false
+	val requestPermissions: Boolean = false,
 )

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/AppViewModel.kt

@@ -1,100 +1,29 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
-import android.content.ActivityNotFoundException
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
 import androidx.lifecycle.ViewModel
-import com.wireguard.android.backend.GoBackend
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.util.Constants
+import androidx.lifecycle.viewModelScope
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
-import timber.log.Timber
+import kotlinx.coroutines.launch
+import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
 
 @HiltViewModel
 class AppViewModel
 @Inject
-constructor() : ViewModel() {
+constructor(
+	private val appDataRepository: AppDataRepository,
+) : ViewModel() {
 
-    val vpnIntent: Intent? = GoBackend.VpnService.prepare(WireGuardAutoTunnel.instance)
-
-    private val _appUiState = MutableStateFlow(
-        AppUiState(
-            vpnPermissionAccepted = vpnIntent == null,
-        ),
+	private val _appUiState =
+		MutableStateFlow(
+			AppUiState(),
 		)
 	val appUiState = _appUiState.asStateFlow()
 
-
-    fun isRequiredPermissionGranted(): Boolean {
-        val allAccepted =
-            (_appUiState.value.vpnPermissionAccepted && _appUiState.value.vpnPermissionAccepted)
-        if (!allAccepted) requestPermissions()
-        return allAccepted
-    }
-
-    private fun requestPermissions() {
-        _appUiState.update {
-            it.copy(
-                requestPermissions = true,
-            )
-        }
-    }
-
-    fun permissionsRequested() {
-        _appUiState.update {
-            it.copy(
-                requestPermissions = false,
-            )
-        }
-    }
-
-    fun openWebPage(url: String, context: Context) {
-        try {
-            val webpage: Uri = Uri.parse(url)
-            val intent = Intent(Intent.ACTION_VIEW, webpage).apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            }
-            context.startActivity(intent)
-        } catch (e: ActivityNotFoundException) {
-            Timber.e(e)
-            showSnackbarMessage(context.getString(R.string.no_browser_detected))
-        }
-    }
-
-    fun onVpnPermissionAccepted() {
-        _appUiState.update {
-            it.copy(
-                vpnPermissionAccepted = true,
-            )
-        }
-    }
-
-    fun launchEmail(context: Context) {
-        try {
-            val intent =
-                Intent(Intent.ACTION_SENDTO).apply {
-                    type = Constants.EMAIL_MIME_TYPE
-                    putExtra(Intent.EXTRA_EMAIL, arrayOf(context.getString(R.string.my_email)))
-                    putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.email_subject))
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                }
-            context.startActivity(
-                Intent.createChooser(intent, context.getString(R.string.email_chooser)).apply {
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                },
-            )
-        } catch (e: ActivityNotFoundException) {
-            Timber.e(e)
-            showSnackbarMessage(context.getString(R.string.no_email_detected))
-        }
-    }
-
 	fun showSnackbarMessage(message: String) {
 		_appUiState.update {
 			it.copy(
@@ -113,11 +42,12 @@ constructor() : ViewModel() {
 		}
 	}
 
-    fun setNotificationPermissionAccepted(accepted: Boolean) {
-        _appUiState.update {
-            it.copy(
-                notificationPermissionAccepted = accepted,
-            )
+	fun onPinLockDisabled() = viewModelScope.launch {
+		PinManager.clearPin()
+		appDataRepository.appState.setPinLockEnabled(false)
 	}
+
+	fun onPinLockEnabled() = viewModelScope.launch {
+		appDataRepository.appState.setPinLockEnabled(true)
 	}
 }

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

@@ -1,14 +1,13 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
-import android.Manifest
-import android.os.Build
 import android.os.Bundle
 import androidx.activity.SystemBarStyle
-import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
@@ -19,6 +18,7 @@ import androidx.compose.material3.SnackbarDuration
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.SnackbarResult
+import androidx.compose.material3.Surface
 import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -38,14 +38,8 @@ import androidx.navigation.compose.composable
 import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.navArgument
-import com.google.accompanist.permissions.ExperimentalPermissionsApi
-import com.google.accompanist.permissions.isGranted
-import com.google.accompanist.permissions.rememberPermissionState
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.CustomSnackBar
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.ConfigScreen
@@ -57,6 +51,7 @@ import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.logs.LogsScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.StringValue
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
@@ -65,19 +60,12 @@ import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
-
 	@Inject
 	lateinit var appStateRepository: AppStateRepository
 
 	@Inject
-    lateinit var settingsRepository: SettingsRepository
+	lateinit var tunnelService: TunnelService
 
-    @Inject
-    lateinit var serviceManager: ServiceManager
-
-    @OptIn(
-        ExperimentalPermissionsApi::class,
-    )
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
 
@@ -85,37 +73,14 @@ class MainActivity : AppCompatActivity() {
 
 		enableEdgeToEdge(navigationBarStyle = SystemBarStyle.dark(Color.Transparent.toArgb()))
 
-        lifecycleScope.launch {
-            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
-            val settings = settingsRepository.getSettings()
-            if (settings.isAutoTunnelEnabled) {
-                serviceManager.startWatcherService(application.applicationContext)
-            }
-        }
-
 		setContent {
 			val appViewModel = hiltViewModel<AppViewModel>()
 			val appUiState by appViewModel.appUiState.collectAsStateWithLifecycle()
 			val navController = rememberNavController()
 			val navBackStackEntry by navController.currentBackStackEntryAsState()
 
-            val notificationPermissionState =
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
-                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS) else null
-
 			val snackbarHostState = remember { SnackbarHostState() }
 
-            val vpnActivityResultState =
-                rememberLauncherForActivityResult(
-                    ActivityResultContracts.StartActivityForResult(),
-                    onResult = {
-                        val accepted = (it.resultCode == RESULT_OK)
-                        if (accepted) {
-                            appViewModel.onVpnPermissionAccepted()
-                        }
-                    },
-                )
-
 			fun showSnackBarMessage(message: StringValue) {
 				lifecycleScope.launch(Dispatchers.Main) {
 					val result =
@@ -125,38 +90,15 @@ class MainActivity : AppCompatActivity() {
 						)
 					when (result) {
 						SnackbarResult.ActionPerformed,
-                        SnackbarResult.Dismissed -> {
+						SnackbarResult.Dismissed,
+						-> {
 							snackbarHostState.currentSnackbarData?.dismiss()
 						}
 					}
 				}
 			}
 
-            LaunchedEffect(appUiState.requestPermissions) {
-                if (appUiState.requestPermissions) {
-                    appViewModel.permissionsRequested()
-                    if (notificationPermissionState != null && !notificationPermissionState.status.isGranted
-                    ) {
-                        showSnackBarMessage(StringValue.StringResource(R.string.notification_permission_required))
-                        return@LaunchedEffect notificationPermissionState.launchPermissionRequest()
-                    }
-                    if (!appUiState.vpnPermissionAccepted) {
-                        return@LaunchedEffect appViewModel.vpnIntent?.let {
-                            vpnActivityResultState.launch(
-                                it,
-                            )
-                        }!!
-                    }
-                }
-            }
-
 			WireguardAutoTunnelTheme {
-                LaunchedEffect(Unit) {
-                    appViewModel.setNotificationPermissionAccepted(
-                        notificationPermissionState?.status?.isGranted ?: true,
-                    )
-                }
-
 				LaunchedEffect(appUiState.snackbarMessageConsumed) {
 					if (!appUiState.snackbarMessageConsumed) {
 						showSnackBarMessage(StringValue.DynamicString(appUiState.snackbarMessage))
@@ -179,8 +121,9 @@ class MainActivity : AppCompatActivity() {
 							)
 						}
 					},
-                    //TODO refactor
-                    modifier = Modifier
+					containerColor = MaterialTheme.colorScheme.background,
+					modifier =
+					Modifier
 						.focusable()
 						.focusProperties {
 							when (navBackStackEntry?.destination?.route) {
@@ -199,12 +142,12 @@ class MainActivity : AppCompatActivity() {
 						)
 					},
 				) { padding ->
+					Surface(modifier = Modifier.fillMaxSize().padding(padding)) {
 						NavHost(
 							navController,
+							enterTransition = { fadeIn(tween(Constants.TRANSITION_ANIMATION_TIME)) },
+							exitTransition = { fadeOut(tween(Constants.TRANSITION_ANIMATION_TIME)) },
 							startDestination = (if (isPinLockEnabled == true) Screen.Lock.route else Screen.Main.route),
-                        modifier = Modifier
-                            .padding(padding)
-                            .fillMaxSize(),
 						) {
 							composable(
 								Screen.Main.route,
@@ -229,7 +172,6 @@ class MainActivity : AppCompatActivity() {
 							) {
 								SupportScreen(
 									focusRequester = focusRequester,
-                                appViewModel = appViewModel,
 									navController = navController,
 								)
 							}
@@ -251,7 +193,8 @@ class MainActivity : AppCompatActivity() {
 								),
 							) {
 								val id = it.arguments?.getString("id")
-                            val configType = ConfigType.valueOf(
+								val configType =
+									ConfigType.valueOf(
 										it.arguments?.getString("configType") ?: ConfigType.WIREGUARD.name,
 									)
 								if (!id.isNullOrBlank()) {
@@ -286,4 +229,10 @@ class MainActivity : AppCompatActivity() {
 				}
 			}
 		}
+	}
+
+	override fun onDestroy() {
+		super.onDestroy()
+		tunnelService.cancelStatsJob()
+	}
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/Screen.kt

@@ -39,6 +39,7 @@ sealed class Screen(val route: String) {
 	}
 
 	data object Config : Screen("config")
+
 	data object Lock : Screen("lock")
 
 	data object Option : Screen("option")

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/SplashActivity.kt

@@ -9,30 +9,34 @@ import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
-import com.zaneschepke.logcatter.LocalLogCollector
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel.Companion.isRunningOnAndroidTv
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestAutoTunnelTileServiceUpdate
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
+import javax.inject.Provider
 
 @SuppressLint("CustomSplashScreen")
 @AndroidEntryPoint
 class SplashActivity : ComponentActivity() {
-
 	@Inject
 	lateinit var appStateRepository: AppStateRepository
 
 	@Inject
-    lateinit var localLogCollector: LocalLogCollector
+	lateinit var appDataRepository: AppDataRepository
 
 	@Inject
-    @ApplicationScope
-    lateinit var applicationScope: CoroutineScope
+	lateinit var tunnelService: Provider<TunnelService>
+
+	@Inject
+	lateinit var serviceManager: ServiceManager
 
 	override fun onCreate(savedInstanceState: Bundle?) {
 		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
@@ -41,18 +45,22 @@ class SplashActivity : ComponentActivity() {
 		}
 		super.onCreate(savedInstanceState)
 
-        applicationScope.launch {
-            if (!isRunningOnAndroidTv()) localLogCollector.start()
-        }
-
 		lifecycleScope.launch {
 			repeatOnLifecycle(Lifecycle.State.CREATED) {
 				val pinLockEnabled = appStateRepository.isPinLockEnabled()
 				if (pinLockEnabled) {
 					PinManager.initialize(WireGuardAutoTunnel.instance)
 				}
+				val settings = appDataRepository.settings.getSettings()
+				if (settings.isAutoTunnelEnabled) serviceManager.startWatcherService(application.applicationContext)
+				if (tunnelService.get().getState() == TunnelState.UP) tunnelService.get().startStatsJob()
+				val tunnels = appDataRepository.tunnels.getActive()
+				if (tunnels.isNotEmpty() && tunnelService.get().getState() == TunnelState.DOWN) tunnelService.get().startTunnel(tunnels.first())
+				requestTunnelTileServiceStateUpdate()
+				requestAutoTunnelTileServiceUpdate()
 
-                val intent = Intent(this@SplashActivity, MainActivity::class.java).apply {
+				val intent =
+					Intent(this@SplashActivity, MainActivity::class.java).apply {
 						putExtra(IS_PIN_LOCK_ENABLED_KEY, pinLockEnabled)
 					}
 				startActivity(intent)
@@ -65,4 +73,3 @@ class SplashActivity : ComponentActivity() {
 		const val IS_PIN_LOCK_ENABLED_KEY = "is_pin_lock_enabled"
 	}
 }
-

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

@@ -12,13 +12,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 
 @Composable
-fun ClickableIconButton(
-    onClick: () -> Unit,
-    onIconClick: () -> Unit,
-    text: String,
-    icon: ImageVector,
-    enabled: Boolean
-) {
+fun ClickableIconButton(onClick: () -> Unit, onIconClick: () -> Unit, text: String, icon: ImageVector, enabled: Boolean) {
 	TextButton(
 		onClick = onClick,
 		enabled = enabled,

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

@@ -15,12 +15,14 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import com.zaneschepke.wireguardautotunnel.util.toThreeDecimalPlaceString
+import com.zaneschepke.wireguardautotunnel.util.extensions.toThreeDecimalPlaceString
 
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
@@ -31,11 +33,13 @@ fun RowListItem(
 	onClick: () -> Unit,
 	rowButton: @Composable () -> Unit,
 	expanded: Boolean,
-    statistics: TunnelStatistics?
+	statistics: TunnelStatistics?,
+	focusRequester: FocusRequester,
 ) {
 	Box(
 		modifier =
 		Modifier
+			.focusRequester(focusRequester)
 			.animateContentSize()
 			.clip(RoundedCornerShape(30.dp))
 			.combinedClickable(
@@ -45,7 +49,8 @@ fun RowListItem(
 	) {
 		Column {
 			Row(
-                modifier = Modifier
+				modifier =
+				Modifier
 					.fillMaxWidth()
 					.padding(horizontal = 15.dp, vertical = 5.dp),
 				verticalAlignment = Alignment.CenterVertically,
@@ -70,7 +75,7 @@ fun RowListItem(
 						verticalAlignment = Alignment.CenterVertically,
 						horizontalArrangement = Arrangement.SpaceEvenly,
 					) {
-                        //TODO change these to string resources
+						// TODO change these to string resources
 						val handshakeEpoch = statistics.peerStats(it)!!.latestHandshakeEpochMillis
 						val peerTx = statistics.peerStats(it)!!.txBytes
 						val peerRx = statistics.peerStats(it)!!.rxBytes

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/config/ConfigurationTextBox.kt

@@ -16,7 +16,7 @@ fun ConfigurationTextBox(
 	onValueChange: (String) -> Unit,
 	keyboardActions: KeyboardActions,
 	label: String,
-    modifier: Modifier
+	modifier: Modifier,
 ) {
 	OutlinedTextField(
 		modifier = modifier,

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/config/ConfigurationToggle.kt

@@ -13,24 +13,20 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.Dp
 
 @Composable
-fun ConfigurationToggle(
-    label: String,
-    enabled: Boolean,
-    checked: Boolean,
-    padding: Dp,
-    onCheckChanged: () -> Unit,
-    modifier: Modifier = Modifier
-) {
+fun ConfigurationToggle(label: String, enabled: Boolean, checked: Boolean, padding: Dp, onCheckChanged: () -> Unit, modifier: Modifier = Modifier) {
 	Row(
-        modifier = Modifier
+		modifier =
+		Modifier
 			.fillMaxWidth()
 			.padding(padding),
 		verticalAlignment = Alignment.CenterVertically,
 		horizontalArrangement = Arrangement.SpaceBetween,
 	) {
 		Text(
-            label, textAlign = TextAlign.Start,
-            modifier = Modifier
+			label,
+			textAlign = TextAlign.Start,
+			modifier =
+			Modifier
 				.weight(
 					weight = 1.0f,
 					fill = false,

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/dialog/InfoDialog.kt

@@ -0,0 +1,37 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.dialog
+
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import com.zaneschepke.wireguardautotunnel.R
+
+@Composable
+fun InfoDialog(
+	onAttest: () -> Unit,
+	onDismiss: () -> Unit,
+	title: @Composable () -> Unit,
+	body: @Composable () -> Unit,
+	confirmText: @Composable () -> Unit,
+) {
+	AlertDialog(
+		onDismissRequest = { onDismiss() },
+		confirmButton = {
+			TextButton(
+				onClick = {
+					onAttest()
+				},
+			) {
+				confirmText()
+			}
+		},
+		dismissButton = {
+			TextButton(onClick = { onDismiss() }) {
+				Text(text = stringResource(R.string.cancel))
+			}
+		},
+		title = { title() },
+		text = { body() },
+	)
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/functions/Functions.kt

@@ -0,0 +1,53 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.functions
+
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import androidx.activity.compose.ManagedActivityResultLauncher
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
+import com.zaneschepke.wireguardautotunnel.util.Constants
+
+@Composable
+fun rememberFileImportLauncherForResult(onNoFileExplorer: () -> Unit, onData: (data: Uri) -> Unit): ManagedActivityResultLauncher<String, Uri?> {
+	return 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)
+					}
+				) {
+					onNoFileExplorer()
+				}
+				return intent
+			}
+		},
+	) { data ->
+		if (data == null) return@rememberLauncherForActivityResult
+		onData(data)
+	}
+}

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

@@ -10,34 +10,41 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
 import androidx.navigation.NavController
+import androidx.navigation.NavGraph.Companion.findStartDestination
 import androidx.navigation.compose.currentBackStackEntryAsState
-import com.zaneschepke.wireguardautotunnel.ui.Screen
 
 @Composable
 fun BottomNavBar(navController: NavController, bottomNavItems: List<BottomNavItem>) {
-    val backStackEntry = navController.currentBackStackEntryAsState()
-
 	var showBottomBar by rememberSaveable { mutableStateOf(true) }
 	val navBackStackEntry by navController.currentBackStackEntryAsState()
 
-    //TODO find a better way to hide nav bar
-    showBottomBar = when (navBackStackEntry?.destination?.route) {
-        Screen.Lock.route -> false
-        else -> true
-    }
+	showBottomBar = bottomNavItems.firstOrNull { navBackStackEntry?.destination?.route?.contains(it.route) == true } != null
 
+	if (showBottomBar) {
 		NavigationBar(
-        containerColor = if (!showBottomBar) Color.Transparent else MaterialTheme.colorScheme.background,
+			containerColor = MaterialTheme.colorScheme.surface,
 		) {
-        if (showBottomBar) bottomNavItems.forEach { item ->
-            val selected = item.route == backStackEntry.value?.destination?.route
+			bottomNavItems.forEach { item ->
+				val selected = navBackStackEntry?.destination?.route?.contains(item.route) == true
 
 				NavigationBarItem(
 					selected = selected,
-                onClick = { navController.navigate(item.route) },
+					onClick = {
+						if (navBackStackEntry?.destination?.route == item.route) return@NavigationBarItem
+						navController.navigate(item.route) {
+							// Pop up to the start destination of the graph to
+							// avoid building up a large stack of destinations
+							// on the back stack as users select items
+							popUpTo(navController.graph.findStartDestination().id) {
+								saveState = true
+							}
+							// Avoid multiple copies of the same destination when
+							// reselecting the same item
+							launchSingleTop = true
+						}
+					},
 					label = {
 						Text(
 							text = item.name,
@@ -53,4 +60,5 @@ fun BottomNavBar(navController: NavController, bottomNavItems: List<BottomNavIte
 				)
 			}
 		}
+	}
 }

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

@@ -15,7 +15,8 @@ fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (
 	val context = LocalContext.current
 	val biometricManager = BiometricManager.from(context)
 	val bio = biometricManager.canAuthenticate(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
-    val isBiometricAvailable = remember {
+	val isBiometricAvailable =
+		remember {
 			when (bio) {
 				BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
 					onError("Biometrics not available")
@@ -71,9 +72,7 @@ fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (
 						onFailure()
 					}
 
-                    override fun onAuthenticationSucceeded(
-                        result: BiometricPrompt.AuthenticationResult
-                    ) {
+					override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
 						super.onAuthenticationSucceeded(result)
 						onSuccess()
 					}

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

@@ -19,23 +19,21 @@ 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.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 
 @Composable
-fun CustomSnackBar(
-    message: String,
-    isRtl: Boolean = true,
-    containerColor: Color = MaterialTheme.colorScheme.surface
-) {
+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,
+				if (context.isRunningOnTv()) 1 / 3f else 2 / 3f,
 			)
 			.padding(bottom = 100.dp),
 		shape = RoundedCornerShape(16.dp),
@@ -44,7 +42,8 @@ fun CustomSnackBar(
 			LocalLayoutDirection provides if (isRtl) LayoutDirection.Rtl else LayoutDirection.Ltr,
 		) {
 			Row(
-                modifier = Modifier
+				modifier =
+				Modifier
 					.width(IntrinsicSize.Max)
 					.height(IntrinsicSize.Min),
 				verticalAlignment = Alignment.CenterVertically,
@@ -54,10 +53,10 @@ fun CustomSnackBar(
 				Icon(
 					icon,
 					contentDescription = icon.name,
-                    tint = Color.White,
+					tint = MaterialTheme.colorScheme.onSurface,
 					modifier = Modifier.padding(end = 10.dp),
 				)
-                Text(message, color = Color.White, modifier = Modifier.padding(end = 5.dp))
+				Text(message, color = MaterialTheme.colorScheme.onSurface, modifier = Modifier.padding(end = 5.dp))
 			}
 		}
 	}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/screen/LoadingScreen.kt

@@ -16,7 +16,8 @@ fun LoadingScreen() {
 	Column(
 		horizontalAlignment = Alignment.CenterHorizontally,
 		verticalArrangement = Arrangement.Top,
-        modifier = Modifier
+		modifier =
+		Modifier
 			.fillMaxSize()
 			.focusable()
 			.padding(),

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/text/LogTypeLabel.kt

@@ -14,7 +14,8 @@ import androidx.compose.ui.unit.dp
 @Composable
 fun LogTypeLabel(color: Color, content: @Composable () -> Unit) {
 	Box(
-        modifier = Modifier
+		modifier =
+		Modifier
 			.size(20.dp)
 			.clip(RoundedCornerShape(2.dp))
 			.background(color),

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

@@ -54,7 +54,6 @@ 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
@@ -71,7 +70,6 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
 import com.google.accompanist.drawablepainter.DrawablePainter
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.SearchBar
@@ -81,7 +79,8 @@ import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
 import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.getMessage
+import com.zaneschepke.wireguardautotunnel.util.extensions.getMessage
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import kotlinx.coroutines.delay
 
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@@ -95,7 +94,7 @@ fun ConfigScreen(
 	navController: NavController,
 	appViewModel: AppViewModel,
 	tunnelId: String,
-    configType: ConfigType
+	configType: ConfigType,
 ) {
 	val context = LocalContext.current
 	val clipboardManager: ClipboardManager = LocalClipboardManager.current
@@ -109,11 +108,16 @@ fun ConfigScreen(
 	LaunchedEffect(Unit) { viewModel.init(tunnelId) }
 
 	LaunchedEffect(uiState.loading) {
-        if (!uiState.loading && WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+		if (!uiState.loading && context.isRunningOnTv()) {
+			delay(Constants.FOCUS_REQUEST_DELAY)
+			kotlin.runCatching {
+				focusRequester.requestFocus()
+			}.onFailure {
 				delay(Constants.FOCUS_REQUEST_DELAY)
 				focusRequester.requestFocus()
 			}
 		}
+	}
 
 	if (uiState.loading) {
 		LoadingScreen()
@@ -128,16 +132,23 @@ fun ConfigScreen(
 	val fillMaxWidth = .85f
 	val screenPadding = 5.dp
 
-    val applicationButtonText = buildAnnotatedString {
+	val applicationButtonText =
+		buildAnnotatedString {
 			append(stringResource(id = R.string.tunneling_apps))
 			append(": ")
 			if (uiState.isAllApplicationsEnabled) {
 				append(stringResource(id = R.string.all))
 			} else {
 				append("${uiState.checkedPackageNames.size} ")
-            (if (uiState.include) append(stringResource(id = R.string.included)) else append(
+				(
+					if (uiState.include) {
+						append(stringResource(id = R.string.included))
+					} else {
+						append(
 							stringResource(id = R.string.excluded),
-            ))
+						)
+					}
+					)
 			}
 		}
 
@@ -149,11 +160,15 @@ fun ConfigScreen(
 			},
 			onError = {
 				showAuthPrompt = false
-                appViewModel.showSnackbarMessage(context.getString(R.string.error_authentication_failed))
+				appViewModel.showSnackbarMessage(
+					context.getString(R.string.error_authentication_failed),
+				)
 			},
 			onFailure = {
 				showAuthPrompt = false
-                appViewModel.showSnackbarMessage(context.getString(R.string.error_authorization_failed))
+				appViewModel.showSnackbarMessage(
+					context.getString(R.string.error_authorization_failed),
+				)
 			},
 		)
 	}
@@ -175,7 +190,8 @@ fun ConfigScreen(
 					.fillMaxHeight(if (uiState.isAllApplicationsEnabled) 1 / 5f else 4 / 5f),
 			) {
 				Column(
-                    modifier = Modifier
+					modifier =
+					Modifier
 						.fillMaxWidth(),
 				) {
 					Row(
@@ -246,7 +262,8 @@ fun ConfigScreen(
 								Row(
 									verticalAlignment = Alignment.CenterVertically,
 									horizontalArrangement = Arrangement.SpaceBetween,
-                                    modifier = Modifier
+									modifier =
+									Modifier
 										.fillMaxSize()
 										.padding(5.dp),
 								) {
@@ -275,9 +292,11 @@ fun ConfigScreen(
 									Checkbox(
 										modifier = Modifier.fillMaxSize(),
 										checked =
-                                        (uiState.checkedPackageNames.contains(
+										(
+											uiState.checkedPackageNames.contains(
 												pack.packageName,
-                                        )),
+											)
+											),
 										onCheckedChange = {
 											if (it) {
 												viewModel.onAddCheckedPackage(pack.packageName)
@@ -292,7 +311,8 @@ fun ConfigScreen(
 					}
 					Row(
 						verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier
+						modifier =
+						Modifier
 							.fillMaxSize()
 							.padding(top = 5.dp),
 						horizontalArrangement = Arrangement.Center,
@@ -315,13 +335,15 @@ fun ConfigScreen(
 			FloatingActionButton(
 				modifier =
 				Modifier.onFocusChanged {
-                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+					if (context.isRunningOnTv()) {
 						fobColor = if (it.isFocused) hoverColor else secondaryColor
 					}
 				},
 				onClick = {
 					viewModel.onSaveAllChanges(configType).onSuccess {
-                        appViewModel.showSnackbarMessage(context.getString(R.string.config_changes_saved))
+						appViewModel.showSnackbarMessage(
+							context.getString(R.string.config_changes_saved),
+						)
 						navController.navigate(Screen.Main.route)
 					}.onFailure {
 						appViewModel.showSnackbarMessage(it.getMessage(context))
@@ -333,7 +355,7 @@ fun ConfigScreen(
 				Icon(
 					imageVector = Icons.Rounded.Save,
 					contentDescription = stringResource(id = R.string.save_changes),
-                    tint = Color.DarkGray,
+					tint = MaterialTheme.colorScheme.background,
 				)
 			}
 		},
@@ -354,19 +376,22 @@ fun ConfigScreen(
 					shape = RoundedCornerShape(12.dp),
 					color = MaterialTheme.colorScheme.surface,
 					modifier =
-                    (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+					(
+						if (context.isRunningOnTv()) {
 							Modifier
 								.fillMaxHeight(fillMaxHeight)
 								.fillMaxWidth(fillMaxWidth)
 						} else {
 							Modifier.fillMaxWidth(fillMaxWidth)
-                    })
+						}
+						)
 						.padding(bottom = 10.dp),
 				) {
 					Column(
 						horizontalAlignment = Alignment.Start,
 						verticalArrangement = Arrangement.Top,
-                        modifier = Modifier
+						modifier =
+						Modifier
 							.padding(15.dp)
 							.focusGroup(),
 					) {
@@ -380,19 +405,23 @@ fun ConfigScreen(
 							keyboardActions = keyboardActions,
 							label = stringResource(R.string.name),
 							hint = stringResource(R.string.tunnel_name).lowercase(),
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.fillMaxWidth()
 								.focusRequester(focusRequester),
 						)
 						OutlinedTextField(
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.fillMaxWidth()
 								.clickable { showAuthPrompt = true },
 							value = uiState.interfaceProxy.privateKey,
 							visualTransformation =
-                            if ((tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated)
+							if ((tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated) {
 								VisualTransformation.None
-                            else PasswordVisualTransformation(),
+							} else {
+								PasswordVisualTransformation()
+							},
 							enabled = (tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated,
 							onValueChange = { value -> viewModel.onPrivateKeyChange(value) },
 							trailingIcon = {
@@ -403,7 +432,7 @@ fun ConfigScreen(
 									Icon(
 										Icons.Rounded.Refresh,
 										stringResource(R.string.rotate_keys),
-                                        tint = Color.White,
+										tint = MaterialTheme.colorScheme.onSurface,
 									)
 								}
 							},
@@ -433,7 +462,7 @@ fun ConfigScreen(
 									Icon(
 										Icons.Rounded.ContentCopy,
 										stringResource(R.string.copy_public_key),
-                                        tint = Color.White,
+										tint = MaterialTheme.colorScheme.onSurface,
 									)
 								}
 							},
@@ -450,7 +479,8 @@ fun ConfigScreen(
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.addresses),
 								hint = stringResource(R.string.comma_separated_list),
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.fillMaxWidth(3 / 5f)
 									.padding(end = 5.dp),
 							)
@@ -470,7 +500,8 @@ fun ConfigScreen(
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.dns_servers),
 								hint = stringResource(R.string.comma_separated_list),
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.fillMaxWidth(3 / 5f)
 									.padding(end = 5.dp),
 							)
@@ -486,11 +517,15 @@ fun ConfigScreen(
 						if (configType == ConfigType.AMNEZIA) {
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.junkPacketCount,
-                                onValueChange = { value -> viewModel.onJunkPacketCountChanged(value) },
+								onValueChange = {
+										value ->
+									viewModel.onJunkPacketCountChanged(value)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.junk_packet_count),
 								hint = stringResource(R.string.junk_packet_count).lowercase(),
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
@@ -503,8 +538,12 @@ fun ConfigScreen(
 								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.junk_packet_minimum_size),
-                                hint = stringResource(R.string.junk_packet_minimum_size).lowercase(),
-                                modifier = Modifier
+								hint =
+								stringResource(
+									R.string.junk_packet_minimum_size,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
@@ -517,8 +556,12 @@ fun ConfigScreen(
 								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.junk_packet_maximum_size),
-                                hint = stringResource(R.string.junk_packet_maximum_size).lowercase(),
-                                modifier = Modifier
+								hint =
+								stringResource(
+									R.string.junk_packet_maximum_size,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
@@ -532,27 +575,42 @@ fun ConfigScreen(
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.init_packet_junk_size),
 								hint = stringResource(R.string.init_packet_junk_size).lowercase(),
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.responsePacketJunkSize,
-                                onValueChange = { value -> viewModel.onResponsePacketJunkSize(value) },
+								onValueChange = {
+										value ->
+									viewModel.onResponsePacketJunkSize(value)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.response_packet_junk_size),
-                                hint = stringResource(R.string.response_packet_junk_size).lowercase(),
-                                modifier = Modifier
+								hint =
+								stringResource(
+									R.string.response_packet_junk_size,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.initPacketMagicHeader,
-                                onValueChange = { value -> viewModel.onInitPacketMagicHeader(value) },
+								onValueChange = {
+										value ->
+									viewModel.onInitPacketMagicHeader(value)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.init_packet_magic_header),
-                                hint = stringResource(R.string.init_packet_magic_header).lowercase(),
-                                modifier = Modifier
+								hint =
+								stringResource(
+									R.string.init_packet_magic_header,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
@@ -565,8 +623,12 @@ fun ConfigScreen(
 								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.response_packet_magic_header),
-                                hint = stringResource(R.string.response_packet_magic_header).lowercase(),
-                                modifier = Modifier
+								hint =
+								stringResource(
+									R.string.response_packet_magic_header,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
@@ -579,8 +641,12 @@ fun ConfigScreen(
 								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.underload_packet_magic_header),
-                                hint = stringResource(R.string.underload_packet_magic_header).lowercase(),
-                                modifier = Modifier
+								hint =
+								stringResource(
+									R.string.underload_packet_magic_header,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
@@ -593,15 +659,20 @@ fun ConfigScreen(
 								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.transport_packet_magic_header),
-                                hint = stringResource(R.string.transport_packet_magic_header).lowercase(),
-                                modifier = Modifier
+								hint =
+								stringResource(
+									R.string.transport_packet_magic_header,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 						}
 						Row(
 							verticalAlignment = Alignment.CenterVertically,
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.fillMaxSize()
 								.padding(top = 5.dp),
 							horizontalArrangement = Arrangement.Center,
@@ -619,26 +690,30 @@ fun ConfigScreen(
 						shape = RoundedCornerShape(12.dp),
 						color = MaterialTheme.colorScheme.surface,
 						modifier =
-                        (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+						(
+							if (context.isRunningOnTv()) {
 								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
+							modifier =
+							Modifier
 								.padding(horizontal = 15.dp)
 								.padding(bottom = 10.dp),
 						) {
 							Row(
 								horizontalArrangement = Arrangement.SpaceBetween,
 								verticalAlignment = Alignment.CenterVertically,
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.padding(horizontal = 5.dp),
 							) {
@@ -724,7 +799,8 @@ fun ConfigScreen(
 				Row(
 					horizontalArrangement = Arrangement.SpaceEvenly,
 					verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier
+					modifier =
+					Modifier
 						.fillMaxSize()
 						.padding(bottom = 140.dp),
 				) {
@@ -738,7 +814,7 @@ fun ConfigScreen(
 					}
 				}
 			}
-            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+			if (context.isRunningOnTv()) {
 				Spacer(modifier = Modifier.weight(.17f))
 			}
 		}

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

@@ -4,7 +4,7 @@ import com.wireguard.config.Config
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.model.InterfaceProxy
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.model.PeerProxy
-import com.zaneschepke.wireguardautotunnel.util.Packages
+import com.zaneschepke.wireguardautotunnel.util.extensions.Packages
 
 data class ConfigUiState(
 	val proxyPeers: List<PeerProxy> = arrayListOf(PeerProxy()),
@@ -16,7 +16,7 @@ data class ConfigUiState(
 	val loading: Boolean = true,
 	val tunnel: TunnelConfig? = null,
 	val tunnelName: String = "",
-    val isAmneziaEnabled: Boolean = false
+	val isAmneziaEnabled: Boolean = false,
 ) {
 	companion object {
 		fun from(config: Config): ConfigUiState {
@@ -45,7 +45,7 @@ data class ConfigUiState(
 		}
 
 		fun from(config: org.amnezia.awg.config.Config): ConfigUiState {
-            //TODO update with new values
+			// TODO update with new values
 			val proxyPeers = config.peers.map { PeerProxy.from(it) }
 			val proxyInterface = InterfaceProxy.from(config.`interface`)
 			var include = true

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

@@ -23,8 +23,8 @@ import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.StringValue
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
-import com.zaneschepke.wireguardautotunnel.util.removeAt
-import com.zaneschepke.wireguardautotunnel.util.update
+import com.zaneschepke.wireguardautotunnel.util.extensions.removeAt
+import com.zaneschepke.wireguardautotunnel.util.extensions.update
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -40,16 +40,14 @@ class ConfigViewModel
 constructor(
 	private val settingsRepository: SettingsRepository,
 	private val appDataRepository: AppDataRepository,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : ViewModel() {
-
 	private val packageManager = WireGuardAutoTunnel.instance.packageManager
 
 	private val _uiState = MutableStateFlow(ConfigUiState())
 	val uiState = _uiState.asStateFlow()
 
-    fun init(tunnelId: String) =
-        viewModelScope.launch(ioDispatcher) {
+	fun init(tunnelId: String) = viewModelScope.launch(ioDispatcher) {
 		val packages = getQueriedPackages("")
 		val state =
 			if (tunnelId != Constants.MANUAL_TUNNEL_CONFIG_ID) {
@@ -58,11 +56,17 @@ constructor(
 						.firstOrNull { it.id.toString() == tunnelId }
 				val isAmneziaEnabled = settingsRepository.getSettings().isAmneziaEnabled
 				if (tunnelConfig != null) {
-                        (if (isAmneziaEnabled) {
+					(
+						if (isAmneziaEnabled) {
 							val amConfig =
 								if (tunnelConfig.amQuick == "") tunnelConfig.wgQuick else tunnelConfig.amQuick
 							ConfigUiState.from(TunnelConfig.configFromAmQuick(amConfig))
-                        } else ConfigUiState.from(TunnelConfig.configFromWgQuick(tunnelConfig.wgQuick))).copy(
+						} else {
+							ConfigUiState.from(
+								TunnelConfig.configFromWgQuick(tunnelConfig.wgQuick),
+							)
+						}
+						).copy(
 						packages = packages,
 						loading = false,
 						tunnel = tunnelConfig,
@@ -111,7 +115,7 @@ constructor(
 	}
 
 	fun getPackageLabel(packageInfo: PackageInfo): String {
-        return packageInfo.applicationInfo.loadLabel(packageManager).toString()
+		return packageInfo.applicationInfo?.loadLabel(packageManager).toString()
 	}
 
 	private fun getAllInternetCapablePackages(): List<PackageInfo> {
@@ -133,14 +137,11 @@ constructor(
 		return _uiState.value.isAllApplicationsEnabled
 	}
 
-    private fun saveConfig(tunnelConfig: TunnelConfig) =
-        viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }
+	private fun saveConfig(tunnelConfig: TunnelConfig) = viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }
 
-    private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) =
-        viewModelScope.launch {
+	private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) = viewModelScope.launch {
 		if (tunnelConfig != null) {
 			saveConfig(tunnelConfig).join()
-                WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
 		}
 	}
 
@@ -183,14 +184,23 @@ constructor(
 		if (_uiState.value.interfaceProxy.dnsServers.isNotEmpty()) {
 			builder.parseDnsServers(_uiState.value.interfaceProxy.dnsServers.trim())
 		}
-        if (_uiState.value.interfaceProxy.mtu.isNotEmpty())
+		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)
+		if (_uiState.value.include) {
+			builder.includeApplications(
+				_uiState.value.checkedPackageNames,
+			)
+		}
+		if (!_uiState.value.include) {
+			builder.excludeApplications(
+				_uiState.value.checkedPackageNames,
+			)
+		}
 		return builder.build()
 	}
 
@@ -201,16 +211,27 @@ constructor(
 		if (_uiState.value.interfaceProxy.dnsServers.isNotEmpty()) {
 			builder.parseDnsServers(_uiState.value.interfaceProxy.dnsServers.trim())
 		}
-        if (_uiState.value.interfaceProxy.mtu.isNotEmpty())
+		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)
+		if (_uiState.value.include) {
+			builder.includeApplications(
+				_uiState.value.checkedPackageNames,
+			)
+		}
+		if (!_uiState.value.include) {
+			builder.excludeApplications(
+				_uiState.value.checkedPackageNames,
+			)
+		}
 		if (_uiState.value.interfaceProxy.junkPacketCount.isNotEmpty()) {
-            builder.setJunkPacketCount(_uiState.value.interfaceProxy.junkPacketCount.trim().toInt())
+			builder.setJunkPacketCount(
+				_uiState.value.interfaceProxy.junkPacketCount.trim().toInt(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.junkPacketMinSize.isNotEmpty()) {
 			builder.setJunkPacketMinSize(
@@ -264,24 +285,32 @@ constructor(
 	private fun buildAmConfig(): org.amnezia.awg.config.Config {
 		val peerList = buildAmPeerListFromProxyPeers()
 		val amInterface = buildAmInterfaceListFromProxyInterface()
-        return org.amnezia.awg.config.Config.Builder().addPeers(peerList).setInterface(amInterface)
+		return org.amnezia.awg.config.Config.Builder().addPeers(
+			peerList,
+		).setInterface(amInterface)
 			.build()
 	}
 
 	fun onSaveAllChanges(configType: ConfigType): Result<Unit> {
 		return try {
-            val wgQuick = buildConfig().toWgQuickString()
-            val amQuick = if (configType == ConfigType.AMNEZIA) {
-                buildAmConfig().toAwgQuickString()
-            } else TunnelConfig.AM_QUICK_DEFAULT
-            val tunnelConfig = when (uiState.value.tunnel) {
-                null -> TunnelConfig(
+			val wgQuick = buildConfig().toWgQuickString(true)
+			val amQuick =
+				if (configType == ConfigType.AMNEZIA) {
+					buildAmConfig().toAwgQuickString(true)
+				} else {
+					TunnelConfig.AM_QUICK_DEFAULT
+				}
+			val tunnelConfig =
+				when (uiState.value.tunnel) {
+					null ->
+						TunnelConfig(
 							name = _uiState.value.tunnelName,
 							wgQuick = wgQuick,
 							amQuick = amQuick,
 						)
 
-                else -> uiState.value.tunnel!!.copy(
+					else ->
+						uiState.value.tunnel!!.copy(
 							name = _uiState.value.tunnelName,
 							wgQuick = wgQuick,
 							amQuick = amQuick,
@@ -292,7 +321,8 @@ constructor(
 		} catch (e: Exception) {
 			Timber.e(e)
 			val message = e.message?.substringAfter(":", missingDelimiterValue = "")
-            val stringValue = message?.let {
+			val stringValue =
+				message?.let {
 					StringValue.DynamicString(message)
 				} ?: StringValue.StringResource(R.string.unknown_error)
 			Result.failure(WgTunnelExceptions.ConfigParseError(stringValue))
@@ -392,7 +422,6 @@ constructor(
 				interfaceProxy = _uiState.value.interfaceProxy.copy(addresses = value),
 			)
 		}
-
 	}
 
 	fun onListenPortChanged(value: String) {
@@ -423,7 +452,6 @@ constructor(
 				interfaceProxy = _uiState.value.interfaceProxy.copy(publicKey = value),
 			)
 		}
-
 	}
 
 	fun onPrivateKeyChange(value: String) {
@@ -483,7 +511,10 @@ constructor(
 	fun onResponsePacketJunkSize(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(responsePacketJunkSize = value),
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					responsePacketJunkSize = value,
+				),
 			)
 		}
 	}
@@ -491,7 +522,10 @@ constructor(
 	fun onInitPacketMagicHeader(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(initPacketMagicHeader = value),
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					initPacketMagicHeader = value,
+				),
 			)
 		}
 	}
@@ -499,7 +533,10 @@ constructor(
 	fun onResponsePacketMagicHeader(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(responsePacketMagicHeader = value),
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					responsePacketMagicHeader = value,
+				),
 			)
 		}
 	}
@@ -507,7 +544,10 @@ constructor(
 	fun onTransportPacketMagicHeader(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(transportPacketMagicHeader = value),
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					transportPacketMagicHeader = value,
+				),
 			)
 		}
 	}
@@ -515,7 +555,10 @@ constructor(
 	fun onUnderloadPacketMagicHeader(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(underloadPacketMagicHeader = value),
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					underloadPacketMagicHeader = value,
+				),
 			)
 		}
 	}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/config/model/InterfaceProxy.kt

@@ -49,24 +49,69 @@ data class InterfaceProxy(
 					""
 				},
 				mtu = if (i.mtu.isPresent) i.mtu.get().toString().trim() else "",
-                junkPacketCount = if (i.junkPacketCount.isPresent) i.junkPacketCount.get()
-                    .toString() else "",
-                junkPacketMinSize = if (i.junkPacketMinSize.isPresent) i.junkPacketMinSize.get()
-                    .toString() else "",
-                junkPacketMaxSize = if (i.junkPacketMaxSize.isPresent) i.junkPacketMaxSize.get()
-                    .toString() else "",
-                initPacketJunkSize = if (i.initPacketJunkSize.isPresent) i.initPacketJunkSize.get()
-                    .toString() else "",
-                responsePacketJunkSize = if (i.responsePacketJunkSize.isPresent) i.responsePacketJunkSize.get()
-                    .toString() else "",
-                initPacketMagicHeader = if (i.initPacketMagicHeader.isPresent) i.initPacketMagicHeader.get()
-                    .toString() else "",
-                responsePacketMagicHeader = if (i.responsePacketMagicHeader.isPresent) i.responsePacketMagicHeader.get()
-                    .toString() else "",
-                transportPacketMagicHeader = if (i.transportPacketMagicHeader.isPresent) i.transportPacketMagicHeader.get()
-                    .toString() else "",
-                underloadPacketMagicHeader = if (i.underloadPacketMagicHeader.isPresent) i.underloadPacketMagicHeader.get()
-                    .toString() else "",
+				junkPacketCount =
+				if (i.junkPacketCount.isPresent) {
+					i.junkPacketCount.get()
+						.toString()
+				} else {
+					""
+				},
+				junkPacketMinSize =
+				if (i.junkPacketMinSize.isPresent) {
+					i.junkPacketMinSize.get()
+						.toString()
+				} else {
+					""
+				},
+				junkPacketMaxSize =
+				if (i.junkPacketMaxSize.isPresent) {
+					i.junkPacketMaxSize.get()
+						.toString()
+				} else {
+					""
+				},
+				initPacketJunkSize =
+				if (i.initPacketJunkSize.isPresent) {
+					i.initPacketJunkSize.get()
+						.toString()
+				} else {
+					""
+				},
+				responsePacketJunkSize =
+				if (i.responsePacketJunkSize.isPresent) {
+					i.responsePacketJunkSize.get()
+						.toString()
+				} else {
+					""
+				},
+				initPacketMagicHeader =
+				if (i.initPacketMagicHeader.isPresent) {
+					i.initPacketMagicHeader.get()
+						.toString()
+				} else {
+					""
+				},
+				responsePacketMagicHeader =
+				if (i.responsePacketMagicHeader.isPresent) {
+					i.responsePacketMagicHeader.get()
+						.toString()
+				} else {
+					""
+				},
+				transportPacketMagicHeader =
+				if (i.transportPacketMagicHeader.isPresent) {
+					i.transportPacketMagicHeader.get()
+						.toString()
+				} else {
+					""
+				},
+				underloadPacketMagicHeader =
+				if (i.underloadPacketMagicHeader.isPresent) {
+					i.underloadPacketMagicHeader.get()
+						.toString()
+				} else {
+					""
+				},
 			)
 		}
 	}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/config/model/PeerProxy.kt

@@ -7,7 +7,7 @@ data class PeerProxy(
 	val preSharedKey: String = "",
 	val persistentKeepalive: String = "",
 	val endpoint: String = "",
-    val allowedIps: String = IPV4_WILDCARD.joinToString(", ").trim()
+	val allowedIps: String = IPV4_WILDCARD.joinToString(", ").trim(),
 ) {
 	companion object {
 		fun from(peer: Peer): PeerProxy {

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

@@ -2,5 +2,5 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.main
 
 enum class ConfigType {
 	AMNEZIA,
-    WIREGUARD
+	WIREGUARD,
 }

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

@@ -1,40 +1,23 @@
 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.appcompat.app.AppCompatActivity.RESULT_OK
 import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.focusGroup
 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.Row
 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.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.foundation.text.ClickableText
 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.Bolt
 import androidx.compose.material.icons.rounded.Circle
 import androidx.compose.material.icons.rounded.CopyAll
@@ -43,23 +26,15 @@ import androidx.compose.material.icons.rounded.Info
 import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material.icons.rounded.Smartphone
 import androidx.compose.material.icons.rounded.Star
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.FabPosition
-import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.ModalBottomSheet
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
-import androidx.compose.material3.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
@@ -80,59 +55,64 @@ import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
-import com.iamageo.multifablibrary.FabIcon
-import com.iamageo.multifablibrary.FabOption
-import com.iamageo.multifablibrary.MultiFabItem
-import com.iamageo.multifablibrary.MultiFloatingActionButton
 import com.journeyapps.barcodescanner.ScanContract
 import com.journeyapps.barcodescanner.ScanOptions
+import com.wireguard.android.backend.GoBackend
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.RowListItem
+import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
+import com.zaneschepke.wireguardautotunnel.ui.common.functions.rememberFileImportLauncherForResult
 import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.GettingStartedLabel
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.ScrollDismissMultiFab
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.TunnelImportSheet
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.VpnDeniedDialog
 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.getMessage
-import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
-import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
+import com.zaneschepke.wireguardautotunnel.util.extensions.getMessage
+import com.zaneschepke.wireguardautotunnel.util.extensions.handshakeStatus
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
+import com.zaneschepke.wireguardautotunnel.util.extensions.mapPeerStats
+import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
+import com.zaneschepke.wireguardautotunnel.util.extensions.startTunnelBackground
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import timber.log.Timber
 
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
+@OptIn(ExperimentalFoundationApi::class)
 @Composable
 fun MainScreen(
 	viewModel: MainViewModel = hiltViewModel(),
 	appViewModel: AppViewModel,
 	focusRequester: FocusRequester,
-    navController: NavController
+	navController: NavController,
 ) {
 	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) }
 	var configType by remember { mutableStateOf(ConfigType.WIREGUARD) }
+	var showVpnPermissionDialog by remember { mutableStateOf(false) }
+	val isVisible = rememberSaveable { mutableStateOf(true) }
+	var showDeleteTunnelAlertDialog 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 {
+	val nestedScrollConnection =
+		remember {
 			object : NestedScrollConnection {
 				override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
 					// Hide FAB
@@ -143,66 +123,48 @@ fun MainScreen(
 					if (available.y > 1) {
 						isVisible.value = true
 					}
-
 					return Offset.Zero
 				}
 			}
 		}
 
-
-    var showDeleteTunnelAlertDialog by remember { mutableStateOf(false) }
-    var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+	val vpnActivityResultState =
+		rememberLauncherForActivityResult(
+			ActivityResultContracts.StartActivityForResult(),
+			onResult = {
+				val accepted = (it.resultCode == RESULT_OK)
+				if (accepted) {
+					Timber.d("VPN permission granted")
+				} else {
+					showVpnPermissionDialog = true
+				}
+			},
+		)
 
 	LaunchedEffect(Unit) {
-        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+		if (context.isRunningOnTv()) {
+			delay(Constants.FOCUS_REQUEST_DELAY)
+			kotlin.runCatching {
+				focusRequester.requestFocus()
+			}.onFailure {
 				delay(Constants.FOCUS_REQUEST_DELAY)
 				focusRequester.requestFocus()
 			}
 		}
+	}
 
-    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(),
-                                ),
+	val tunnelFileImportResultLauncher = rememberFileImportLauncherForResult(onNoFileExplorer = {
+		appViewModel.showSnackbarMessage(
+			context.getString(R.string.error_no_file_explorer),
 		)
-                        } 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)
-                        }
-                    ) {
-                        appViewModel.showSnackbarMessage(context.getString(R.string.error_no_file_explorer))
-                    }
-                    return intent
-                }
-            },
-        ) { data ->
-            if (data == null) return@rememberLauncherForActivityResult
+	}, onData = { data ->
 		scope.launch {
 			viewModel.onTunnelFileSelected(data, configType, context).onFailure {
 				appViewModel.showSnackbarMessage(it.getMessage(context))
 			}
 		}
-        }
+	})
+
 	val scanLauncher =
 		rememberLauncherForActivityResult(
 			contract = ScanContract(),
@@ -217,34 +179,32 @@ fun MainScreen(
 			},
 		)
 
-    AnimatedVisibility(showDeleteTunnelAlertDialog) {
-        AlertDialog(
-            onDismissRequest = { showDeleteTunnelAlertDialog = false },
-            confirmButton = {
-                TextButton(
-                    onClick = {
+	VpnDeniedDialog(showVpnPermissionDialog, onDismiss = { showVpnPermissionDialog = false })
+
+	if (showDeleteTunnelAlertDialog) {
+		InfoDialog(
+			onDismiss = { showDeleteTunnelAlertDialog = false },
+			onAttest = {
 				selectedTunnel?.let { viewModel.onDelete(it, context) }
 				showDeleteTunnelAlertDialog = false
 				selectedTunnel = null
 			},
-                ) {
-                    Text(text = stringResource(R.string.yes))
-                }
-            },
-            dismissButton = {
-                TextButton(onClick = { showDeleteTunnelAlertDialog = false }) {
-                    Text(text = stringResource(R.string.cancel))
-                }
-            },
 			title = { Text(text = stringResource(R.string.delete_tunnel)) },
-            text = { Text(text = stringResource(R.string.delete_tunnel_message)) },
+			body = { Text(text = stringResource(R.string.delete_tunnel_message)) },
+			confirmText = { Text(text = stringResource(R.string.yes)) },
 		)
 	}
 
 	fun onTunnelToggle(checked: Boolean, tunnel: TunnelConfig) {
-        if (appViewModel.isRequiredPermissionGranted()) {
-            if (checked) viewModel.onTunnelStart(tunnel, context) else viewModel.onTunnelStop(
-                context,
+		if (checked) {
+			if (uiState.settings.isKernelEnabled) {
+				context.startTunnelBackground(tunnel.id)
+			} else {
+				viewModel.onTunnelStart(tunnel)
+			}
+		} else {
+			viewModel.onTunnelStop(
+				tunnel,
 			)
 		}
 	}
@@ -274,159 +234,26 @@ fun MainScreen(
 					},
 				)
 			}
-
 		},
 		floatingActionButtonPosition = FabPosition.End,
 		floatingActionButton = {
-            AnimatedVisibility(
-                visible = isVisible.value,
-                enter = slideInVertically(initialOffsetY = { it * 2 }),
-                exit = slideOutVertically(targetOffsetY = { it * 2 }),
-                modifier = Modifier
-                    .focusRequester(focusRequester)
-                    .focusGroup(),
-            ) {
-                val secondaryColor = MaterialTheme.colorScheme.secondary
-                val tvFobColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-                val fobColor =
-                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) tvFobColor else secondaryColor
-                val fobIconColor =
-                    if (WireGuardAutoTunnel.isRunningOnAndroidTv()) Color.White else MaterialTheme.colorScheme.background
-                MultiFloatingActionButton(
-                    fabIcon = FabIcon(
-                        iconRes = R.drawable.add,
-                        iconResAfterRotate = R.drawable.close,
-                        iconRotate = 180f,
-                    ),
-                    fabOption = FabOption(
-                        iconTint = fobIconColor,
-                        backgroundTint = fobColor,
-                    ),
-                    itemsMultiFab = listOf(
-                        MultiFabItem(
-                            label = {
-                                Text(
-                                    stringResource(id = R.string.amnezia),
-                                    color = Color.White,
-                                    textAlign = TextAlign.Center,
-                                    modifier = Modifier.padding(end = 10.dp),
-                                )
-                            },
-                            modifier = Modifier
-                                .size(40.dp),
-                            icon = R.drawable.add,
-                            value = ConfigType.AMNEZIA.name,
-                            miniFabOption = FabOption(
-                                backgroundTint = fobColor,
-                                fobIconColor,
-                            ),
-                        ),
-                        MultiFabItem(
-                            label = {
-                                Text(
-                                    stringResource(id = R.string.wireguard),
-                                    color = Color.White,
-                                    textAlign = TextAlign.Center,
-                                    modifier = Modifier.padding(end = 10.dp),
-                                )
-                            },
-                            icon = R.drawable.add,
-                            value = ConfigType.WIREGUARD.name,
-                            miniFabOption = FabOption(
-                                backgroundTint = fobColor,
-                                fobIconColor,
-                            ),
-                        ),
-                    ),
-                    onFabItemClicked = {
+			ScrollDismissMultiFab(R.drawable.add, focusRequester, isVisible = isVisible.value, onFabItemClicked = {
 				showBottomSheet = true
 				configType = ConfigType.valueOf(it.value)
-                    },
-                    shape = RoundedCornerShape(16.dp),
-                )
-            }
+			})
 		},
 	) {
-        if (showBottomSheet) {
-            ModalBottomSheet(
-                onDismissRequest = {
-                    showBottomSheet = false
-
-                },
-                sheetState = sheetState,
-            ) {
-                // Sheet content
-                Row(
-                    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()) {
-                    HorizontalDivider()
-                    Row(
-                        modifier =
-                        Modifier
-                            .fillMaxWidth()
-                            .clickable {
-                                scope.launch {
-                                    showBottomSheet = false
-                                    launchQrScanner()
-                                }
-                            }
-                            .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),
-                        )
-                    }
-                }
-                HorizontalDivider()
-                Row(
-                    modifier =
-                    Modifier
-                        .fillMaxWidth()
-                        .clickable {
-                            showBottomSheet = false
+		TunnelImportSheet(
+			showBottomSheet,
+			onDismiss = { showBottomSheet = false },
+			onFileClick = { tunnelFileImportResultLauncher.launch(Constants.ALLOWED_FILE_TYPES) },
+			onQrClick = { launchQrScanner() },
+			onManualImportClick = {
 				navController.navigate(
-                                "${Screen.Config.route}/${Constants.MANUAL_TUNNEL_CONFIG_ID}?configType=${configType}",
+					"${Screen.Config.route}/${Constants.MANUAL_TUNNEL_CONFIG_ID}?configType=$configType",
 				)
-                        }
-                        .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),
-                    )
-                }
-            }
-        }
-
 		LazyColumn(
 			horizontalAlignment = Alignment.Start,
 			verticalArrangement = Arrangement.Top,
@@ -440,98 +267,73 @@ fun MainScreen(
 			reverseLayout = false,
 			flingBehavior = ScrollableDefaults.flingBehavior(),
 		) {
+			if (uiState.tunnels.isEmpty()) {
 				item {
-                AnimatedVisibility(
-                    uiState.tunnels.isEmpty(), exit = fadeOut(), enter = fadeIn(),
-                ) {
-                    Column(
-                        horizontalAlignment = Alignment.CenterHorizontally,
-                        verticalArrangement = Arrangement.Center,
-                        modifier = Modifier
-                            .padding(top = 100.dp)
-                            .fillMaxSize(),
-                    ) {
-                        val gettingStarted = buildAnnotatedString {
-                            append(stringResource(id = R.string.see_the))
-                            append(" ")
-                            pushStringAnnotation(
-                                tag = "gettingStarted",
-                                annotation = stringResource(id = R.string.getting_started_url),
-                            )
-                            withStyle(style = SpanStyle(color = MaterialTheme.colorScheme.primary)) {
-                                append(stringResource(id = R.string.getting_started_guide))
-                            }
-                            pop()
-                            append(" ")
-                            append(stringResource(R.string.unsure_how))
-                            append(".")
-                        }
-                        Text(
-                            text = stringResource(R.string.no_tunnels),
-                            fontStyle = FontStyle.Italic,
-                        )
-                        ClickableText(
-                            modifier = Modifier
-                                .padding(vertical = 10.dp, horizontal = 24.dp),
-                            text = gettingStarted,
-                            style = MaterialTheme.typography.bodyMedium.copy(
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                textAlign = TextAlign.Center,
-                            ),
-                        ) {
-                            gettingStarted.getStringAnnotations(tag = "gettingStarted", it, it)
-                                .firstOrNull()?.let { annotation ->
-                                    appViewModel.openWebPage(annotation.item, context)
-                                }
-                        }
-                    }
+					GettingStartedLabel(onClick = { context.openWebUrl(it) })
 				}
 			}
 			item {
 				if (uiState.settings.isAutoTunnelEnabled) {
-                    val autoTunnelingLabel = buildAnnotatedString {
+					val itemFocusRequester = remember { FocusRequester() }
+					val autoTunnelingLabel =
+						buildAnnotatedString {
 							append(stringResource(id = R.string.auto_tunneling))
 							append(": ")
-                        if (uiState.settings.isAutoTunnelPaused) append(
+							if (uiState.settings.isAutoTunnelPaused) {
+								append(
 									stringResource(id = R.string.paused),
-                        ) else append(
+								)
+							} else {
+								append(
 									stringResource(id = R.string.active),
 								)
 							}
+						}
 					RowListItem(
 						icon = {
 							val icon = Icons.Rounded.Bolt
 							Icon(
 								icon,
 								icon.name,
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.padding(end = 8.5.dp)
 									.size(25.dp),
 								tint =
-                                if (uiState.settings.isAutoTunnelPaused) Color.Gray
-                                else mint,
+								if (uiState.settings.isAutoTunnelPaused) {
+									Color.Gray
+								} else {
+									mint
+								},
 							)
 						},
 						text = autoTunnelingLabel.text,
 						rowButton = {
 							if (uiState.settings.isAutoTunnelPaused) {
 								TextButton(
+									modifier = Modifier.focusRequester(itemFocusRequester),
 									onClick = { viewModel.resumeAutoTunneling() },
 								) {
 									Text(stringResource(id = R.string.resume))
 								}
 							} else {
 								TextButton(
+									modifier = Modifier.focusRequester(itemFocusRequester),
 									onClick = { viewModel.pauseAutoTunneling() },
 								) {
 									Text(stringResource(id = R.string.pause))
 								}
 							}
 						},
-                        onClick = {},
+						onClick = {
+							if (context.isRunningOnTv()) {
+								itemFocusRequester.requestFocus()
+							}
+						},
 						onHold = {},
 						expanded = false,
 						statistics = null,
+						focusRequester = focusRequester,
 					)
 				}
 			}
@@ -539,10 +341,11 @@ fun MainScreen(
 				uiState.tunnels,
 				key = { tunnel -> tunnel.id },
 			) { tunnel ->
+				val isActive = uiState.tunnels.any { it.id == tunnel.id && it.isActive }
 				val leadingIconColor =
-                    (if (
-                        uiState.vpnState.tunnelConfig?.name == tunnel.name &&
-                        uiState.vpnState.status == TunnelState.UP
+					(
+						if (
+							isActive
 						) {
 							uiState.vpnState.statistics
 								?.mapPeerStats()
@@ -561,12 +364,15 @@ fun MainScreen(
 								}
 						} else {
 							Color.Gray
-                    })
+						}
+						)
+				val itemFocusRequester = remember { FocusRequester() }
 				val expanded = remember { mutableStateOf(false) }
 				RowListItem(
 					icon = {
 						val circleIcon = Icons.Rounded.Circle
-                        val icon = if (tunnel.isPrimaryTunnel) {
+						val icon =
+							if (tunnel.isPrimaryTunnel) {
 								Icons.Rounded.Star
 							} else if (tunnel.isMobileDataTunnel) {
 								Icons.Rounded.Smartphone
@@ -577,7 +383,8 @@ fun MainScreen(
 							icon,
 							icon.name,
 							tint = leadingIconColor,
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.padding(
 									end = if (icon == circleIcon) 12.5.dp else 10.dp,
 									start = if (icon == circleIcon) 2.5.dp else 0.dp,
@@ -591,31 +398,33 @@ fun MainScreen(
 							(uiState.vpnState.status == TunnelState.UP) &&
 							(tunnel.name == uiState.vpnState.tunnelConfig?.name)
 						) {
-                            appViewModel.showSnackbarMessage(context.getString(R.string.turn_off_tunnel))
+							appViewModel.showSnackbarMessage(
+								context.getString(R.string.turn_off_tunnel),
+							)
 							return@RowListItem
 						}
 						haptic.performHapticFeedback(HapticFeedbackType.LongPress)
 						selectedTunnel = tunnel
 					},
 					onClick = {
-                        if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+						if (!context.isRunningOnTv()) {
 							if (
-                                uiState.vpnState.status == TunnelState.UP &&
-                                (uiState.vpnState.tunnelConfig?.name == tunnel.name)
+								isActive
 							) {
 								expanded.value = !expanded.value
 							}
 						} else {
 							selectedTunnel = tunnel
-                            focusRequester.requestFocus()
+							itemFocusRequester.requestFocus()
 						}
 					},
 					statistics = uiState.vpnState.statistics,
 					expanded = expanded.value,
+					focusRequester = focusRequester,
 					rowButton = {
 						if (
 							tunnel.id == selectedTunnel?.id &&
-                            !WireGuardAutoTunnel.isRunningOnAndroidTv()
+							!context.isRunningOnTv()
 						) {
 							Row {
 								IconButton(
@@ -656,29 +465,23 @@ fun MainScreen(
 								}
 							}
 						} else {
-                            val checked by remember {
-                                derivedStateOf {
-                                    (uiState.vpnState.status == TunnelState.UP &&
-                                        tunnel.name == uiState.vpnState.tunnelConfig?.name)
-                                }
-                            }
-                            if (!checked) expanded.value = false
-
+							if (!isActive) expanded.value = false
 							@Composable
-                            fun TunnelSwitch() =
-                                Switch(
-                                    modifier = Modifier.focusRequester(focusRequester),
-                                    checked = checked,
+							fun TunnelSwitch() = Switch(
+								modifier = Modifier.focusRequester(itemFocusRequester),
+								checked = isActive,
 								onCheckedChange = { checked ->
 									if (!checked) expanded.value = false
+									val intent = if (uiState.settings.isKernelEnabled) null else GoBackend.VpnService.prepare(context)
+									if (intent != null) return@Switch vpnActivityResultState.launch(intent)
 									onTunnelToggle(checked, tunnel)
 								},
 							)
-                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+							if (context.isRunningOnTv()) {
 								Row {
 									IconButton(
 										onClick = {
-                                            if (uiState.settings.isAutoTunnelEnabled) {
+											if (uiState.settings.isAutoTunnelEnabled && !uiState.settings.isAutoTunnelPaused) {
 												appViewModel.showSnackbarMessage(
 													context.getString(R.string.turn_off_auto),
 												)

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

@@ -2,11 +2,11 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.main
 
 import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnState
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 
 data class MainUiState(
 	val settings: Settings = Settings(),
 	val tunnels: TunnelConfigs = emptyList(),
 	val vpnState: VpnState = VpnState(),
-    val loading: Boolean = true
+	val loading: Boolean = true,
 )

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

@@ -7,17 +7,16 @@ import android.provider.OpenableColumns
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wireguard.config.Config
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
-import com.zaneschepke.wireguardautotunnel.util.toWgQuickString
+import com.zaneschepke.wireguardautotunnel.util.extensions.toWgQuickString
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.SharingStarted
@@ -36,15 +35,14 @@ class MainViewModel
 constructor(
 	private val appDataRepository: AppDataRepository,
 	private val serviceManager: ServiceManager,
-    val vpnService: VpnService,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+	val tunnelService: TunnelService,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : ViewModel() {
-
 	val uiState =
 		combine(
 			appDataRepository.settings.getSettingsFlow(),
 			appDataRepository.tunnels.getTunnelConfigsFlow(),
-            vpnService.vpnState,
+			tunnelService.vpnState,
 		) { settings, tunnels, vpnState ->
 			MainUiState(settings, tunnels, vpnState, false)
 		}
@@ -67,7 +65,6 @@ constructor(
 				resetTunnelSetting(settings)
 			}
 			appDataRepository.tunnels.delete(tunnel)
-            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
 		}
 	}
 
@@ -80,21 +77,14 @@ constructor(
 		)
 	}
 
-    fun onTunnelStart(tunnelConfig: TunnelConfig, context: Context) =
-        viewModelScope.launch {
-            Timber.d("On start called!")
-            serviceManager.startVpnService(
-                context,
-                tunnelConfig.id,
-                isManualStart = true,
-            )
+	fun onTunnelStart(tunnelConfig: TunnelConfig) = viewModelScope.launch {
+		Timber.i("Starting tunnel ${tunnelConfig.name}")
+		tunnelService.startTunnel(tunnelConfig)
 	}
 
-
-    fun onTunnelStop(context: Context) =
-        viewModelScope.launch {
+	fun onTunnelStop(tunnel: TunnelConfig) = viewModelScope.launch {
 		Timber.i("Stopping active tunnel")
-            serviceManager.stopVpnService(context, isManualStop = true)
+		tunnelService.stopTunnel(tunnel)
 	}
 
 	private fun validateConfigString(config: String, configType: ConfigType) {
@@ -139,16 +129,26 @@ constructor(
 		return withContext(ioDispatcher) {
 			try {
 				validateConfigString(result, configType)
-                val tunnelName = makeTunnelNameUnique(generateQrCodeTunnelName(result, configType))
-                val tunnelConfig = when (configType) {
+				val tunnelName =
+					makeTunnelNameUnique(generateQrCodeTunnelName(result, configType))
+				val tunnelConfig =
+					when (configType) {
 						ConfigType.AMNEZIA -> {
 							TunnelConfig(
-                            name = tunnelName, amQuick = result,
-                            wgQuick = TunnelConfig.configFromAmQuick(result).toWgQuickString(),
+								name = tunnelName,
+								amQuick = result,
+								wgQuick =
+								TunnelConfig.configFromAmQuick(
+									result,
+								).toWgQuickString(),
 							)
 						}
 
-                    ConfigType.WIREGUARD -> TunnelConfig(name = tunnelName, wgQuick = result)
+						ConfigType.WIREGUARD ->
+							TunnelConfig(
+								name = tunnelName,
+								wgQuick = result,
+							)
 					}
 				addTunnel(tunnelConfig)
 				Result.success(Unit)
@@ -165,29 +165,26 @@ constructor(
 			var tunnelName = name
 			var num = 1
 			while (tunnels.any { it.name == tunnelName }) {
-                tunnelName = name + "(${num})"
+				tunnelName = "$name($num)"
 				num++
 			}
 			tunnelName
 		}
 	}
 
-    private fun saveTunnelConfigFromStream(
-        stream: InputStream,
-        fileName: String,
-        type: ConfigType
-    ) {
+	private fun saveTunnelConfigFromStream(stream: InputStream, fileName: String, type: ConfigType) {
 		var amQuick: String? = null
-        val wgQuick = stream.use {
+		val wgQuick =
+			stream.use {
 				when (type) {
 					ConfigType.AMNEZIA -> {
 						val config = org.amnezia.awg.config.Config.parse(it)
-                    amQuick = config.toAwgQuickString()
+						amQuick = config.toAwgQuickString(true)
 						config.toWgQuickString()
 					}
 
 					ConfigType.WIREGUARD -> {
-                    Config.parse(it).toWgQuickString()
+						Config.parse(it).toWgQuickString(true)
 					}
 				}
 			}
@@ -207,11 +204,7 @@ constructor(
 		return context.applicationContext.contentResolver.openInputStream(uri)
 	}
 
-    suspend fun onTunnelFileSelected(
-        uri: Uri,
-        configType: ConfigType,
-        context: Context
-    ): Result<Unit> {
+	suspend fun onTunnelFileSelected(uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
 		return withContext(ioDispatcher) {
 			try {
 				if (isValidUriContentScheme(uri)) {
@@ -220,7 +213,8 @@ constructor(
 						Constants.CONF_FILE_EXTENSION ->
 							saveTunnelFromConfUri(fileName, uri, configType, context)
 
-                        Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(
+						Constants.ZIP_FILE_EXTENSION ->
+							saveTunnelsFromZipUri(
 								uri,
 								configType,
 								context,
@@ -238,11 +232,7 @@ constructor(
 		}
 	}
 
-    private suspend fun saveTunnelsFromZipUri(
-        uri: Uri,
-        configType: ConfigType,
-        context: Context
-    ): Result<Unit> {
+	private suspend fun saveTunnelsFromZipUri(uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
 		return withContext(ioDispatcher) {
 			ZipInputStream(getInputStreamFromUri(uri, context)).use { zip ->
 				generateSequence { zip.nextEntry }
@@ -258,13 +248,16 @@ constructor(
 								val wgQuick =
 									when (configType) {
 										ConfigType.AMNEZIA -> {
-                                            val config = org.amnezia.awg.config.Config.parse(zip)
-                                            amQuick = config.toAwgQuickString()
+											val config =
+												org.amnezia.awg.config.Config.parse(
+													zip,
+												)
+											amQuick = config.toAwgQuickString(true)
 											config.toWgQuickString()
 										}
 
 										ConfigType.WIREGUARD -> {
-                                            Config.parse(zip).toWgQuickString()
+											Config.parse(zip).toWgQuickString(true)
 										}
 									}
 								addTunnel(
@@ -285,12 +278,7 @@ constructor(
 		}
 	}
 
-    private suspend fun saveTunnelFromConfUri(
-        name: String,
-        uri: Uri,
-        configType: ConfigType,
-        context: Context
-    ): Result<Unit> {
+	private suspend fun saveTunnelFromConfUri(name: String, uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
 		return withContext(ioDispatcher) {
 			val stream = getInputStreamFromUri(uri, context)
 			return@withContext if (stream != null) {
@@ -307,21 +295,19 @@ constructor(
 	}
 
 	private fun addTunnel(tunnelConfig: TunnelConfig) = viewModelScope.launch {
-        val firstTunnel = appDataRepository.tunnels.count() == 0
 		saveTunnel(tunnelConfig)
-        if (firstTunnel) WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
 	}
 
-    fun pauseAutoTunneling() =
-        viewModelScope.launch {
-            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = true))
-            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
+	fun pauseAutoTunneling() = viewModelScope.launch {
+		appDataRepository.settings.save(
+			uiState.value.settings.copy(isAutoTunnelPaused = true),
+		)
 	}
 
-    fun resumeAutoTunneling() =
-        viewModelScope.launch {
-            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = false))
-            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
+	fun resumeAutoTunneling() = viewModelScope.launch {
+		appDataRepository.settings.save(
+			uiState.value.settings.copy(isAutoTunnelPaused = false),
+		)
 	}
 
 	private fun saveTunnel(tunnelConfig: TunnelConfig) = viewModelScope.launch {
@@ -349,8 +335,12 @@ constructor(
 			val index = getDisplayNameColumnIndex(cursor)
 			if (index != null) {
 				cursor.getString(index)
-            } else null
-        } else null
+			} else {
+				null
+			}
+		} else {
+			null
+		}
 	}
 
 	private fun isValidUriContentScheme(uri: Uri): Boolean {
@@ -374,9 +364,7 @@ constructor(
 		}
 	}
 
-    private fun saveSettings(settings: Settings) =
-        viewModelScope.launch { appDataRepository.settings.save(settings) }
-
+	private fun saveSettings(settings: Settings) = viewModelScope.launch { appDataRepository.settings.save(settings) }
 
 	fun onCopyTunnel(tunnel: TunnelConfig?) = viewModelScope.launch {
 		tunnel?.let {

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

@@ -0,0 +1,71 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.text.ClickableText
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
+
+@Composable
+fun GettingStartedLabel(onClick: (url: String) -> Unit) {
+	Column(
+		horizontalAlignment = Alignment.CenterHorizontally,
+		verticalArrangement = Arrangement.Center,
+		modifier =
+		Modifier
+			.padding(top = 100.dp)
+			.fillMaxSize(),
+	) {
+		val gettingStarted =
+			buildAnnotatedString {
+				append(stringResource(id = R.string.see_the))
+				append(" ")
+				pushStringAnnotation(
+					tag = "gettingStarted",
+					annotation = stringResource(id = R.string.getting_started_url),
+				)
+				withStyle(
+					style = SpanStyle(color = MaterialTheme.colorScheme.primary),
+				) {
+					append(stringResource(id = R.string.getting_started_guide))
+				}
+				pop()
+				append(" ")
+				append(stringResource(R.string.unsure_how))
+				append(".")
+			}
+		Text(
+			text = stringResource(R.string.no_tunnels),
+			fontStyle = FontStyle.Italic,
+		)
+		ClickableText(
+			modifier =
+			Modifier
+				.padding(vertical = 10.dp, horizontal = 24.dp),
+			text = gettingStarted,
+			style =
+			MaterialTheme.typography.bodyMedium.copy(
+				color = MaterialTheme.colorScheme.onSurfaceVariant,
+				textAlign = TextAlign.Center,
+			),
+		) {
+			gettingStarted.getStringAnnotations(tag = "gettingStarted", it, it)
+				.firstOrNull()?.let { annotation ->
+					onClick(annotation.item)
+				}
+		}
+	}
+}

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

@@ -0,0 +1,108 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
+
+import androidx.annotation.DrawableRes
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import com.iamageo.multifablibrary.FabIcon
+import com.iamageo.multifablibrary.FabOption
+import com.iamageo.multifablibrary.MultiFabItem
+import com.iamageo.multifablibrary.MultiFloatingActionButton
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
+
+@Composable
+fun ScrollDismissMultiFab(
+	@DrawableRes res: Int,
+	focusRequester: FocusRequester,
+	isVisible: Boolean,
+	onFabItemClicked: (fabItem: MultiFabItem) -> Unit,
+) {
+	// Nested scroll for control FAB
+
+	val context = LocalContext.current
+
+	AnimatedVisibility(
+		visible = isVisible,
+		enter = slideInVertically(initialOffsetY = { it * 2 }),
+		exit = slideOutVertically(targetOffsetY = { it * 2 }),
+		modifier =
+		Modifier
+			.focusRequester(focusRequester)
+			.focusGroup(),
+	) {
+		val fobColor = MaterialTheme.colorScheme.secondary
+		val fobIconColor = MaterialTheme.colorScheme.background
+		MultiFloatingActionButton(
+			fabIcon =
+			FabIcon(
+				iconRes = res,
+				iconResAfterRotate = R.drawable.close,
+				iconRotate = 180f,
+			),
+			fabOption =
+			FabOption(
+				iconTint = fobIconColor,
+				backgroundTint = fobColor,
+			),
+			itemsMultiFab =
+			listOf(
+				MultiFabItem(
+					label = {
+						Text(
+							stringResource(id = R.string.amnezia),
+							color = MaterialTheme.colorScheme.onBackground,
+							textAlign = TextAlign.Center,
+							modifier = Modifier.padding(end = 10.dp),
+						)
+					},
+					modifier =
+					Modifier
+						.size(40.dp),
+					icon = res,
+					value = ConfigType.AMNEZIA.name,
+					miniFabOption =
+					FabOption(
+						backgroundTint = fobColor,
+						fobIconColor,
+					),
+				),
+				MultiFabItem(
+					label = {
+						Text(
+							stringResource(id = R.string.wireguard),
+							color = MaterialTheme.colorScheme.onBackground,
+							textAlign = TextAlign.Center,
+							modifier = Modifier.padding(end = 10.dp),
+						)
+					},
+					icon = res,
+					value = ConfigType.WIREGUARD.name,
+					miniFabOption =
+					FabOption(
+						backgroundTint = fobColor,
+						fobIconColor,
+					),
+				),
+			),
+			onFabItemClicked = {
+				onFabItemClicked(it)
+			},
+			shape = RoundedCornerShape(16.dp),
+		)
+	}
+}

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

@@ -0,0 +1,104 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+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.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Text
+import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun TunnelImportSheet(show: Boolean, onDismiss: () -> Unit, onFileClick: () -> Unit, onQrClick: () -> Unit, onManualImportClick: () -> Unit) {
+	val sheetState = rememberModalBottomSheetState()
+
+	val context = LocalContext.current
+	if (show) {
+		ModalBottomSheet(
+			onDismissRequest = {
+				onDismiss()
+			},
+			sheetState = sheetState,
+		) {
+			Row(
+				modifier =
+				Modifier
+					.fillMaxWidth()
+					.clickable {
+						onDismiss()
+						onFileClick()
+					}
+					.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 (!context.isRunningOnTv()) {
+				HorizontalDivider()
+				Row(
+					modifier =
+					Modifier
+						.fillMaxWidth()
+						.clickable {
+							onDismiss()
+							onQrClick()
+						}
+						.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),
+					)
+				}
+			}
+			HorizontalDivider()
+			Row(
+				modifier =
+				Modifier
+					.fillMaxWidth()
+					.clickable {
+						onDismiss()
+						onManualImportClick()
+					}
+					.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),
+				)
+			}
+		}
+	}
+}

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

@@ -0,0 +1,49 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.main.components
+
+import androidx.compose.foundation.text.ClickableText
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.withStyle
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
+import com.zaneschepke.wireguardautotunnel.util.extensions.launchVpnSettings
+
+@Composable
+fun VpnDeniedDialog(show: Boolean, onDismiss: () -> Unit) {
+	val context = LocalContext.current
+	if (show) {
+		val alwaysOnDescription = buildAnnotatedString {
+			append(stringResource(R.string.always_on_message))
+			append(" ")
+			pushStringAnnotation(tag = "vpnSettings", annotation = "")
+			withStyle(style = SpanStyle(color = MaterialTheme.colorScheme.primary)) {
+				append(stringResource(id = R.string.vpn_settings))
+			}
+			pop()
+			append(" ")
+			append(stringResource(R.string.always_on_message2))
+			append(".")
+		}
+		InfoDialog(
+			onDismiss = { onDismiss() },
+			onAttest = { onDismiss() },
+			title = { Text(text = stringResource(R.string.vpn_denied_dialog_title)) },
+			body = {
+				ClickableText(
+					text = alwaysOnDescription,
+					style = MaterialTheme.typography.bodyMedium.copy(color = MaterialTheme.colorScheme.outline),
+				) {
+					alwaysOnDescription.getStringAnnotations(tag = "vpnSettings", it, it).firstOrNull()?.let {
+						context.launchVpnSettings()
+					}
+				}
+			},
+			confirmText = { Text(text = stringResource(R.string.okay)) },
+		)
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/options/OptionsScreen.kt

@@ -1,11 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.options
 
 import android.annotation.SuppressLint
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
@@ -16,7 +12,6 @@ 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
@@ -32,7 +27,6 @@ import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -44,32 +38,27 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
-import com.iamageo.multifablibrary.FabIcon
-import com.iamageo.multifablibrary.FabOption
-import com.iamageo.multifablibrary.MultiFabItem
-import com.iamageo.multifablibrary.MultiFloatingActionButton
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.ClickableIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationToggle
 import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.ScrollDismissMultiFab
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.getMessage
+import com.zaneschepke.wireguardautotunnel.util.extensions.getMessage
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
@@ -81,7 +70,7 @@ fun OptionsScreen(
 	navController: NavController,
 	appViewModel: AppViewModel,
 	focusRequester: FocusRequester,
-    tunnelId: String
+	tunnelId: String,
 ) {
 	val scrollState = rememberScrollState()
 	val uiState by optionsViewModel.uiState.collectAsStateWithLifecycle()
@@ -97,11 +86,16 @@ fun OptionsScreen(
 
 	LaunchedEffect(Unit) {
 		optionsViewModel.init(tunnelId)
-        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+		if (context.isRunningOnTv()) {
+			delay(Constants.FOCUS_REQUEST_DELAY)
+			kotlin.runCatching {
+				focusRequester.requestFocus()
+			}.onFailure {
 				delay(Constants.FOCUS_REQUEST_DELAY)
 				focusRequester.requestFocus()
 			}
 		}
+	}
 
 	fun saveTrustedSSID() {
 		if (currentText.isNotEmpty()) {
@@ -117,75 +111,12 @@ fun OptionsScreen(
 
 	Scaffold(
 		floatingActionButton = {
-            val secondaryColor = MaterialTheme.colorScheme.secondary
-            val tvFobColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-            val fobColor =
-                if (WireGuardAutoTunnel.isRunningOnAndroidTv()) tvFobColor else secondaryColor
-            val fobIconColor =
-                if (WireGuardAutoTunnel.isRunningOnAndroidTv()) Color.White else MaterialTheme.colorScheme.background
-            AnimatedVisibility(
-                visible = true,
-                enter = slideInVertically(initialOffsetY = { it * 2 }),
-                exit = slideOutVertically(targetOffsetY = { it * 2 }),
-                modifier = Modifier
-                    .focusRequester(focusRequester)
-                    .focusGroup(),
-            ) {
-                MultiFloatingActionButton(
-                    fabIcon = FabIcon(
-                        iconRes = R.drawable.edit,
-                        iconResAfterRotate = R.drawable.close,
-                        iconRotate = 180f,
-                    ),
-                    fabOption = FabOption(
-                        iconTint = fobIconColor,
-                        backgroundTint = fobColor,
-                    ),
-                    itemsMultiFab = listOf(
-                        MultiFabItem(
-                            label = {
-                                Text(
-                                    stringResource(id = R.string.amnezia),
-                                    color = Color.White,
-                                    textAlign = TextAlign.Center,
-                                    modifier = Modifier.padding(end = 10.dp),
-                                )
-                            },
-                            modifier = Modifier
-                                .size(40.dp),
-                            icon = R.drawable.edit,
-                            value = ConfigType.AMNEZIA.name,
-                            miniFabOption = FabOption(
-                                backgroundTint = fobColor,
-                                fobIconColor,
-                            ),
-                        ),
-                        MultiFabItem(
-                            label = {
-                                Text(
-                                    stringResource(id = R.string.wireguard),
-                                    color = Color.White,
-                                    textAlign = TextAlign.Center,
-                                    modifier = Modifier.padding(end = 10.dp),
-                                )
-                            },
-                            icon = R.drawable.edit,
-                            value = ConfigType.WIREGUARD.name,
-                            miniFabOption = FabOption(
-                                backgroundTint = fobColor,
-                                fobIconColor,
-                            ),
-                        ),
-                    ),
-                    onFabItemClicked = {
+			ScrollDismissMultiFab(R.drawable.edit, focusRequester, isVisible = true, onFabItemClicked = {
 				val configType = ConfigType.valueOf(it.value)
 				navController.navigate(
-                            "${Screen.Config.route}/${tunnelId}?configType=${configType.name}",
+					"${Screen.Config.route}/$tunnelId?configType=${configType.name}",
 				)
-                    },
-                    shape = RoundedCornerShape(16.dp),
-                )
-            }
+			})
 		},
 	) {
 		Column(
@@ -208,7 +139,8 @@ fun OptionsScreen(
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
 				modifier =
-                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+				(
+					if (context.isRunningOnTv()) {
 						Modifier
 							.height(IntrinsicSize.Min)
 							.fillMaxWidth(fillMaxWidth)
@@ -217,7 +149,8 @@ fun OptionsScreen(
 						Modifier
 							.fillMaxWidth(fillMaxWidth)
 							.padding(top = 20.dp)
-                })
+					}
+					)
 					.padding(bottom = 10.dp),
 			) {
 				Column(
@@ -233,7 +166,8 @@ fun OptionsScreen(
 						stringResource(R.string.set_primary_tunnel),
 						enabled = true,
 						checked = uiState.isDefaultTunnel,
-                        modifier = Modifier
+						modifier =
+						Modifier
 							.focusRequester(focusRequester),
 						padding = screenPadding,
 						onCheckChanged = { optionsViewModel.onTogglePrimaryTunnel() },
@@ -246,7 +180,8 @@ fun OptionsScreen(
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
 				modifier =
-                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+				(
+					if (context.isRunningOnTv()) {
 						Modifier
 							.height(IntrinsicSize.Min)
 							.fillMaxWidth(fillMaxWidth)
@@ -255,7 +190,8 @@ fun OptionsScreen(
 						Modifier
 							.fillMaxWidth(fillMaxWidth)
 							.padding(top = 20.dp)
-                })
+					}
+					)
 					.padding(bottom = 10.dp),
 			) {
 				Column(
@@ -276,7 +212,8 @@ fun OptionsScreen(
 					)
 					Column {
 						FlowRow(
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.padding(screenPadding)
 								.fillMaxWidth(),
 							horizontalArrangement = Arrangement.spacedBy(5.dp),
@@ -284,15 +221,14 @@ fun OptionsScreen(
 							uiState.tunnel?.tunnelNetworks?.forEach { ssid ->
 								ClickableIconButton(
 									onClick = {
-                                        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+										if (context.isRunningOnTv()) {
 											focusRequester.requestFocus()
 											optionsViewModel.onDeleteRunSSID(ssid)
 										}
 									},
 									onIconClick = {
-                                        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
+										if (context.isRunningOnTv()) focusRequester.requestFocus()
 										optionsViewModel.onDeleteRunSSID(ssid)
-
 									},
 									text = ssid,
 									icon = Icons.Filled.Close,
@@ -303,7 +239,7 @@ fun OptionsScreen(
 								Text(
 									stringResource(R.string.no_wifi_names_configured),
 									fontStyle = FontStyle.Italic,
-                                    color = Color.Gray,
+									color = MaterialTheme.colorScheme.onSurface,
 								)
 							}
 						}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/options/OptionsUiState.kt

@@ -5,5 +5,5 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 data class OptionsUiState(
 	val id: String? = null,
 	val tunnel: TunnelConfig? = null,
-    val isDefaultTunnel: Boolean = false
+	val isDefaultTunnel: Boolean = false,
 )

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/screens/options/OptionsViewModel.kt

@@ -3,7 +3,6 @@ package com.zaneschepke.wireguardautotunnel.ui.screens.options
 import androidx.compose.ui.util.fastFirstOrNull
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.util.Constants
@@ -19,14 +18,15 @@ import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 @HiltViewModel
-class OptionsViewModel @Inject
+class OptionsViewModel
+@Inject
 constructor(
-    private val appDataRepository: AppDataRepository
+	private val appDataRepository: AppDataRepository,
 ) : ViewModel() {
-
 	private val _optionState = MutableStateFlow(OptionsUiState())
 
-    val uiState = combine(
+	val uiState =
+		combine(
 			appDataRepository.tunnels.getTunnelConfigsFlow(),
 			_optionState,
 		) { tunnels, optionState ->
@@ -34,7 +34,9 @@ constructor(
 				val tunnelConfig = tunnels.fastFirstOrNull { it.id.toString() == optionState.id }
 				val isPrimaryTunnel = tunnelConfig?.isPrimaryTunnel == true
 				OptionsUiState(optionState.id, tunnelConfig, isPrimaryTunnel)
-        } else OptionsUiState()
+			} else {
+				OptionsUiState()
+			}
 		}.stateIn(
 			viewModelScope,
 			SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
@@ -52,7 +54,8 @@ constructor(
 	fun onDeleteRunSSID(ssid: String) = viewModelScope.launch {
 		uiState.value.tunnel?.let {
 			appDataRepository.tunnels.save(
-                tunnelConfig = it.copy(
+				tunnelConfig =
+				it.copy(
 					tunnelNetworks = (uiState.value.tunnel!!.tunnelNetworks - ssid).toMutableList(),
 				),
 			)
@@ -67,11 +70,13 @@ constructor(
 
 	suspend fun onSaveRunSSID(ssid: String): Result<Unit> {
 		val trimmed = ssid.trim()
-        val tunnelsWithName = withContext(viewModelScope.coroutineContext) {
+		val tunnelsWithName =
+			withContext(viewModelScope.coroutineContext) {
 				appDataRepository.tunnels.findByTunnelNetworksName(trimmed)
 			}
 		return if (uiState.value.tunnel?.tunnelNetworks?.contains(trimmed) != true &&
-            tunnelsWithName.isEmpty()) {
+			tunnelsWithName.isEmpty()
+		) {
 			uiState.value.tunnel?.tunnelNetworks?.add(trimmed)
 			saveTunnel(uiState.value.tunnel)
 			Result.success(Unit)
@@ -84,7 +89,9 @@ constructor(
 		uiState.value.tunnel?.let {
 			if (it.isMobileDataTunnel) {
 				appDataRepository.tunnels.updateMobileDataTunnel(null)
-            } else appDataRepository.tunnels.updateMobileDataTunnel(it)
+			} else {
+				appDataRepository.tunnels.updateMobileDataTunnel(it)
+			}
 		}
 	}
 
@@ -96,7 +103,6 @@ constructor(
 					false -> uiState.value.tunnel
 				},
 			)
-            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
 		}
 	}
 }

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

@@ -7,10 +7,10 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import xyz.teamgravity.pin_lock_compose.PinLock
 
 @Composable
@@ -19,15 +19,20 @@ fun PinLockScreen(navController: NavController, appViewModel: AppViewModel) {
 	PinLock(
 		title = { pinExists ->
 			Text(
-                text = if (pinExists) stringResource(id = R.string.enter_pin) else stringResource(
+				text =
+				if (pinExists) {
+					stringResource(id = R.string.enter_pin)
+				} else {
+					stringResource(
 						id = R.string.create_pin,
-                ),
+					)
+				},
 			)
 		},
 		color = MaterialTheme.colorScheme.surface,
 		onPinCorrect = {
 			// pin is correct, navigate or hide pin lock
-            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+			if (context.isRunningOnTv()) {
 				navController.navigate(Screen.Main.route)
 			} else {
 				val isPopped = navController.popBackStack()
@@ -35,7 +40,6 @@ fun PinLockScreen(navController: NavController, appViewModel: AppViewModel) {
 					navController.navigate(Screen.Main.route)
 				}
 			}
-
 		},
 		onPinIncorrect = {
 			// pin is incorrect, show error
@@ -48,6 +52,7 @@ fun PinLockScreen(navController: NavController, appViewModel: AppViewModel) {
 			appViewModel.showSnackbarMessage(
 				StringValue.StringResource(R.string.pin_created).asString(context),
 			)
+			appViewModel.onPinLockEnabled()
 		},
 	)
 }

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

@@ -8,11 +8,10 @@ import android.net.Uri
 import android.os.Build
 import android.os.PowerManager
 import android.provider.Settings
-import android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.ActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.animation.AnimatedVisibility
+import androidx.appcompat.app.AppCompatActivity.RESULT_OK
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
@@ -25,7 +24,6 @@ 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
@@ -34,8 +32,6 @@ import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.outlined.Add
-import androidx.compose.material.icons.rounded.LocationOff
-import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -55,16 +51,13 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.text.style.TextAlign
 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
@@ -73,7 +66,6 @@ import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
@@ -81,10 +73,16 @@ 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.text.SectionTitle
-import com.zaneschepke.wireguardautotunnel.util.getMessage
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.components.VpnDeniedDialog
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.BackgroundLocationDialog
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.BackgroundLocationDisclosure
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.components.LocationServicesDialog
+import com.zaneschepke.wireguardautotunnel.util.extensions.getMessage
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
+import com.zaneschepke.wireguardautotunnel.util.extensions.launchAppSettings
+import com.zaneschepke.wireguardautotunnel.util.extensions.showToast
 import kotlinx.coroutines.launch
-import timber.log.Timber
-import java.io.File
+import xyz.teamgravity.pin_lock_compose.PinManager
 
 @OptIn(
 	ExperimentalPermissionsApi::class,
@@ -102,7 +100,6 @@ fun SettingsScreen(
 	val scope = rememberCoroutineScope()
 	val scrollState = rememberScrollState()
 	val interactionSource = remember { MutableInteractionSource() }
-    //val pinExists = remember { mutableStateOf(PinManager.pinExists()) }
 
 	val uiState by viewModel.uiState.collectAsStateWithLifecycle()
 	val kernelSupport by viewModel.kernelSupport.collectAsStateWithLifecycle()
@@ -110,9 +107,11 @@ fun SettingsScreen(
 	val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
 	var currentText by remember { mutableStateOf("") }
 	var isBackgroundLocationGranted by remember { mutableStateOf(true) }
+	var showVpnPermissionDialog by remember { mutableStateOf(false) }
 	var showLocationServicesAlertDialog by remember { mutableStateOf(false) }
 	var didExportFiles by remember { mutableStateOf(false) }
 	var showAuthPrompt by remember { mutableStateOf(false) }
+	var showLocationDialog by remember { mutableStateOf(false) }
 
 	val screenPadding = 5.dp
 	val fillMaxWidth = .85f
@@ -121,8 +120,17 @@ fun SettingsScreen(
 		viewModel.checkKernelSupport()
 	}
 
+	val notificationPermissionState =
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+			rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS)
+		} else {
+			null
+		}
+
 	val startForResult =
-        rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
+		rememberLauncherForActivityResult(
+			ActivityResultContracts.StartActivityForResult(),
+		) { result: ActivityResult ->
 			if (result.resultCode == Activity.RESULT_OK) {
 				result.data
 				// Handle the Intent
@@ -130,36 +138,18 @@ fun SettingsScreen(
 			viewModel.setBatteryOptimizeDisableShown()
 		}
 
-    fun exportAllConfigs() {
-        try {
-            val wgFiles = uiState.tunnels.map { config ->
-                val file = File(context.cacheDir, "${config.name}-wg.conf")
-                file.outputStream().use {
-                    it.write(config.wgQuick.toByteArray())
-                }
-                file
-            }
-            val amFiles = uiState.tunnels.mapNotNull { config ->
-                if (config.amQuick != TunnelConfig.AM_QUICK_DEFAULT) {
-                    val file = File(context.cacheDir, "${config.name}-am.conf")
-                    file.outputStream().use {
-                        it.write(config.amQuick.toByteArray())
-                    }
-                    file
-                } else null
-            }
-            scope.launch {
-                viewModel.onExportTunnels(wgFiles + amFiles).onFailure {
-                    appViewModel.showSnackbarMessage(it.getMessage(context))
-                }.onSuccess {
-                    didExportFiles = true
-                    appViewModel.showSnackbarMessage(context.getString(R.string.exported_configs_message))
-                }
-            }
-        } catch (e: Exception) {
-            Timber.e(e)
-        }
+	val vpnActivityResultState =
+		rememberLauncherForActivityResult(
+			ActivityResultContracts.StartActivityForResult(),
+			onResult = {
+				val accepted = (it.resultCode == RESULT_OK)
+				if (accepted) {
+					viewModel.onToggleAutoTunnel(context)
+				} else {
+					showVpnPermissionDialog = true
 				}
+			},
+		)
 
 	fun isBatteryOptimizationsDisabled(): Boolean {
 		val pm = context.getSystemService(POWER_SERVICE) as PowerManager
@@ -176,13 +166,20 @@ fun SettingsScreen(
 	}
 
 	fun handleAutoTunnelToggle() {
-        if (uiState.isBatteryOptimizeDisableShown || isBatteryOptimizationsDisabled()) {
-            if (appViewModel.isRequiredPermissionGranted()) {
-                viewModel.onToggleAutoTunnel(context)
+		if (!uiState.isBatteryOptimizeDisableShown || !isBatteryOptimizationsDisabled()) return requestBatteryOptimizationsDisabled()
+		if (notificationPermissionState != null && !notificationPermissionState.status.isGranted) {
+			appViewModel.showSnackbarMessage(
+				context.getString(R.string.notification_permission_required),
+			)
+			return notificationPermissionState.launchPermissionRequest()
 		}
+		val intent = if (!uiState.settings.isKernelEnabled) {
+			com.wireguard.android.backend.GoBackend.VpnService.prepare(context)
 		} else {
-            requestBatteryOptimizationsDisabled()
+			null
 		}
+		if (intent != null) return vpnActivityResultState.launch(intent)
+		viewModel.onToggleAutoTunnel(context)
 	}
 
 	fun saveTrustedSSID() {
@@ -195,12 +192,6 @@ fun SettingsScreen(
 		}
 	}
 
-    fun openSettings() {
-        val intentSettings = Intent(ACTION_APPLICATION_DETAILS_SETTINGS)
-        intentSettings.data = Uri.fromParts("package", context.packageName, null)
-        context.startActivity(intentSettings)
-    }
-
 	fun checkFineLocationGranted() {
 		isBackgroundLocationGranted =
 			if (!fineLocationState.status.isGranted) {
@@ -211,9 +202,13 @@ fun SettingsScreen(
 			}
 	}
 
+	fun onRootDenied() = appViewModel.showSnackbarMessage(context.getString(R.string.error_root_denied))
+
+	fun onRootAccepted() = appViewModel.showSnackbarMessage(context.getString(R.string.root_accepted))
+
 	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
 		if (
-            WireGuardAutoTunnel.isRunningOnAndroidTv() &&
+			context.isRunningOnTv() &&
 			Build.VERSION.SDK_INT == Build.VERSION_CODES.Q
 		) {
 			checkFineLocationGranted()
@@ -233,119 +228,61 @@ fun SettingsScreen(
 	if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
 		checkFineLocationGranted()
 	}
-
-    AnimatedVisibility(showLocationServicesAlertDialog) {
-        AlertDialog(
-            onDismissRequest = { showLocationServicesAlertDialog = false },
-            confirmButton = {
-                TextButton(
-                    onClick = {
-                        showLocationServicesAlertDialog = false
-                        handleAutoTunnelToggle()
-                    },
-                ) {
-                    Text(text = stringResource(R.string.okay))
-                }
-            },
-            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),
-        ) {
-            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()
+		BackgroundLocationDisclosure(
+			onDismiss = { viewModel.setLocationDisclosureShown() },
+			onAttest = {
+				context.launchAppSettings()
 				viewModel.setLocationDisclosureShown()
 			},
-                ) {
-                    Text(stringResource(id = R.string.turn_on))
-                }
-            }
-        }
+			scrollState,
+			focusRequester,
+		)
+		return
 	}
 
+	BackgroundLocationDialog(
+		showLocationDialog,
+		onDismiss = { showLocationDialog = false },
+		onAttest = { showLocationDialog = false },
+	)
+
+	LocationServicesDialog(
+		showLocationServicesAlertDialog,
+		onDismiss = { showVpnPermissionDialog = false },
+		onAttest = { handleAutoTunnelToggle() },
+	)
+
+	VpnDeniedDialog(showVpnPermissionDialog, onDismiss = { showVpnPermissionDialog = false })
+
 	if (showAuthPrompt) {
 		AuthorizationPrompt(
 			onSuccess = {
 				showAuthPrompt = false
-                exportAllConfigs()
+				scope.launch {
+					viewModel.exportAllConfigs().onSuccess {
+						appViewModel.showSnackbarMessage(context.getString(R.string.exported_configs_message))
+					}.onFailure {
+						appViewModel.showSnackbarMessage(context.getString(R.string.export_configs_failed))
+					}
+				}
 			},
 			onError = { _ ->
 				showAuthPrompt = false
-                appViewModel.showSnackbarMessage(context.getString(R.string.error_authentication_failed))
+				appViewModel.showSnackbarMessage(
+					context.getString(R.string.error_authentication_failed),
+				)
 			},
 			onFailure = {
 				showAuthPrompt = false
-                appViewModel.showSnackbarMessage(context.getString(R.string.error_authorization_failed))
+				appViewModel.showSnackbarMessage(
+					context.getString(R.string.error_authorization_failed),
+				)
 			},
 		)
 	}
 
-    if (uiState.tunnels.isEmpty() && uiState.isLocationDisclosureShown) {
-        Column(
-            horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center,
-            modifier = Modifier.fillMaxSize(),
-        ) {
-            Text(
-                stringResource(R.string.one_tunnel_required),
-                textAlign = TextAlign.Center,
-                modifier = Modifier.padding(15.dp),
-                fontStyle = FontStyle.Italic,
-            )
-        }
-    }
-    if (uiState.isLocationDisclosureShown && uiState.tunnels.isNotEmpty()) {
+	if (uiState.isLocationDisclosureShown) {
 		Column(
 			horizontalAlignment = Alignment.CenterHorizontally,
 			verticalArrangement = Arrangement.Top,
@@ -366,7 +303,8 @@ fun SettingsScreen(
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
 				modifier =
-                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+				(
+					if (context.isRunningOnTv()) {
 						Modifier
 							.height(IntrinsicSize.Min)
 							.fillMaxWidth(fillMaxWidth)
@@ -375,7 +313,8 @@ fun SettingsScreen(
 						Modifier
 							.fillMaxWidth(fillMaxWidth)
 							.padding(top = 20.dp)
-                })
+					}
+					)
 					.padding(bottom = 10.dp),
 			) {
 				Column(
@@ -390,21 +329,26 @@ fun SettingsScreen(
 					ConfigurationToggle(
 						stringResource(id = R.string.tunnel_on_wifi),
 						enabled =
-                        !(uiState.settings.isAutoTunnelEnabled ||
-                            uiState.settings.isAlwaysOnVpnEnabled),
+						!(
+							uiState.settings.isAutoTunnelEnabled ||
+								uiState.settings.isAlwaysOnVpnEnabled
+							),
 						checked = uiState.settings.isTunnelOnWifiEnabled,
 						padding = screenPadding,
 						onCheckChanged = { viewModel.onToggleTunnelOnWifi() },
 						modifier =
-                        if (uiState.settings.isAutoTunnelEnabled) Modifier
-                        else
+						if (uiState.settings.isAutoTunnelEnabled) {
 							Modifier
-                                .focusRequester(focusRequester),
+						} else {
+							Modifier
+								.focusRequester(focusRequester)
+						},
 					)
-                    AnimatedVisibility(visible = uiState.settings.isTunnelOnWifiEnabled) {
+					if (uiState.settings.isTunnelOnWifiEnabled) {
 						Column {
 							FlowRow(
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.padding(screenPadding)
 									.fillMaxWidth(),
 								horizontalArrangement = Arrangement.spacedBy(5.dp),
@@ -412,35 +356,39 @@ fun SettingsScreen(
 								uiState.settings.trustedNetworkSSIDs.forEach { ssid ->
 									ClickableIconButton(
 										onClick = {
-                                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+											if (context.isRunningOnTv()) {
 												focusRequester.requestFocus()
 												viewModel.onDeleteTrustedSSID(ssid)
 											}
 										},
 										onIconClick = {
-                                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
+											if (context.isRunningOnTv()) focusRequester.requestFocus()
 											viewModel.onDeleteTrustedSSID(ssid)
-
 										},
 										text = ssid,
 										icon = Icons.Filled.Close,
 										enabled =
-                                        !(uiState.settings.isAutoTunnelEnabled ||
-                                            uiState.settings.isAlwaysOnVpnEnabled),
+										!(
+											uiState.settings.isAutoTunnelEnabled ||
+												uiState.settings.isAlwaysOnVpnEnabled
+											),
 									)
 								}
 								if (uiState.settings.trustedNetworkSSIDs.isEmpty()) {
 									Text(
 										stringResource(R.string.none),
 										fontStyle = FontStyle.Italic,
-                                        color = Color.Gray,
+										style = MaterialTheme.typography.bodySmall,
+										color = MaterialTheme.colorScheme.onSurface,
 									)
 								}
 							}
 							OutlinedTextField(
 								enabled =
-                                !(uiState.settings.isAutoTunnelEnabled ||
-                                    uiState.settings.isAlwaysOnVpnEnabled),
+								!(
+									uiState.settings.isAutoTunnelEnabled ||
+										uiState.settings.isAlwaysOnVpnEnabled
+									),
 								value = currentText,
 								onValueChange = { currentText = it },
 								label = { Text(stringResource(R.string.add_trusted_ssid)) },
@@ -488,8 +436,10 @@ fun SettingsScreen(
 					ConfigurationToggle(
 						stringResource(R.string.tunnel_mobile_data),
 						enabled =
-                        !(uiState.settings.isAutoTunnelEnabled ||
-                            uiState.settings.isAlwaysOnVpnEnabled),
+						!(
+							uiState.settings.isAutoTunnelEnabled ||
+								uiState.settings.isAlwaysOnVpnEnabled
+							),
 						checked = uiState.settings.isTunnelOnMobileDataEnabled,
 						padding = screenPadding,
 						onCheckChanged = { viewModel.onToggleTunnelOnMobileData() },
@@ -497,8 +447,10 @@ fun SettingsScreen(
 					ConfigurationToggle(
 						stringResource(id = R.string.tunnel_on_ethernet),
 						enabled =
-                        !(uiState.settings.isAutoTunnelEnabled ||
-                            uiState.settings.isAlwaysOnVpnEnabled),
+						!(
+							uiState.settings.isAutoTunnelEnabled ||
+								uiState.settings.isAlwaysOnVpnEnabled
+							),
 						checked = uiState.settings.isTunnelOnEthernetEnabled,
 						padding = screenPadding,
 						onCheckChanged = { viewModel.onToggleTunnelOnEthernet() },
@@ -506,8 +458,10 @@ fun SettingsScreen(
 					ConfigurationToggle(
 						stringResource(R.string.restart_on_ping),
 						enabled =
-                        !(uiState.settings.isAutoTunnelEnabled ||
-                            uiState.settings.isAlwaysOnVpnEnabled),
+						!(
+							uiState.settings.isAutoTunnelEnabled ||
+								uiState.settings.isAlwaysOnVpnEnabled
+							),
 						checked = uiState.settings.isPingEnabled,
 						padding = screenPadding,
 						onCheckChanged = { viewModel.onToggleRestartOnPing() },
@@ -515,11 +469,15 @@ fun SettingsScreen(
 					Row(
 						verticalAlignment = Alignment.CenterVertically,
 						modifier =
-                        (if (!uiState.settings.isAutoTunnelEnabled) Modifier
-                        else
+						(
+							if (!uiState.settings.isAutoTunnelEnabled) {
+								Modifier
+							} else {
 								Modifier.focusRequester(
 									focusRequester,
-                            ))
+								)
+							}
+							)
 							.fillMaxSize()
 							.padding(top = 5.dp),
 						horizontalArrangement = Arrangement.Center,
@@ -527,21 +485,14 @@ fun SettingsScreen(
 						TextButton(
 							enabled = !uiState.settings.isAlwaysOnVpnEnabled,
 							onClick = {
+								if (uiState.tunnels.isEmpty()) return@TextButton context.showToast(R.string.tunnel_required)
 								if (
 									uiState.settings.isTunnelOnWifiEnabled &&
 									!uiState.settings.isAutoTunnelEnabled
 								) {
 									when (false) {
-                                        isBackgroundLocationGranted ->
-                                            appViewModel.showSnackbarMessage(
-                                                context.getString(R.string.background_location_required),
-                                            )
-
-                                        fineLocationState.status.isGranted ->
-                                            appViewModel.showSnackbarMessage(
-                                                context.getString(R.string.precise_location_required),
-                                            )
-
+										isBackgroundLocationGranted -> showLocationDialog = true
+										fineLocationState.status.isGranted -> showLocationDialog = true
 										viewModel.isLocationEnabled(context) ->
 											showLocationServicesAlertDialog = true
 
@@ -570,7 +521,8 @@ fun SettingsScreen(
 				shadowElevation = 2.dp,
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
-                modifier = Modifier
+				modifier =
+				Modifier
 					.fillMaxWidth(fillMaxWidth)
 					.padding(vertical = 10.dp),
 			) {
@@ -586,9 +538,11 @@ fun SettingsScreen(
 					ConfigurationToggle(
 						stringResource(R.string.use_amnezia),
 						enabled =
-                        !(uiState.settings.isAutoTunnelEnabled ||
+						!(
+							uiState.settings.isAutoTunnelEnabled ||
 								uiState.settings.isAlwaysOnVpnEnabled ||
-                            (uiState.vpnState.status == TunnelState.UP) || uiState.settings.isKernelEnabled),
+								(uiState.vpnState.status == TunnelState.UP) || uiState.settings.isKernelEnabled
+							),
 						checked = uiState.settings.isAmneziaEnabled,
 						padding = screenPadding,
 						onCheckChanged = {
@@ -599,19 +553,35 @@ fun SettingsScreen(
 						ConfigurationToggle(
 							stringResource(R.string.use_kernel),
 							enabled =
-                            !(uiState.settings.isAutoTunnelEnabled ||
+							!(
+								uiState.settings.isAutoTunnelEnabled ||
 									uiState.settings.isAlwaysOnVpnEnabled ||
-                                (uiState.vpnState.status == TunnelState.UP)),
+									(uiState.vpnState.status == TunnelState.UP)
+								),
 							checked = uiState.settings.isKernelEnabled,
 							padding = screenPadding,
 							onCheckChanged = {
 								scope.launch {
-                                    viewModel.onToggleKernelMode().onFailure {
-                                        appViewModel.showSnackbarMessage(it.getMessage(context))
-                                    }
+									viewModel.onToggleKernelMode({ onRootAccepted() }, { onRootDenied() })
 								}
 							},
 						)
+						Row(
+							verticalAlignment = Alignment.CenterVertically,
+							modifier =
+							Modifier
+								.fillMaxSize()
+								.padding(top = 5.dp),
+							horizontalArrangement = Arrangement.Center,
+						) {
+							TextButton(
+								onClick = {
+									viewModel.requestRoot({ onRootAccepted() }, { onRootDenied() })
+								},
+							) {
+								Text(stringResource(R.string.request_root))
+							}
+						}
 					}
 				}
 			}
@@ -624,7 +594,7 @@ fun SettingsScreen(
 				Modifier
 					.fillMaxWidth(fillMaxWidth)
 					.padding(vertical = 10.dp)
-                    .padding(bottom = 140.dp),
+					.padding(bottom = 10.dp),
 			) {
 				Column(
 					horizontalAlignment = Alignment.Start,
@@ -635,7 +605,7 @@ fun SettingsScreen(
 						title = stringResource(id = R.string.other),
 						padding = screenPadding,
 					)
-                    if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+					if (!context.isRunningOnTv()) {
 						ConfigurationToggle(
 							stringResource(R.string.always_on_vpn_support),
 							enabled = !uiState.settings.isAutoTunnelEnabled,
@@ -667,24 +637,29 @@ fun SettingsScreen(
 						padding = screenPadding,
 						onCheckChanged = {
 							if (uiState.isPinLockEnabled) {
-                                viewModel.onPinLockDisabled()
+								appViewModel.onPinLockDisabled()
 							} else {
-                                viewModel.onPinLockEnabled()
+								// TODO may want to show a dialog before proceeding in the future
+								PinManager.initialize(WireGuardAutoTunnel.instance)
 								navController.navigate(Screen.Lock.route)
 							}
 						},
 					)
-                    if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+					if (!context.isRunningOnTv()) {
 						Row(
 							verticalAlignment = Alignment.CenterVertically,
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.fillMaxSize()
 								.padding(top = 5.dp),
 							horizontalArrangement = Arrangement.Center,
 						) {
 							TextButton(
 								enabled = !didExportFiles,
-                                onClick = { showAuthPrompt = true },
+								onClick = {
+									if (uiState.tunnels.isEmpty()) return@TextButton context.showToast(R.string.tunnel_required)
+									showAuthPrompt = true
+								},
 							) {
 								Text(stringResource(R.string.export_configs))
 							}

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

@@ -10,5 +10,5 @@ data class SettingsUiState(
 	val vpnState: VpnState = VpnState(),
 	val isLocationDisclosureShown: Boolean = true,
 	val isBatteryOptimizeDisableShown: Boolean = false,
-    val isPinLockEnabled: Boolean = false
+	val isPinLockEnabled: Boolean = false,
 )

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

@@ -7,12 +7,11 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wireguard.android.backend.WgQuickBackend
 import com.wireguard.android.util.RootShell
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
@@ -27,7 +26,6 @@ import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import timber.log.Timber
-import xyz.teamgravity.pin_lock_compose.PinManager
 import java.io.File
 import javax.inject.Inject
 import javax.inject.Provider
@@ -41,9 +39,8 @@ constructor(
 	private val rootShell: Provider<RootShell>,
 	private val fileUtils: FileUtils,
 	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-    vpnService: VpnService
+	tunnelService: TunnelService,
 ) : ViewModel() {
-
 	private val _kernelSupport = MutableStateFlow(false)
 	val kernelSupport = _kernelSupport.asStateFlow()
 
@@ -51,7 +48,7 @@ constructor(
 		combine(
 			appDataRepository.settings.getSettingsFlow(),
 			appDataRepository.tunnels.getTunnelConfigsFlow(),
-            vpnService.vpnState,
+			tunnelService.vpnState,
 			appDataRepository.appState.generalStateFlow,
 		) { settings, tunnels, tunnelState, generalState ->
 			SettingsUiState(
@@ -80,13 +77,11 @@ constructor(
 		}
 	}
 
-    fun setLocationDisclosureShown() =
-        viewModelScope.launch {
+	fun setLocationDisclosureShown() = viewModelScope.launch {
 		appDataRepository.appState.setLocationDisclosureShown(true)
 	}
 
-    fun setBatteryOptimizeDisableShown() =
-        viewModelScope.launch {
+	fun setBatteryOptimizeDisableShown() = viewModelScope.launch {
 		appDataRepository.appState.setBatteryOptimizationDisableShown(true)
 	}
 
@@ -111,8 +106,7 @@ constructor(
 		return fileUtils.saveFilesToZip(files)
 	}
 
-    fun onToggleAutoTunnel(context: Context) =
-        viewModelScope.launch {
+	fun onToggleAutoTunnel(context: Context) = viewModelScope.launch {
 		val isAutoTunnelEnabled = uiState.value.settings.isAutoTunnelEnabled
 		var isAutoTunnelPaused = uiState.value.settings.isAutoTunnelPaused
 
@@ -128,11 +122,9 @@ constructor(
 				isAutoTunnelPaused = isAutoTunnelPaused,
 			),
 		)
-            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
 	}
 
-    fun onToggleAlwaysOnVPN() =
-        viewModelScope.launch {
+	fun onToggleAlwaysOnVPN() = viewModelScope.launch {
 		saveSettings(
 			uiState.value.settings.copy(
 				isAlwaysOnVpnEnabled = !uiState.value.settings.isAlwaysOnVpnEnabled,
@@ -140,8 +132,7 @@ constructor(
 		)
 	}
 
-    private fun saveSettings(settings: Settings) =
-        viewModelScope.launch { appDataRepository.settings.save(settings) }
+	private fun saveSettings(settings: Settings) = viewModelScope.launch { appDataRepository.settings.save(settings) }
 
 	fun onToggleTunnelOnEthernet() {
 		saveSettings(
@@ -152,7 +143,10 @@ constructor(
 	}
 
 	fun isLocationEnabled(context: Context): Boolean {
-        val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+		val locationManager =
+			context.getSystemService(
+				Context.LOCATION_SERVICE,
+			) as LocationManager
 		return LocationManagerCompat.isLocationEnabled(locationManager)
 	}
 
@@ -164,10 +158,10 @@ constructor(
 		)
 	}
 
-    private fun saveKernelMode(on: Boolean) {
+	private fun saveKernelMode(enabled: Boolean) {
 		saveSettings(
 			uiState.value.settings.copy(
-                isKernelEnabled = on,
+				isKernelEnabled = enabled,
 			),
 		)
 	}
@@ -195,28 +189,25 @@ constructor(
 		)
 	}
 
-    suspend fun onToggleKernelMode(): Result<Unit> {
-        return withContext(ioDispatcher) {
+	fun onToggleKernelMode(onSuccess: () -> Unit, onFailure: () -> Unit) = viewModelScope.launch {
 		if (!uiState.value.settings.isKernelEnabled) {
-                try {
-                    rootShell.get().start()
-                    Timber.i("Root shell accepted!")
+			requestRoot(
+				{
+					onSuccess()
 					saveSettings(
 						uiState.value.settings.copy(
 							isKernelEnabled = true,
 							isAmneziaEnabled = false,
 						),
 					)
-
-                } catch (e: RootShell.RootShellException) {
-                    Timber.e(e)
-                    saveKernelMode(on = false)
-                    return@withContext Result.failure(WgTunnelExceptions.RootDenied())
-                }
+				},
+				{
+					onFailure()
+					saveKernelMode(enabled = false)
+				},
+			)
 		} else {
-                saveKernelMode(on = false)
-            }
-            Result.success(Unit)
+			saveKernelMode(enabled = false)
 		}
 	}
 
@@ -229,7 +220,8 @@ constructor(
 	}
 
 	fun checkKernelSupport() = viewModelScope.launch {
-        val kernelSupport = withContext(ioDispatcher) {
+		val kernelSupport =
+			withContext(ioDispatcher) {
 				WgQuickBackend.hasKernelSupport()
 			}
 		_kernelSupport.update {
@@ -237,21 +229,32 @@ constructor(
 		}
 	}
 
-    fun onPinLockDisabled() = viewModelScope.launch {
-        PinManager.clearPin()
-        appDataRepository.appState.setPinLockEnabled(false)
-    }
-
-    fun onPinLockEnabled() = viewModelScope.launch {
-        PinManager.initialize(WireGuardAutoTunnel.instance)
-        appDataRepository.appState.setPinLockEnabled(true)
-    }
-
 	fun onToggleRestartAtBoot() = viewModelScope.launch {
 		saveSettings(
 			uiState.value.settings.copy(
-                isRestoreOnBootEnabled = !uiState.value.settings.isRestoreOnBootEnabled
-            )
+				isRestoreOnBootEnabled = !uiState.value.settings.isRestoreOnBootEnabled,
+			),
 		)
 	}
+
+	fun requestRoot(onSuccess: () -> Unit, onFailure: () -> Unit) = viewModelScope.launch(ioDispatcher) {
+		kotlin.runCatching {
+			rootShell.get().start()
+			Timber.i("Root shell accepted!")
+			onSuccess()
+		}.onFailure {
+			onFailure()
+		}.onSuccess {
+			onSuccess()
+		}
+	}
+
+	suspend fun exportAllConfigs(): Result<Unit> {
+		return kotlin.runCatching {
+			val tunnels = appDataRepository.tunnels.getAll()
+			val wgFiles = fileUtils.createWgFiles(tunnels)
+			val amFiles = fileUtils.createAmFiles(tunnels)
+			onExportTunnels(wgFiles + amFiles)
+		}
+	}
 }

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

@@ -0,0 +1,49 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.settings.components
+
+import androidx.compose.foundation.text.ClickableText
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.withStyle
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
+import com.zaneschepke.wireguardautotunnel.util.extensions.launchAppSettings
+
+@Composable
+fun BackgroundLocationDialog(show: Boolean, onDismiss: () -> Unit, onAttest: () -> Unit) {
+	val context = LocalContext.current
+	if (show) {
+		val alwaysOnDescription = buildAnnotatedString {
+			append(stringResource(R.string.background_location_message))
+			append(" ")
+			pushStringAnnotation(tag = "appSettings", annotation = "")
+			withStyle(style = SpanStyle(color = MaterialTheme.colorScheme.primary)) {
+				append(stringResource(id = R.string.app_settings))
+			}
+			pop()
+			append(" ")
+			append(stringResource(R.string.background_location_message2))
+			append(".")
+		}
+		InfoDialog(
+			onDismiss = { onDismiss() },
+			onAttest = { onDismiss() },
+			title = { Text(text = stringResource(R.string.vpn_denied_dialog_title)) },
+			body = {
+				ClickableText(
+					text = alwaysOnDescription,
+					style = MaterialTheme.typography.bodyMedium.copy(color = MaterialTheme.colorScheme.outline),
+				) {
+					alwaysOnDescription.getStringAnnotations(tag = "appSettings", it, it).firstOrNull()?.let {
+						context.launchAppSettings()
+					}
+				}
+			},
+			confirmText = { Text(text = stringResource(R.string.okay)) },
+		)
+	}
+}

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

@@ -0,0 +1,88 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.settings.components
+
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+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.layout.size
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.LocationOff
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
+
+@Composable
+fun BackgroundLocationDisclosure(onDismiss: () -> Unit, onAttest: () -> Unit, scrollState: ScrollState, focusRequester: FocusRequester) {
+	val context = LocalContext.current
+	Column(
+		horizontalAlignment = Alignment.CenterHorizontally,
+		verticalArrangement = Arrangement.Top,
+		modifier =
+		Modifier
+			.fillMaxSize()
+			.verticalScroll(scrollState),
+	) {
+		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 (context.isRunningOnTv()) {
+				Modifier
+					.fillMaxWidth()
+					.padding(10.dp)
+			} else {
+				Modifier
+					.fillMaxWidth()
+					.padding(30.dp)
+			},
+			verticalAlignment = Alignment.CenterVertically,
+			horizontalArrangement = Arrangement.SpaceEvenly,
+		) {
+			TextButton(onClick = { onDismiss() }) {
+				Text(stringResource(id = R.string.no_thanks))
+			}
+			TextButton(
+				modifier = Modifier.focusRequester(focusRequester),
+				onClick = {
+					onAttest()
+				},
+			) {
+				Text(stringResource(id = R.string.turn_on))
+			}
+		}
+	}
+}

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

@@ -0,0 +1,34 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.settings.components
+
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import com.zaneschepke.wireguardautotunnel.R
+
+@Composable
+fun LocationServicesDialog(show: Boolean, onDismiss: () -> Unit, onAttest: () -> Unit) {
+	if (show) {
+		AlertDialog(
+			onDismissRequest = { onDismiss() },
+			confirmButton = {
+				TextButton(
+					onClick = {
+						onDismiss()
+						onAttest()
+					},
+				) {
+					Text(text = stringResource(R.string.okay))
+				}
+			},
+			dismissButton = {
+				TextButton(onClick = { onDismiss() }) {
+					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)) },
+		)
+	}
+}

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

@@ -48,17 +48,13 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
 import com.zaneschepke.wireguardautotunnel.BuildConfig
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
+import com.zaneschepke.wireguardautotunnel.util.extensions.launchSupportEmail
+import com.zaneschepke.wireguardautotunnel.util.extensions.openWebUrl
 
 @Composable
-fun SupportScreen(
-    viewModel: SupportViewModel = hiltViewModel(),
-    appViewModel: AppViewModel,
-    navController: NavController,
-    focusRequester: FocusRequester
-) {
+fun SupportScreen(viewModel: SupportViewModel = hiltViewModel(), navController: NavController, focusRequester: FocusRequester) {
 	val context = LocalContext.current
 	val fillMaxWidth = .85f
 
@@ -79,7 +75,8 @@ fun SupportScreen(
 			shape = RoundedCornerShape(12.dp),
 			color = MaterialTheme.colorScheme.surface,
 			modifier =
-            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+			(
+				if (context.isRunningOnTv()) {
 					Modifier
 						.height(IntrinsicSize.Min)
 						.fillMaxWidth(fillMaxWidth)
@@ -88,7 +85,8 @@ fun SupportScreen(
 					Modifier
 						.fillMaxWidth(fillMaxWidth)
 						.padding(top = 20.dp)
-            })
+				}
+				)
 				.padding(bottom = 25.dp),
 		) {
 			Column(modifier = Modifier.padding(20.dp)) {
@@ -108,12 +106,12 @@ fun SupportScreen(
 				)
 				TextButton(
 					onClick = {
-                        appViewModel.openWebPage(
+						context.openWebUrl(
 							context.resources.getString(R.string.docs_url),
-                            context,
 						)
 					},
-                    modifier = Modifier
+					modifier =
+					Modifier
 						.padding(vertical = 5.dp)
 						.focusRequester(focusRequester),
 				) {
@@ -128,7 +126,8 @@ fun SupportScreen(
 							Text(
 								stringResource(id = R.string.docs_description),
 								textAlign = TextAlign.Justify,
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.padding(start = 10.dp)
 									.weight(
 										weight = 1.0f,
@@ -149,9 +148,8 @@ fun SupportScreen(
 				)
 				TextButton(
 					onClick = {
-                        appViewModel.openWebPage(
+						context.openWebUrl(
 							context.resources.getString(R.string.telegram_url),
-                            context,
 						)
 					},
 					modifier = Modifier.padding(vertical = 5.dp),
@@ -169,7 +167,7 @@ fun SupportScreen(
 								Modifier.size(25.dp),
 							)
 							Text(
-                                stringResource(id = R.string.discord_description),
+								stringResource(id = R.string.chat_description),
 								textAlign = TextAlign.Justify,
 								modifier = Modifier.padding(start = 10.dp),
 							)
@@ -186,9 +184,8 @@ fun SupportScreen(
 				)
 				TextButton(
 					onClick = {
-                        appViewModel.openWebPage(
+						context.openWebUrl(
 							context.resources.getString(R.string.github_url),
-                            context,
 						)
 					},
 					modifier = Modifier.padding(vertical = 5.dp),
@@ -222,7 +219,7 @@ fun SupportScreen(
 					color = MaterialTheme.colorScheme.onBackground,
 				)
 				TextButton(
-                    onClick = { appViewModel.launchEmail(context) },
+					onClick = { context.launchSupportEmail() },
 					modifier = Modifier.padding(vertical = 5.dp),
 				) {
 					Row(
@@ -245,7 +242,7 @@ fun SupportScreen(
 						)
 					}
 				}
-                if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+				if (!context.isRunningOnTv()) {
 					HorizontalDivider(
 						thickness = 0.5.dp,
 						color = MaterialTheme.colorScheme.onBackground,
@@ -284,9 +281,8 @@ fun SupportScreen(
 			fontSize = 16.sp,
 			modifier =
 			Modifier.clickable {
-                appViewModel.openWebPage(
+				context.openWebUrl(
 					context.resources.getString(R.string.privacy_policy_url),
-                    context,
 				)
 			},
 		)
@@ -295,12 +291,14 @@ fun SupportScreen(
 			verticalAlignment = Alignment.CenterVertically,
 			modifier = Modifier.padding(25.dp),
 		) {
-            val version = buildAnnotatedString {
+			val version =
+				buildAnnotatedString {
 					append(stringResource(id = R.string.version))
 					append(": ")
 					append(BuildConfig.VERSION_NAME)
 				}
-            val mode = buildAnnotatedString {
+			val mode =
+				buildAnnotatedString {
 					append(stringResource(R.string.mode))
 					append(": ")
 					when (uiState.settings.isKernelEnabled) {

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

@@ -11,9 +11,10 @@ import kotlinx.coroutines.flow.stateIn
 import javax.inject.Inject
 
 @HiltViewModel
-class SupportViewModel @Inject constructor(settingsRepository: SettingsRepository) :
+class SupportViewModel
+@Inject
+constructor(settingsRepository: SettingsRepository) :
 	ViewModel() {
-
 	val uiState =
 		settingsRepository
 			.getSettingsFlow()

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

@@ -42,7 +42,6 @@ import kotlinx.coroutines.launch
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
 @Composable
 fun LogsScreen(viewModel: LogsViewModel = hiltViewModel()) {
-
 	val logs = viewModel.logs
 
 	val context = LocalContext.current
@@ -87,7 +86,8 @@ fun LogsScreen(viewModel: LogsViewModel = hiltViewModel()) {
 			horizontalAlignment = Alignment.CenterHorizontally,
 			verticalArrangement = Arrangement.spacedBy(16.dp, Alignment.Top),
 			state = lazyColumnListState,
-            modifier = Modifier
+			modifier =
+			Modifier
 				.fillMaxSize()
 				.padding(horizontal = 24.dp),
 		) {
@@ -99,13 +99,16 @@ fun LogsScreen(viewModel: LogsViewModel = hiltViewModel()) {
 				Row(
 					horizontalArrangement = Arrangement.spacedBy(5.dp, Alignment.Start),
 					verticalAlignment = Alignment.Top,
-                    modifier = Modifier
+					modifier =
+					Modifier
 						.fillMaxSize()
 						.clickable(
 							interactionSource = remember { MutableInteractionSource() },
 							indication = null,
 							onClick = {
-                                clipboardManager.setText(annotatedString = AnnotatedString(it.toString()))
+								clipboardManager.setText(
+									annotatedString = AnnotatedString(it.toString()),
+								)
 							},
 						),
 				) {

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

@@ -9,7 +9,7 @@ import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.module.MainDispatcher
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.FileUtils
-import com.zaneschepke.wireguardautotunnel.util.chunked
+import com.zaneschepke.wireguardautotunnel.util.extensions.chunked
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.launch
@@ -20,13 +20,13 @@ import javax.inject.Inject
 
 @HiltViewModel
 class LogsViewModel
-@Inject constructor(
+@Inject
+constructor(
 	private val localLogCollector: LocalLogCollector,
 	private val fileUtils: FileUtils,
 	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-    @MainDispatcher private val mainDispatcher: CoroutineDispatcher
+	@MainDispatcher private val mainDispatcher: CoroutineDispatcher,
 ) : ViewModel() {
-
 	val logs = mutableStateListOf<LogMessage>()
 
 	init {
@@ -45,7 +45,8 @@ class LogsViewModel
 	}
 
 	suspend fun saveLogsToFile(): Result<Unit> {
-        val file = localLogCollector.getLogFile().getOrElse {
+		val file =
+			localLogCollector.getLogFile().getOrElse {
 				return Result.failure(it)
 			}
 		val fileContent = fileUtils.readBytesFromFile(file)

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/Theme.kt

@@ -2,6 +2,7 @@ package com.zaneschepke.wireguardautotunnel.ui.theme
 
 import android.app.Activity
 import android.os.Build
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.darkColorScheme
 import androidx.compose.material3.dynamicDarkColorScheme
@@ -19,9 +20,10 @@ private val DarkColorScheme =
 	darkColorScheme(
 		// primary = Purple80,
 		primary = virdigris,
-        secondary = virdigris,
+		secondary = PurpleGrey40,
 		// secondary = PurpleGrey80,
-        tertiary = virdigris,
+		tertiary = Pink40,
+		surfaceTint = Pink80,
 		// tertiary = Pink80
 	)
 
@@ -30,6 +32,7 @@ private val LightColorScheme =
 		primary = Purple40,
 		secondary = PurpleGrey40,
 		tertiary = Pink40,
+		surfaceTint = Pink80,
         /* Other default colors to override
         background = Color(0xFFFFFBFE),
         surface = Color(0xFFFFFBFE),
@@ -44,21 +47,19 @@ private val LightColorScheme =
 @Composable
 fun WireguardAutoTunnelTheme(
 	// force dark theme
-    darkTheme: Boolean = true,
-    // darkTheme: Boolean = isSystemInDarkTheme(),
-    // Dynamic color is available on Android 12+
-    // turning off dynamic color for now
-    dynamicColor: Boolean = false,
-    content: @Composable () -> Unit
+	useDarkTheme: Boolean = isSystemInDarkTheme(),
+	content: @Composable () -> Unit,
 ) {
-    val colorScheme =
-        when {
-            dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
 	val context = LocalContext.current
-                if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
+	val colorScheme = when {
+		(Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) -> {
+			if (useDarkTheme) {
+				dynamicDarkColorScheme(context)
+			} else {
+				dynamicLightColorScheme(context)
 			}
-
-            darkTheme -> DarkColorScheme
+		}
+		useDarkTheme -> DarkColorScheme
 		else -> LightColorScheme
 	}
 	val view = LocalView.current
@@ -69,7 +70,7 @@ fun WireguardAutoTunnelTheme(
 			window.statusBarColor = Color.Transparent.toArgb()
 			window.navigationBarColor = Color.Transparent.toArgb()
 			WindowCompat.getInsetsController(window, window.decorView).isAppearanceLightStatusBars =
-                !darkTheme
+				!useDarkTheme
 		}
 	}