build(deps): bump hiltAndroid from 2.51.1 to 2.52

Bumps `hiltAndroid` from 2.51.1 to 2.52.

Updates `com.google.dagger:hilt-android` from 2.51.1 to 2.52
- [Release notes](https://github.com/google/dagger/releases)
- [Changelog](https://github.com/google/dagger/blob/master/CHANGELOG.md)
- [Commits](https://github.com/google/dagger/compare/dagger-2.51.1...dagger-2.52)

Updates `com.google.dagger:hilt-android-compiler` from 2.51.1 to 2.52
- [Release notes](https://github.com/google/dagger/releases)
- [Changelog](https://github.com/google/dagger/blob/master/CHANGELOG.md)
- [Commits](https://github.com/google/dagger/compare/dagger-2.51.1...dagger-2.52)

Updates `com.google.dagger.hilt.android` from 2.51.1 to 2.52
- [Release notes](https://github.com/google/dagger/releases)
- [Changelog](https://github.com/google/dagger/blob/master/CHANGELOG.md)
- [Commits](https://github.com/google/dagger/compare/dagger-2.51.1...dagger-2.52)

---
updated-dependencies:
- dependency-name: com.google.dagger:hilt-android
  dependency-type: direct:production
  update-type: version-update:semver-minor
- dependency-name: com.google.dagger:hilt-android-compiler
  dependency-type: direct:production
  update-type: version-update:semver-minor
- dependency-name: com.google.dagger.hilt.android
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

.editorconfig

@@ -1,8 +1,14 @@
-[{*.kt,*.kts}]
+root = true
-indent_style = space
+
-insert_final_newline = true
+[*]
-max_line_length = 100
+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: release-android
-name: Android CI Tag Deployment (Release)
 
 on:
+  schedule:
+    - cron: "4 3 * * *"
   workflow_dispatch:
-  push:
+    inputs:
-    tags:
+      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: Build Fdroid Prerelease APK
-      - name: Get apk path
+        if: ${{ inputs.release_type != '' && inputs.release_type == 'prerelease' }}
-        id: apk-path
+        run: ./gradlew :app:assembleFdroidPrerelease -x test
-        run: echo "path=$(find . -regex '^.*/build/outputs/apk/fdroid/release/.*\.apk$' -type f | head -1)" >> $GITHUB_OUTPUT
+
+      - 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.5
         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 }}
+          tag_name: ${{ env.TAG_NAME }}
-          name: ${{ github.ref_name }}
+          name: ${{ env.TAG_NAME }}
           draft: false
-          prerelease: false
+          prerelease: ${{ inputs.release_type == 'prerelease' || inputs.release_type == '' || inputs.release_type == 'nightly' }}
-          append_body: true
+          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 }})
 

README.md

@@ -22,7 +22,8 @@ WG Tunnel
 
 <div align="left">
 
-This is an alternative Android Application for [WireGuard](https://www.wireguard.com/) and [AmneziaWG](https://docs.amnezia.org/documentation/amnezia-wg/) with added
+This is an alternative Android Application for [WireGuard](https://www.wireguard.com/)
+and [AmneziaWG](https://docs.amnezia.org/documentation/amnezia-wg/) with added
 features. Built using the [wireguard-android](https://github.com/WireGuard/wireguard-android)
 library and [Jetpack Compose](https://developer.android.com/jetpack/compose), this application was
 inspired by the official [WireGuard Android](https://github.com/WireGuard/wireguard-android) app.
@@ -64,27 +65,28 @@ and on while on different networks. This app was created to offer a free solutio
 * Battery preservation measures
 * Restart tunnel on ping failure (beta)
 
+## Fdroid
+
+Want updates faster?
+
+Check out my personal [fdroid repository](https://github.com/zaneschepke/fdroid) to get updates the
+moment they are released.
+
 ## Docs
 
-Basic documentation of the feature and behaviors of this app can be
+Information about features, behaviors, and answers to common questions can be found in the
-found [here](https://zaneschepke.com/wgtunnel-docs/overview.html).
+app [documentation](https://zaneschepke.com/wgtunnel-docs/overview.html).
 
 The repository for these docs can be found [here](https://github.com/zaneschepke/wgtunnel-docs).
 
-## Contributing
-
-Any contributions in the form of feedback, issues, code, or translations are welcome and much appreciated!
-
-Please read the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct) before contributing.
-
 ## Translation
 
 This app is using [Weblate](https://weblate.org) to assist with translations.
 
-Help translate WG Tunnel into your language at [Hosted Weblate](https://hosted.weblate.org/engage/wg-tunnel/).\
+Help translate WG Tunnel into your language
+at [Hosted Weblate](https://hosted.weblate.org/engage/wg-tunnel/).\
 [![Translation status](https://hosted.weblate.org/widgets/wg-tunnel/-/multi-auto.svg)](https://hosted.weblate.org/engage/wg-tunnel/)
 
-
 ## Building
 
 ```
@@ -98,4 +100,11 @@ And then build the app:
 $ ./gradlew assembleDebug
 ```
 
-</span>
+## Contributing
+
+Any contributions in the form of feedback, issues, code, or translations are welcome and much
+appreciated!
+
+Please read
+the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct)
+before contributing.

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
+		versionCode = determineVersionCode()
-        versionName = Constants.VERSION_NAME
+		versionName = determineVersionName()
 
 		ksp { arg("room.schemaLocation", "$projectDir/schemas") }
 
@@ -35,44 +35,10 @@ android {
 
 	signingConfigs {
 		create(Constants.RELEASE) {
-            val properties =
+			storeFile = getStoreFile()
-                Properties().apply {
+			storePassword = getSigningProperty(Constants.STORE_PASS_VAR)
-                    // created local file for signing details
+			keyAlias = getSigningProperty(Constants.KEY_ALIAS_VAR)
-                    try {
+			keyPassword = getSigningProperty(Constants.KEY_PASS_VAR)
-                        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),
-                    )
 		}
 	}
 
@@ -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
@@ -103,6 +59,26 @@ android {
 			signingConfig = signingConfigs.getByName(Constants.RELEASE)
 		}
 		debug { isDebuggable = true }
+
+		create(Constants.PRERELEASE) {
+			initWith(buildTypes.getByName(Constants.RELEASE))
+		}
+
+		create(Constants.NIGHTLY) {
+			initWith(buildTypes.getByName(Constants.RELEASE))
+		}
+
+		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 {
@@ -112,9 +88,6 @@ android {
 		}
 		create("general") {
 			dimension = Constants.TYPE
-            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
-                //any plugins general specific
-            }
 		}
 	}
 	compileOptions {
@@ -127,7 +100,6 @@ android {
 		compose = true
 		buildConfig = true
 	}
-    composeOptions { kotlinCompilerExtensionVersion = Constants.COMPOSE_COMPILER_EXTENSION_VERSION }
 	packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
@@ -169,7 +141,6 @@ dependencies {
 	// logging
 	implementation(libs.timber)
 
-
 	// compose navigation
 	implementation(libs.androidx.navigation.compose)
 	implementation(libs.androidx.hilt.navigation.compose)
@@ -203,7 +174,6 @@ dependencies {
 
 	// barcode scanning
 	implementation(libs.zxing.android.embedded)
-    implementation(libs.zxing.core)
 
 	// bio
 	implementation(libs.androidx.biometric.ktx)
@@ -212,4 +182,28 @@ dependencies {
 	// shortcuts
 	implementation(libs.androidx.core)
 	implementation(libs.androidx.core.google.shortcuts)
+
+	// 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/proguard-rules.pro

@@ -22,5 +22,3 @@
 -keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
     <fields>;
 }
-
-

app/src/main/AndroidManifest.xml

@@ -51,7 +51,7 @@
     </queries>
     <application
         android:name=".WireGuardAutoTunnel"
-        android:allowBackup="true"
+        android:allowBackup="false"
         android:banner="@drawable/ic_banner"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:enableOnBackInvokedCallback="true"
@@ -60,18 +60,17 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.WireguardAutoTunnel"
+        android:theme="@style/Theme.AppSplashScreen"
         tools:targetApi="tiramisu">
         <activity
-            android:name=".ui.MainActivity"
+            android:name=".ui.SplashActivity"
             android:exported="true"
-            android:theme="@style/Theme.WireguardAutoTunnel">
+            android:theme="@style/Theme.AppSplashScreen">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
                 <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
-
                 <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
             </intent-filter>
             <meta-data
@@ -79,17 +78,23 @@
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
-            android:name=".ui.CaptureActivityPortrait"
+            android:name=".ui.MainActivity"
-            android:screenOrientation="fullSensor"
+            android:exported="true"
-            android:stateNotNeeded="true"
+            android:theme="@style/Theme.WireguardAutoTunnel">
-            android:theme="@style/zxing_CaptureTheme"
+        </activity>
-            android:windowSoftInputMode="stateAlwaysHidden"
+        <activity
-            tools:ignore="DiscouragedApi" />
+            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

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

@@ -3,35 +3,36 @@ 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.wireguardautotunnel.util.ReleaseTree
 import dagger.hilt.android.HiltAndroidApp
-import kotlinx.coroutines.MainScope
-import kotlinx.coroutines.cancel
 import timber.log.Timber
-import xyz.teamgravity.pin_lock_compose.PinManager
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
 	override fun onCreate() {
 		super.onCreate()
 		instance = this
-        if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree()) else Timber.plant(ReleaseTree())
+		if (BuildConfig.DEBUG) {
-        PinManager.initialize(this)
+			Timber.plant(Timber.DebugTree())
+			StrictMode.setThreadPolicy(
+				ThreadPolicy.Builder()
+					.detectDiskReads()
+					.detectDiskWrites()
+					.detectNetwork()
+					.penaltyLog()
+					.build(),
+			)
+		} else {
+			Timber.plant(ReleaseTree())
 		}
-
-    override fun onLowMemory() {
-        super.onLowMemory()
-        applicationScope.cancel("onLowMemory() called by system")
-        applicationScope = MainScope()
 	}
 
 	companion object {
-
-        var applicationScope = MainScope()
-
 		lateinit var instance: WireGuardAutoTunnel
 			private set
 

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

@@ -33,7 +33,7 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 			to = 7,
 			spec = RemoveLegacySettingColumnsMigration::class,
 		),
-        AutoMigration(7, 8)
+		AutoMigration(7, 8),
 	],
 	exportSchema = true,
 )

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

@@ -36,10 +36,10 @@ interface TunnelConfigDao {
 	suspend fun findByTunnelNetworkName(name: String): TunnelConfigs
 
 	@Query("UPDATE TunnelConfig SET is_primary_tunnel = 0 WHERE is_primary_tunnel =1")
-    fun resetPrimaryTunnel()
+	suspend fun resetPrimaryTunnel()
 
 	@Query("UPDATE TunnelConfig SET is_mobile_data_tunnel = 0 WHERE is_mobile_data_tunnel =1")
-    fun resetMobileDataTunnel()
+	suspend fun resetMobileDataTunnel()
 
 	@Query("SELECT * FROM TUNNELCONFIG WHERE is_primary_tunnel=1")
 	suspend fun findByPrimary(): TunnelConfigs

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

@@ -7,14 +7,20 @@ import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
 import timber.log.Timber
 import java.io.IOException
 
-class DataStoreManager(private val context: Context) {
+class DataStoreManager(
+	private val context: Context,
+	@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")
@@ -22,6 +28,7 @@ class DataStoreManager(private val context: Context) {
 			booleanPreferencesKey("TUNNEL_RUNNING_FROM_MANUAL_START")
 		val ACTIVE_TUNNEL = intPreferencesKey("ACTIVE_TUNNEL")
 		val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
+		val IS_PIN_LOCK_ENABLED = booleanPreferencesKey("PIN_LOCK_ENABLED")
 	}
 
 	// preferences
@@ -32,14 +39,17 @@ class DataStoreManager(private val context: Context) {
 		)
 
 	suspend fun init() {
+		withContext(ioDispatcher) {
 			try {
 				context.dataStore.data.first()
 			} catch (e: IOException) {
 				Timber.e(e)
 			}
 		}
+	}
 
 	suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) {
+		withContext(ioDispatcher) {
 			try {
 				context.dataStore.edit { it[key] = value }
 			} catch (e: IOException) {
@@ -48,19 +58,20 @@ class DataStoreManager(private val context: Context) {
 				Timber.e(e)
 			}
 		}
-
+	}
 
 	fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map { it[key] }
 
 	suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
-        return try {
+		return withContext(ioDispatcher) {
+			try {
 				context.dataStore.data.map { it[key] }.first()
 			} catch (e: IOException) {
 				Timber.e(e)
 				null
 			}
 		}
-
+	}
 
 	fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
 		context.dataStore.data.map { it[key] }.first()

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

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

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

@@ -40,12 +40,14 @@ data class TunnelConfig(
 				Config.parse(it)
 			}
 		}
+
 		fun configFromAmQuick(amQuick: String): org.amnezia.awg.config.Config {
 			val inputStream: InputStream = amQuick.byteInputStream()
 			return inputStream.bufferedReader(Charsets.UTF_8).use {
 				org.amnezia.awg.config.Config.parse(it)
 			}
 		}
+
 		const val AM_QUICK_DEFAULT = ""
 	}
 }

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

@@ -4,6 +4,7 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 
 interface AppDataRepository {
 	suspend fun getPrimaryOrFirstTunnel(): TunnelConfig?
+
 	suspend fun getStartTunnelConfig(): TunnelConfig?
 
 	suspend fun toggleWatcherServicePause()

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

@@ -3,10 +3,12 @@ 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()
@@ -17,7 +19,9 @@ class AppDataRoomRepository @Inject constructor(
 			appState.getActiveTunnelId()?.let {
 				tunnels.getById(it)
 			}
-        } else null
+		} else {
+			null
+		}
 	}
 
 	override suspend fun toggleWatcherServicePause() {

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

@@ -5,12 +5,19 @@ 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 setManualStop()
@@ -22,5 +29,4 @@ interface AppStateRepository {
 	suspend fun setCurrentSsid(ssid: String)
 
 	val generalStateFlow: Flow<GeneralState>
-
 }

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

@@ -17,6 +17,15 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
 		dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown)
 	}
 
+	override suspend fun isPinLockEnabled(): Boolean {
+		return 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)
+	}
+
 	override suspend fun isBatteryOptimizationDisableShown(): Boolean {
 		return dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
 			?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
@@ -65,11 +74,17 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
 			prefs?.let { pref ->
 				try {
 					GeneralState(
-                        locationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
+						isLocationDisclosureShown =
+						pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
 							?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-                        batteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
+						isBatteryOptimizationDisableShown =
+						pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
 							?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-                        tunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
+						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,
 					)
 				} catch (e: IllegalArgumentException) {

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

@@ -5,7 +5,6 @@ import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import kotlinx.coroutines.flow.Flow
 
 class RoomSettingsRepository(private val settingsDoa: SettingsDao) : SettingsRepository {
-
 	override suspend fun save(settings: Settings) {
 		settingsDoa.save(settings)
 	}

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

@@ -28,7 +28,6 @@ class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
 				),
 			)
 		}
-
 	}
 
 	override suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?) {

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

@@ -5,7 +5,6 @@ import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 interface TunnelConfigRepository {
-
 	fun getTunnelConfigsFlow(): Flow<TunnelConfigs>
 
 	suspend fun getAll(): TunnelConfigs

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

@@ -0,0 +1,30 @@
+package com.zaneschepke.wireguardautotunnel.module
+
+import android.content.Context
+import com.zaneschepke.logcatter.LocalLogCollector
+import com.zaneschepke.logcatter.LogcatUtil
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+class AppModule {
+	@Singleton
+	@ApplicationScope
+	@Provides
+	fun providesApplicationScope(@DefaultDispatcher defaultDispatcher: CoroutineDispatcher): CoroutineScope =
+		CoroutineScope(SupervisorJob() + defaultDispatcher)
+
+	@Singleton
+	@Provides
+	fun provideLogCollect(@ApplicationContext context: Context): LocalLogCollector {
+		return LogcatUtil.init(context = context)
+	}
+}

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

@@ -2,6 +2,10 @@ package com.zaneschepke.wireguardautotunnel.module
 
 import javax.inject.Qualifier
 
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class Kernel
+
 @Qualifier
 @Retention(AnnotationRetention.BINARY)
 annotation class Userspace

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

@@ -0,0 +1,27 @@
+package com.zaneschepke.wireguardautotunnel.module
+
+import javax.inject.Qualifier
+
+@Retention(AnnotationRetention.RUNTIME)
+@Qualifier
+annotation class DefaultDispatcher
+
+@Retention(AnnotationRetention.RUNTIME)
+@Qualifier
+annotation class IoDispatcher
+
+@Retention(AnnotationRetention.RUNTIME)
+@Qualifier
+annotation class MainDispatcher
+
+@Retention(AnnotationRetention.BINARY)
+@Qualifier
+annotation class MainImmediateDispatcher
+
+@Retention(AnnotationRetention.RUNTIME)
+@Qualifier
+annotation class ApplicationScope
+
+@Retention(AnnotationRetention.RUNTIME)
+@Qualifier
+annotation class ServiceScope

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

@@ -0,0 +1,28 @@
+package com.zaneschepke.wireguardautotunnel.module
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+
+@Module
+@InstallIn(SingletonComponent::class)
+object CoroutinesDispatchersModule {
+	@DefaultDispatcher
+	@Provides
+	fun providesDefaultDispatcher(): CoroutineDispatcher = Dispatchers.Default
+
+	@IoDispatcher
+	@Provides
+	fun providesIoDispatcher(): CoroutineDispatcher = Dispatchers.IO
+
+	@MainDispatcher
+	@Provides
+	fun providesMainDispatcher(): CoroutineDispatcher = Dispatchers.Main
+
+	@MainImmediateDispatcher
+	@Provides
+	fun providesMainImmediateDispatcher(): CoroutineDispatcher = Dispatchers.Main.immediate
+}

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

@@ -1,30 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.module
-
-import android.content.Context
-import androidx.room.Room
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.AppDatabase
-import com.zaneschepke.wireguardautotunnel.data.DatabaseCallback
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-class DatabaseModule {
-    @Provides
-    @Singleton
-    fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
-        return Room.databaseBuilder(
-            context,
-            AppDatabase::class.java,
-            context.getString(R.string.db_name),
-        )
-            .fallbackToDestructiveMigration()
-            .addCallback(DatabaseCallback())
-            .build()
-    }
-}

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

@@ -1,7 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.module
-
-import javax.inject.Qualifier
-
-@Qualifier
-@Retention(AnnotationRetention.BINARY)
-annotation class Kernel

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

@@ -1,7 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.module
 
 import android.content.Context
+import androidx.room.Room
+import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import com.zaneschepke.wireguardautotunnel.data.DatabaseCallback
 import com.zaneschepke.wireguardautotunnel.data.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
 import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
@@ -18,11 +21,25 @@ import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineDispatcher
 import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
 class RepositoryModule {
+	@Provides
+	@Singleton
+	fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
+		return Room.databaseBuilder(
+			context,
+			AppDatabase::class.java,
+			context.getString(R.string.db_name),
+		)
+			.fallbackToDestructiveMigration()
+			.addCallback(DatabaseCallback())
+			.build()
+	}
+
 	@Singleton
 	@Provides
 	fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
@@ -49,8 +66,8 @@ class RepositoryModule {
 
 	@Singleton
 	@Provides
-    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStoreManager {
+	fun providePreferencesDataStore(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): DataStoreManager {
-        return DataStoreManager(context)
+		return DataStoreManager(context, ioDispatcher)
 	}
 
 	@Provides
@@ -64,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(
+	abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification): NotificationService
-        wireGuardNotification: WireGuardNotification
-    ): NotificationService
 
 	@Binds
 	@ServiceScoped
@@ -27,13 +25,9 @@ abstract class ServiceModule {
 
 	@Binds
 	@ServiceScoped
-    abstract fun provideMobileDataService(
+	abstract fun provideMobileDataService(mobileDataService: MobileDataService): NetworkService<MobileDataService>
-        mobileDataService: MobileDataService
-    ): NetworkService<MobileDataService>
 
 	@Binds
 	@ServiceScoped
-    abstract fun provideEthernetService(
+	abstract fun provideEthernetService(ethernetService: EthernetService): NetworkService<EthernetService>
-        ethernetService: EthernetService
-    ): NetworkService<EthernetService>
 }

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

@@ -15,6 +15,9 @@ import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import javax.inject.Provider
 import javax.inject.Singleton
 
 @Module
@@ -49,17 +52,26 @@ class TunnelModule {
 	@Provides
 	@Singleton
 	fun provideVpnService(
-        amneziaBackend: org.amnezia.awg.backend.Backend,
+		amneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
-        @Userspace userspaceBackend: Backend,
+		@Userspace userspaceBackend: Provider<Backend>,
-        @Kernel kernelBackend: Backend,
+		@Kernel kernelBackend: Provider<Backend>,
-        appDataRepository: AppDataRepository
+		appDataRepository: AppDataRepository,
+		@ApplicationScope applicationScope: CoroutineScope,
+		@IoDispatcher ioDispatcher: CoroutineDispatcher,
 	): VpnService {
-        return WireGuardTunnel(amneziaBackend,userspaceBackend, kernelBackend, appDataRepository)
+		return WireGuardTunnel(
+			amneziaBackend,
+			userspaceBackend,
+			kernelBackend,
+			appDataRepository,
+			applicationScope,
+			ioDispatcher,
+		)
 	}
 
 	@Provides
 	@Singleton
-    fun provideServiceManager(appDataRepository: AppDataRepository): ServiceManager {
+	fun provideServiceManager(appDataRepository: AppDataRepository, @IoDispatcher ioDispatcher: CoroutineDispatcher): ServiceManager {
-        return ServiceManager(appDataRepository)
+		return ServiceManager(appDataRepository, ioDispatcher)
 	}
 }

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

@@ -0,0 +1,21 @@
+package com.zaneschepke.wireguardautotunnel.module
+
+import android.content.Context
+import com.zaneschepke.wireguardautotunnel.util.FileUtils
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ViewModelComponent
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.scopes.ViewModelScoped
+import kotlinx.coroutines.CoroutineDispatcher
+
+@Module
+@InstallIn(ViewModelComponent::class)
+class ViewModelModule {
+	@ViewModelScoped
+	@Provides
+	fun provideFileUtils(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): FileUtils {
+		return FileUtils(context, ioDispatcher)
+	}
+}

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

@@ -4,25 +4,32 @@ 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.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {
-
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
 	@Inject
 	lateinit var serviceManager: ServiceManager
 
-    override fun onReceive(context: Context?, intent: Intent?) = goAsync {
+	@Inject
-        if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return@goAsync
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	override fun onReceive(context: Context?, intent: Intent?) {
+		if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return
 		context?.run {
+			applicationScope.launch {
 				val settings = appDataRepository.settings.getSettings()
+				if (settings.isRestoreOnBootEnabled) {
 					if (settings.isAutoTunnelEnabled) {
 						Timber.i("Starting watcher service from boot")
 						serviceManager.startWatcherServiceForeground(context)
@@ -34,6 +41,7 @@ class BootReceiver : BroadcastReceiver() {
 								context,
 								appDataRepository.tunnels.getById(it)?.id,
 							)
+							return@launch
 						}
 					}
 					if (settings.isAlwaysOnVpnEnabled) {
@@ -43,3 +51,5 @@ class BootReceiver : BroadcastReceiver() {
 				}
 			}
 		}
+	}
+}

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

@@ -4,12 +4,14 @@ 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 com.zaneschepke.wireguardautotunnel.util.goAsync
 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
 
@@ -21,7 +23,12 @@ class NotificationActionReceiver : BroadcastReceiver() {
 	@Inject
 	lateinit var serviceManager: ServiceManager
 
-    override fun onReceive(context: Context, intent: Intent?) = goAsync {
+	@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)
@@ -34,3 +41,4 @@ class NotificationActionReceiver : BroadcastReceiver() {
 			}
 		}
 	}
+}

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/ForegroundService.kt

@@ -23,7 +23,9 @@ 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 -> {
 					Timber.i("Always-on VPN starting service")

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

@@ -4,17 +4,17 @@ 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) {
+class ServiceManager(
-
+	private val appDataRepository: AppDataRepository,
-    private fun <T : Service> actionOnService(
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-        action: Action,
-        context: Context,
-        cls: Class<T>,
-        extras: Map<String, Int>? = null
 ) {
+	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
@@ -23,7 +23,11 @@ class ServiceManager(private val appDataRepository: AppDataRepository) {
 		intent.component?.javaClass
 		try {
 			when (action) {
-                Action.START_FOREGROUND, Action.STOP_FOREGROUND -> context.startForegroundService(intent)
+				Action.START_FOREGROUND, Action.STOP_FOREGROUND ->
+					context.startForegroundService(
+						intent,
+					)
+
 				Action.START, Action.STOP -> context.startService(intent)
 			}
 		} catch (e: Exception) {
@@ -31,11 +35,7 @@ class ServiceManager(private val appDataRepository: AppDataRepository) {
 		}
 	}
 
-    suspend fun startVpnService(
+	suspend fun startVpnService(context: Context, tunnelId: Int? = null, isManualStart: Boolean = false) {
-        context: Context,
-        tunnelId: Int? = null,
-        isManualStart: Boolean = false
-    ) {
 		if (isManualStart) onManualStart(tunnelId)
 		actionOnService(
 			Action.START,
@@ -46,6 +46,7 @@ class ServiceManager(private val appDataRepository: AppDataRepository) {
 	}
 
 	suspend fun stopVpnServiceForeground(context: Context, isManualStop: Boolean = false) {
+		withContext(ioDispatcher) {
 			if (isManualStop) onManualStop()
 			Timber.i("Stopping vpn service")
 			actionOnService(
@@ -54,8 +55,10 @@ class ServiceManager(private val appDataRepository: AppDataRepository) {
 				WireGuardTunnelService::class.java,
 			)
 		}
+	}
 
 	suspend fun stopVpnService(context: Context, isManualStop: Boolean = false) {
+		withContext(ioDispatcher) {
 			if (isManualStop) onManualStop()
 			Timber.i("Stopping vpn service")
 			actionOnService(
@@ -64,6 +67,7 @@ class ServiceManager(private val appDataRepository: AppDataRepository) {
 				WireGuardTunnelService::class.java,
 			)
 		}
+	}
 
 	private suspend fun onManualStop() {
 		appDataRepository.appState.setManualStop()
@@ -75,11 +79,8 @@ class ServiceManager(private val appDataRepository: AppDataRepository) {
 		}
 	}
 
-    suspend fun startVpnServiceForeground(
+	suspend fun startVpnServiceForeground(context: Context, tunnelId: Int? = null, isManualStart: Boolean = false) {
-        context: Context,
+		withContext(ioDispatcher) {
-        tunnelId: Int? = null,
-        isManualStart: Boolean = false
-    ) {
 			if (isManualStart) onManualStart(tunnelId)
 			actionOnService(
 				Action.START_FOREGROUND,
@@ -88,10 +89,9 @@ class ServiceManager(private val appDataRepository: AppDataRepository) {
 				tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
 			)
 		}
+	}
 
-    fun startWatcherServiceForeground(
+	fun startWatcherServiceForeground(context: Context) {
-        context: Context,
-    ) {
 		actionOnService(
 			Action.START_FOREGROUND,
 			context,

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

@@ -7,57 +7,67 @@ data class WatcherState(
 	val isEthernetConnected: Boolean = false,
 	val isMobileDataConnected: Boolean = false,
 	val currentNetworkSSID: String = "",
-    val settings: Settings = Settings()
+	val settings: Settings = Settings(),
 ) {
 	fun isEthernetConditionMet(): Boolean {
-        return (isEthernetConnected &&
+		return (
-            settings.isTunnelOnEthernetEnabled)
+			isEthernetConnected &&
+				settings.isTunnelOnEthernetEnabled
+			)
 	}
 
 	fun isMobileDataConditionMet(): Boolean {
-        return (!isEthernetConnected &&
+		return (
+			!isEthernetConnected &&
 				settings.isTunnelOnMobileDataEnabled &&
 				!isWifiConnected &&
-            isMobileDataConnected)
+				isMobileDataConnected
-    }
+			)
-
-    fun isTunnelOnMobileDataPreferredConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            settings.isTunnelOnMobileDataEnabled &&
-            !isWifiConnected &&
-            isMobileDataConnected)
 	}
 
 	fun isTunnelOffOnMobileDataConditionMet(): Boolean {
-        return (!isEthernetConnected &&
+		return (
+			!isEthernetConnected &&
 				!settings.isTunnelOnMobileDataEnabled &&
 				isMobileDataConnected &&
-            !isWifiConnected)
+				!isWifiConnected
+			)
 	}
 
 	fun isUntrustedWifiConditionMet(): Boolean {
-        return (!isEthernetConnected &&
+		return (
+			!isEthernetConnected &&
 				isWifiConnected &&
 				!settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
-            settings.isTunnelOnWifiEnabled)
+				settings.isTunnelOnWifiEnabled
+			)
 	}
 
 	fun isTrustedWifiConditionMet(): Boolean {
-        return (!isEthernetConnected &&
+		return (
-            (isWifiConnected &&
+			!isEthernetConnected &&
-                settings.trustedNetworkSSIDs.contains(currentNetworkSSID)))
+				(
+					isWifiConnected &&
+						settings.trustedNetworkSSIDs.contains(currentNetworkSSID)
+					)
+			)
 	}
 
 	fun isTunnelOffOnWifiConditionMet(): Boolean {
-        return (!isEthernetConnected &&
+		return (
-            (isWifiConnected &&
+			!isEthernetConnected &&
-                !settings.isTunnelOnWifiEnabled))
+				(
+					isWifiConnected &&
+						!settings.isTunnelOnWifiEnabled
+					)
+			)
 	}
 
 	fun isTunnelOffOnNoConnectivityMet(): Boolean {
-        return (!isEthernetConnected &&
+		return (
+			!isEthernetConnected &&
 				!isWifiConnected &&
-            !isMobileDataConnected)
+				!isMobileDataConnected
+			)
 	}
 }
-

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

@@ -8,6 +8,8 @@ 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
@@ -19,18 +21,18 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.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
@@ -56,6 +58,14 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 	@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
@@ -65,11 +75,13 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 
 	override fun onCreate() {
 		super.onCreate()
-        lifecycleScope.launch(Dispatchers.Main) {
+		lifecycleScope.launch(mainImmediateDispatcher) {
 			try {
 				if (appDataRepository.settings.getSettings().isAutoTunnelPaused) {
 					launchWatcherPausedNotification()
-                } else launchWatcherNotification()
+				} else {
+					launchWatcherNotification()
+				}
 			} catch (e: Exception) {
 				Timber.e("Failed to start watcher service, not enough permissions")
 			}
@@ -99,9 +111,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 		stopSelf()
 	}
 
-    private fun launchWatcherNotification(
+	private fun launchWatcherNotification(description: String = getString(R.string.watcher_notification_text_active)) {
-        description: String = getString(R.string.watcher_notification_text_active)
-    ) {
 		val notification =
 			notificationService.createNotification(
 				channelId = getString(R.string.watcher_channel_id),
@@ -145,7 +155,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 
 	private fun startWatcherJob() {
 		watcherJob =
-            lifecycleScope.launch(Dispatchers.IO) {
+			lifecycleScope.launch {
 				val setting = appDataRepository.settings.getSettings()
 				launch {
 					Timber.i("Starting wifi watcher")
@@ -177,11 +187,11 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 					Timber.i("Starting management watcher")
 					manageVpn()
 				}
-
 			}
 	}
 
 	private suspend fun watchForMobileDataConnectivityChanges() {
+		withContext(ioDispatcher) {
 			mobileDataService.networkStatus.collect { status ->
 				when (status) {
 					is NetworkStatus.Available -> {
@@ -213,30 +223,39 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 				}
 			}
 		}
+	}
 
 	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 results =
-                            val host = if (peer.endpoint.isPresent &&
+								config.peers.map { peer ->
-                                peer.endpoint.get().resolved.isPresent)
+									val host =
+										if (peer.endpoint.isPresent &&
+											peer.endpoint.get().resolved.isPresent
+										) {
 											peer.endpoint.get().resolved.get().host
-                            else Constants.DEFAULT_PING_IP
+										} else {
+											Constants.DEFAULT_PING_IP
+										}
 									Timber.i("Checking reachability of: $host")
-                            val reachable = InetAddress.getByName(host)
+									val reachable =
+										InetAddress.getByName(host)
 											.isReachable(Constants.PING_TIMEOUT.toInt())
 									Timber.i("Result: reachable - $reachable")
 									reachable
 								}
 							if (results.contains(false)) {
 								Timber.i("Restarting VPN for ping failure")
-                            serviceManager.stopVpnServiceForeground(this)
+								serviceManager.stopVpnServiceForeground(context)
 								delay(Constants.VPN_RESTART_DELAY)
-                            serviceManager.startVpnServiceForeground(this, it.id)
+								serviceManager.startVpnServiceForeground(context, it.id)
 								delay(Constants.PING_COOLDOWN)
 							}
 						}
@@ -247,10 +266,13 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 				Timber.e(e)
 			}
 		}
+	}
 
 	private suspend fun watchForSettingsChanges() {
 		appDataRepository.settings.getSettingsFlow().collect { settings ->
-            if (networkEventsFlow.value.settings.isAutoTunnelPaused != settings.isAutoTunnelPaused) {
+			if (networkEventsFlow.value.settings.isAutoTunnelPaused
+				!= settings.isAutoTunnelPaused
+			) {
 				when (settings.isAutoTunnelPaused) {
 					true -> launchWatcherPausedNotification()
 					false -> launchWatcherNotification()
@@ -265,6 +287,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 	}
 
 	private suspend fun watchForEthernetConnectivityChanges() {
+		withContext(ioDispatcher) {
 			ethernetService.networkStatus.collect { status ->
 				when (status) {
 					is NetworkStatus.Available -> {
@@ -296,8 +319,10 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 				}
 			}
 		}
+	}
 
 	private suspend fun watchForWifiConnectivityChanges() {
+		withContext(ioDispatcher) {
 			wifiService.networkStatus.collect { status ->
 				when (status) {
 					is NetworkStatus.Available -> {
@@ -308,6 +333,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 							)
 						}
 					}
+
 					is NetworkStatus.CapabilitiesChanged -> {
 						Timber.i("Wifi capabilities changed")
 						networkEventsFlow.update {
@@ -319,7 +345,9 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 						ssid?.let { name ->
 							if (name.contains(Constants.UNREADABLE_SSID)) {
 								Timber.w("SSID unreadable: missing permissions")
-                        } else Timber.i("Detected valid SSID")
+							} else {
+								Timber.i("Detected valid SSID")
+							}
 							appDataRepository.appState.setCurrentSsid(name)
 							networkEventsFlow.update {
 								it.copy(
@@ -340,6 +368,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 				}
 			}
 		}
+	}
 
 	private suspend fun getMobileDataTunnel(): TunnelConfig? {
 		return appDataRepository.tunnels.findByMobileDataTunnel().firstOrNull()
@@ -354,6 +383,8 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 	}
 
 	private suspend fun manageVpn() {
+		val context = this
+		withContext(ioDispatcher) {
 			networkEventsFlow.collectLatest { watcherState ->
 				val autoTunnel = "Auto-tunnel watcher"
 				if (!watcherState.settings.isAutoTunnelPaused) {
@@ -363,60 +394,73 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 					when {
 						watcherState.isEthernetConditionMet() -> {
 							Timber.i("$autoTunnel - tunnel on on ethernet condition met")
-                        if(isTunnelDown()) serviceManager.startVpnServiceForeground(this)
+							if (isTunnelDown()) serviceManager.startVpnServiceForeground(context)
 						}
 
 						watcherState.isMobileDataConditionMet() -> {
-                        Timber.i("$autoTunnel - tunnel on on mobile data condition met")
+							Timber.i("$autoTunnel - tunnel on mobile data condition met")
-                        if(isTunnelDown()) serviceManager.startVpnServiceForeground(this, getMobileDataTunnel()?.id)
+							val mobileDataTunnel = getMobileDataTunnel()
-                    }
+							val tunnel =
-
+								mobileDataTunnel ?: appDataRepository.getPrimaryOrFirstTunnel()
-                    watcherState.isTunnelOnMobileDataPreferredConditionMet() -> {
+							if (isTunnelDown() || tunnelConfig?.isMobileDataTunnel == false) {
-                        if(tunnelConfig?.isMobileDataTunnel == false) {
+								serviceManager.startVpnServiceForeground(
-                            getMobileDataTunnel()?.let {
+									context,
-                                Timber.i("$autoTunnel - tunnel connected on mobile data is not preferred condition met, switching to preferred")
+									tunnel?.id,
-                                if(isTunnelDown()) serviceManager.startVpnServiceForeground(
-                                    this,
-                                    getMobileDataTunnel()?.id,
 								)
 							}
 						}
-                    }
 
 						watcherState.isTunnelOffOnMobileDataConditionMet() -> {
 							Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
-                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
+							if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
 						}
 
 						watcherState.isUntrustedWifiConditionMet() -> {
 							if (tunnelConfig?.tunnelNetworks?.contains(watcherState.currentNetworkSSID) == false ||
-                            tunnelConfig == null) {
+								tunnelConfig == null
-                            Timber.i("$autoTunnel - tunnel on ssid not associated with current tunnel condition met")
+							) {
+								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")
+									Timber.i("Found tunnel associated with this SSID, bringing tunnel up: ${it.name}")
-                                if(isTunnelDown()) serviceManager.startVpnServiceForeground(this, it.id)
+									if (isTunnelDown() || tunnelConfig?.id != it.id) {
+										serviceManager.startVpnServiceForeground(
+											context,
+											it.id,
+										)
+									}
 								} ?: suspend {
 									Timber.i("No tunnel associated with this SSID, using defaults")
-                                if (appDataRepository.getPrimaryOrFirstTunnel()?.name != vpnService.name) {
+									val default = appDataRepository.getPrimaryOrFirstTunnel()
-                                    if(isTunnelDown()) serviceManager.startVpnServiceForeground(this)
+									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")
+							Timber.i(
-                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
+								"$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")
+							Timber.i(
-                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
+								"$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")
+							Timber.i(
-                        if(!isTunnelDown()) serviceManager.stopVpnServiceForeground(this)
+								"$autoTunnel - tunnel off on no connectivity met, turning vpn off",
+							)
+							if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
 						}
 
 						else -> {
@@ -427,3 +471,4 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 			}
 		}
 	}
+}

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

@@ -7,6 +7,8 @@ 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
@@ -17,10 +19,11 @@ import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
 import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.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
 
@@ -37,13 +40,21 @@ class WireGuardTunnelService : ForegroundService() {
 	@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(Dispatchers.Main) {
+		lifecycleScope.launch(mainImmediateDispatcher) {
 			// TODO fix this to not launch if AOVPN
 			if (appDataRepository.tunnels.count() != 0) {
 				launchVpnNotification()
@@ -55,7 +66,7 @@ class WireGuardTunnelService : ForegroundService() {
 		super.startService(extras)
 		cancelJob()
 		job =
-            lifecycleScope.launch(Dispatchers.IO) {
+			lifecycleScope.launch {
 				launch {
 					val tunnelId = extras?.getInt(Constants.TUNNEL_EXTRA_KEY)
 					if (vpnService.getState() == TunnelState.UP) {
@@ -75,6 +86,7 @@ class WireGuardTunnelService : ForegroundService() {
 
 	// TODO improve tunnel notifications
 	private suspend fun handshakeNotifications() {
+		withContext(ioDispatcher) {
 			var tunnelName: String? = null
 			vpnService.vpnState.collect { state ->
 				state.statistics
@@ -111,6 +123,7 @@ class WireGuardTunnelService : ForegroundService() {
 				}
 			}
 		}
+	}
 
 	private fun launchAlwaysOnDisabledNotification() {
 		launchVpnNotification(
@@ -121,7 +134,7 @@ class WireGuardTunnelService : ForegroundService() {
 
 	override fun stopService() {
 		super.stopService()
-        lifecycleScope.launch(Dispatchers.IO) {
+		lifecycleScope.launch {
 			vpnService.stopTunnel()
 			didShowConnected = false
 		}
@@ -129,10 +142,7 @@ class WireGuardTunnelService : ForegroundService() {
 		stopSelf()
 	}
 
-    private fun launchVpnNotification(
+	private fun launchVpnNotification(title: String = getString(R.string.vpn_starting), description: String = getString(R.string.attempt_connection)) {
-        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),

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(
+							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
-                            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(
+							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
-                            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

@@ -2,45 +2,53 @@ package com.zaneschepke.wireguardautotunnel.service.shortcut
 
 import android.os.Bundle
 import androidx.activity.ComponentActivity
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 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 dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class ShortcutsActivity : ComponentActivity() {
-
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
 	@Inject
 	lateinit var serviceManager: ServiceManager
 
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
-        WireGuardAutoTunnel.applicationScope.launch(Dispatchers.IO) {
+		applicationScope.launch {
 			val settings = appDataRepository.settings.getSettings()
 			if (settings.isShortcutsEnabled) {
 				when (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)) {
 					WireGuardTunnelService::class.java.simpleName -> {
 						val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
-                        val tunnelConfig = tunnelName?.let {
+						val tunnelConfig =
+							tunnelName?.let {
 								appDataRepository.tunnels.getAll().firstOrNull {
 									it.name == tunnelName
 								}
 							}
 						when (intent.action) {
-                            Action.START.name -> serviceManager.startVpnServiceForeground(
+							Action.START.name ->
-                                this@ShortcutsActivity, tunnelConfig?.id, isManualStart = true,
+								serviceManager.startVpnServiceForeground(
+									this@ShortcutsActivity,
+									tunnelConfig?.id,
+									isManualStart = true,
 								)
 
-                            Action.STOP.name -> serviceManager.stopVpnServiceForeground(
+							Action.STOP.name ->
+								serviceManager.stopVpnServiceForeground(
 									this@ShortcutsActivity,
 									isManualStop = true,
 								)
@@ -49,13 +57,15 @@ class ShortcutsActivity : ComponentActivity() {
 
 					WireGuardConnectivityWatcherService::class.java.simpleName -> {
 						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,
 									),

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

@@ -3,39 +3,39 @@ 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.ServiceLifecycleDispatcher
+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.service.foreground.ServiceManager
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
-import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
-class AutoTunnelControlTile : TileService() {
+class AutoTunnelControlTile : TileService(), LifecycleOwner {
-
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
 	@Inject
 	lateinit var serviceManager: ServiceManager
 
-    private val scope = CoroutineScope(Dispatchers.IO)
+	private val dispatcher = ServiceLifecycleDispatcher(this)
 
 	private var manualStartConfig: TunnelConfig? = null
 
 	override fun onStartListening() {
 		super.onStartListening()
-        scope.launch {
+		lifecycleScope.launch {
-            appDataRepository.settings.getSettingsFlow().collectLatest {
+			val settings = appDataRepository.settings.getSettings()
-                when (it.isAutoTunnelEnabled) {
+			when (settings.isAutoTunnelEnabled) {
 				true -> {
-                        if (it.isAutoTunnelPaused) {
+					if (settings.isAutoTunnelPaused) {
 						setInactive()
 						setTileDescription(this@AutoTunnelControlTile.getString(R.string.paused))
 					} else {
@@ -51,29 +51,19 @@ class AutoTunnelControlTile : TileService() {
 			}
 		}
 	}
-    }
 
 	override fun onTileAdded() {
 		super.onTileAdded()
 		onStartListening()
 	}
 
-    override fun onDestroy() {
-        super.onDestroy()
-        scope.cancel()
-    }
-
-    override fun onTileRemoved() {
-        super.onTileRemoved()
-        scope.cancel()
-    }
-
 	override fun onClick() {
 		super.onClick()
 		unlockAndRun {
-            scope.launch {
+			lifecycleScope.launch {
 				try {
 					appDataRepository.toggleWatcherServicePause()
+					onStartListening()
 				} catch (e: Exception) {
 					Timber.e(e.message)
 				} finally {
@@ -108,4 +98,7 @@ class AutoTunnelControlTile : TileService() {
 		}
 		qsTile.updateTile()
 	}
+
+	override val lifecycle: Lifecycle
+		get() = dispatcher.lifecycle
 }

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

@@ -3,22 +3,23 @@ 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.ServiceLifecycleDispatcher
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
-class TunnelControlTile : TileService() {
+class TunnelControlTile : TileService(), LifecycleOwner {
-
 	@Inject
 	lateinit var appDataRepository: AppDataRepository
 
@@ -28,45 +29,35 @@ class TunnelControlTile : TileService() {
 	@Inject
 	lateinit var serviceManager: ServiceManager
 
-    private val scope = CoroutineScope(Dispatchers.IO)
+	private val dispatcher = ServiceLifecycleDispatcher(this)
 
 	private var manualStartConfig: TunnelConfig? = null
 
 	override fun onStartListening() {
 		super.onStartListening()
 		Timber.d("On start listening called")
-        scope.launch {
+		lifecycleScope.launch {
-            vpnService.vpnState.collect { it ->
+			when (vpnService.getState()) {
-                when (it.status) {
 				TunnelState.UP -> {
 					setActive()
-                        it.tunnelConfig?.name?.let { name -> setTileDescription(name) }
+					setTileDescription(vpnService.name)
 				}
 
 				TunnelState.DOWN -> {
 					setInactive()
-                        val config = appDataRepository.getStartTunnelConfig()?.also { config ->
+					val config =
+						appDataRepository.getStartTunnelConfig()?.also { config ->
 							manualStartConfig = config
 						} ?: appDataRepository.getPrimaryOrFirstTunnel()
 					config?.let {
 						setTileDescription(it.name)
 					} ?: setUnavailable()
 				}
+
 				else -> setInactive()
 			}
 		}
 	}
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        scope.cancel()
-    }
-
-    override fun onTileRemoved() {
-        super.onTileRemoved()
-        scope.cancel()
-    }
 
 	override fun onTileAdded() {
 		super.onTileAdded()
@@ -76,7 +67,7 @@ class TunnelControlTile : TileService() {
 	override fun onClick() {
 		super.onClick()
 		unlockAndRun {
-            scope.launch {
+			lifecycleScope.launch {
 				try {
 					if (vpnService.getState() == TunnelState.UP) {
 						serviceManager.stopVpnServiceForeground(
@@ -85,7 +76,9 @@ class TunnelControlTile : TileService() {
 						)
 					} else {
 						serviceManager.startVpnServiceForeground(
-                            this@TunnelControlTile, manualStartConfig?.id, isManualStart = true,
+							this@TunnelControlTile,
+							manualStartConfig?.id,
+							isManualStart = true,
 						)
 					}
 				} catch (e: Exception) {
@@ -122,4 +115,7 @@ class TunnelControlTile : TileService() {
 		}
 		qsTile.updateTile()
 	}
+
+	override val lifecycle: Lifecycle
+		get() = dispatcher.lifecycle
 }

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/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) {
@@ -31,6 +32,7 @@ enum class TunnelState {
 				Tunnel.State.UP -> UP
 			}
 		}
+
 		fun from(state: org.amnezia.awg.backend.Tunnel.State): TunnelState {
 			return when (state) {
 				org.amnezia.awg.backend.Tunnel.State.DOWN -> DOWN

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

@@ -6,6 +6,8 @@ import com.wireguard.android.backend.Tunnel.State
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.module.Kernel
 import com.zaneschepke.wireguardautotunnel.module.Userspace
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.AmneziaStatistics
@@ -13,54 +15,52 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStati
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.WireGuardStatistics
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 class WireGuardTunnel
 @Inject
 constructor(
-    private val userspaceAmneziaBackend : org.amnezia.awg.backend.Backend,
+	private val userspaceAmneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
-    @Userspace private val userspaceBackend: Backend,
+	@Userspace private val userspaceBackend: Provider<Backend>,
-    @Kernel private val kernelBackend: Backend,
+	@Kernel private val kernelBackend: Provider<Backend>,
 	private val appDataRepository: AppDataRepository,
+	@ApplicationScope private val applicationScope: CoroutineScope,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : VpnService {
 	private val _vpnState = MutableStateFlow(VpnState())
 	override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()
 
-    private val scope = CoroutineScope(Dispatchers.IO)
-
 	private var statsJob: Job? = null
 
-    private var backend: Backend = userspaceBackend
-
 	private var backendIsWgUserspace = true
 
 	private var backendIsAmneziaUserspace = false
 
 	init {
-        scope.launch {
+		applicationScope.launch(ioDispatcher) {
 			appDataRepository.settings.getSettingsFlow().collect {
 				if (it.isKernelEnabled && (backendIsWgUserspace || backendIsAmneziaUserspace)) {
-                    Timber.d("Setting kernel backend")
+					Timber.i("Setting kernel backend")
-                    backend = kernelBackend
 					backendIsWgUserspace = false
 					backendIsAmneziaUserspace = false
 				} else if (!it.isKernelEnabled && !it.isAmneziaEnabled && !backendIsWgUserspace) {
-                    Timber.d("Setting WireGuard userspace backend")
+					Timber.i("Setting WireGuard userspace backend")
-                    backend = userspaceBackend
 					backendIsWgUserspace = true
 					backendIsAmneziaUserspace = false
 				} else if (it.isAmneziaEnabled && !backendIsAmneziaUserspace) {
-                    Timber.d("Setting Amnezia userspace backend")
+					Timber.i("Setting Amnezia userspace backend")
 					backendIsAmneziaUserspace = true
 					backendIsWgUserspace = false
 				}
@@ -71,18 +71,25 @@ constructor(
 	private fun setState(tunnelConfig: TunnelConfig?, tunnelState: TunnelState): TunnelState {
 		return if (backendIsAmneziaUserspace) {
 			Timber.i("Using Amnezia backend")
-            val config = tunnelConfig?.let {
+			val config =
-                if(it.amQuick != "") TunnelConfig.configFromAmQuick(it.amQuick) else {
+				tunnelConfig?.let {
-                    Timber.w("Using backwards compatible wg config, amnezia specific config not found.")
+					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.setState(this, tunnelState.toAmState(), config)
+			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(
+			val state =
+				backend().setState(
 					this,
 					tunnelState.toWgState(),
 					wgConfig,
@@ -92,18 +99,39 @@ constructor(
 	}
 
 	override suspend fun startTunnel(tunnelConfig: TunnelConfig?): TunnelState {
-        return try {
+		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")
+				} else {
+					throw Exception("No tunnels")
+				}
 			} catch (e: BackendException) {
 				Timber.e("Failed to start tunnel with error: ${e.message}")
 				TunnelState.from(State.DOWN)
 			}
 		}
+	}
+
+	private fun backend(): Backend {
+		return when {
+			backendIsWgUserspace -> {
+				userspaceBackend.get()
+			}
+
+			!backendIsWgUserspace && !backendIsAmneziaUserspace -> {
+				kernelBackend.get()
+			}
+
+			else -> {
+				userspaceBackend.get()
+			}
+		}
+	}
 
 	private fun emitTunnelState(state: TunnelState) {
 		_vpnState.tryEmit(
@@ -134,6 +162,7 @@ constructor(
 	}
 
 	override suspend fun stopTunnel() {
+		withContext(ioDispatcher) {
 			try {
 				if (getState() == TunnelState.UP) {
 					val state = setState(null, TunnelState.DOWN)
@@ -146,37 +175,31 @@ constructor(
 				Timber.e("Failed to stop amnezia tunnel with error: ${e.message}")
 			}
 		}
+	}
 
 	override fun getState(): TunnelState {
-        return if(backendIsAmneziaUserspace) TunnelState.from(userspaceAmneziaBackend.getState(this))
+		return if (backendIsAmneziaUserspace) {
-        else TunnelState.from(backend.getState(this))
+			TunnelState.from(
+				userspaceAmneziaBackend.get().getState(this),
+			)
+		} else {
+			TunnelState.from(backend().getState(this))
+		}
 	}
 
 	override fun getName(): String {
 		return _vpnState.value.tunnelConfig?.name ?: ""
 	}
 
-
 	override fun onStateChange(newState: Tunnel.State) {
 		handleStateChange(TunnelState.from(newState))
 	}
 
 	private fun handleStateChange(state: TunnelState) {
-        val tunnel = this
 		emitTunnelState(state)
 		WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
 		if (state == TunnelState.UP) {
-            statsJob =
+			statsJob = startTunnelStatisticsJob()
-                scope.launch {
-                    while (true) {
-                        if(backendIsAmneziaUserspace) {
-                            emitBackendStatistics(AmneziaStatistics(userspaceAmneziaBackend.getStatistics(tunnel)))
-                        } else {
-                            emitBackendStatistics(WireGuardStatistics(backend.getStatistics(tunnel)))
-                        }
-                        delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
-                    }
-                }
 		}
 		if (state == TunnelState.DOWN) {
 			try {
@@ -187,6 +210,23 @@ constructor(
 		}
 	}
 
+	private fun startTunnelStatisticsJob() = applicationScope.launch(ioDispatcher) {
+		while (true) {
+			if (backendIsAmneziaUserspace) {
+				emitBackendStatistics(
+					AmneziaStatistics(
+						userspaceAmneziaBackend.get().getStatistics(this@WireGuardTunnel),
+					),
+				)
+			} else {
+				emitBackendStatistics(
+					WireGuardStatistics(backend().getStatistics(this@WireGuardTunnel)),
+				)
+			}
+			delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
+		}
+	}
+
 	override fun onStateChange(state: State) {
 		handleStateChange(TunnelState.from(state))
 	}

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

@@ -11,7 +11,7 @@ class AmneziaStatistics(private val statistics: Statistics) : TunnelStatistics()
 			PeerStats(
 				rxBytes = stats.rxBytes,
 				txBytes = stats.txBytes,
-                latestHandshakeEpochMillis = stats.latestHandshakeEpochMillis
+				latestHandshakeEpochMillis = stats.latestHandshakeEpochMillis,
 			)
 		}
 	}

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

@@ -11,7 +11,7 @@ class WireGuardStatistics(private val statistics: Statistics) : TunnelStatistics
 			PeerStats(
 				txBytes = peerStats.txBytes,
 				rxBytes = peerStats.rxBytes,
-                latestHandshakeEpochMillis = peerStats.latestHandshakeEpochMillis
+				latestHandshakeEpochMillis = peerStats.latestHandshakeEpochMillis,
 			)
 		}
 	}

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

@@ -5,5 +5,5 @@ data class AppUiState(
 	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

@@ -4,42 +4,32 @@ import android.content.ActivityNotFoundException
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
-import android.widget.Toast
-import androidx.compose.runtime.mutableStateListOf
 import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
 import com.wireguard.android.backend.GoBackend
-import com.zaneschepke.logcatter.Logcatter
-import com.zaneschepke.logcatter.model.LogMessage
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
 import timber.log.Timber
-import java.time.Instant
 import javax.inject.Inject
 
 @HiltViewModel
 class AppViewModel
 @Inject
 constructor() : ViewModel() {
-
 	val vpnIntent: Intent? = GoBackend.VpnService.prepare(WireGuardAutoTunnel.instance)
 
-    private val _appUiState = MutableStateFlow(
+	private val _appUiState =
+		MutableStateFlow(
 			AppUiState(
 				vpnPermissionAccepted = vpnIntent == null,
 			),
 		)
 	val appUiState = _appUiState.asStateFlow()
 
-
 	fun isRequiredPermissionGranted(): Boolean {
 		val allAccepted =
 			(_appUiState.value.vpnPermissionAccepted && _appUiState.value.vpnPermissionAccepted)
@@ -50,7 +40,7 @@ constructor() : ViewModel() {
 	private fun requestPermissions() {
 		_appUiState.update {
 			it.copy(
-                requestPermissions = true
+				requestPermissions = true,
 			)
 		}
 	}
@@ -58,7 +48,7 @@ constructor() : ViewModel() {
 	fun permissionsRequested() {
 		_appUiState.update {
 			it.copy(
-                requestPermissions = false
+				requestPermissions = false,
 			)
 		}
 	}
@@ -66,7 +56,8 @@ constructor() : ViewModel() {
 	fun openWebPage(url: String, context: Context) {
 		try {
 			val webpage: Uri = Uri.parse(url)
-            val intent = Intent(Intent.ACTION_VIEW, webpage).apply {
+			val intent =
+				Intent(Intent.ACTION_VIEW, webpage).apply {
 					addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
 				}
 			context.startActivity(intent)
@@ -79,7 +70,7 @@ constructor() : ViewModel() {
 	fun onVpnPermissionAccepted() {
 		_appUiState.update {
 			it.copy(
-                vpnPermissionAccepted = true
+				vpnPermissionAccepted = true,
 			)
 		}
 	}
@@ -122,33 +113,6 @@ constructor() : ViewModel() {
 		}
 	}
 
-    val logs = mutableStateListOf<LogMessage>()
-
-    fun readLogCatOutput() =
-        viewModelScope.launch(viewModelScope.coroutineContext + Dispatchers.IO) {
-            launch {
-                Logcatter.logs(callback = {
-                    logs.add(it)
-                    if (logs.size > Constants.LOG_BUFFER_SIZE) {
-                        logs.removeRange(0, (logs.size - Constants.LOG_BUFFER_SIZE).toInt())
-                    }
-                })
-            }
-        }
-
-    fun clearLogs() {
-        logs.clear()
-        Logcatter.clear()
-    }
-
-    fun saveLogsToFile(context: Context) {
-        val fileName = "${Constants.BASE_LOG_FILE_NAME}-${Instant.now().epochSecond}.txt"
-        val content = logs.joinToString(separator = "\n")
-        FileUtils.saveFileToDownloads(context.applicationContext, content, fileName)
-        Toast.makeText(context, context.getString(R.string.logs_saved), Toast.LENGTH_SHORT)
-            .show()
-    }
-
 	fun setNotificationPermissionAccepted(accepted: Boolean) {
 		_appUiState.update {
 			it.copy(

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

@@ -1,5 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import com.journeyapps.barcodescanner.CaptureActivity
-
-class CaptureActivityPortrait : CaptureActivity()

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

@@ -10,6 +10,8 @@ import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.focusable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.MaterialTheme
@@ -19,15 +21,19 @@ import androidx.compose.material3.SnackbarDuration
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.SnackbarResult
+import androidx.compose.material3.Text
 import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusProperties
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -41,11 +47,13 @@ import androidx.navigation.navArgument
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
+import com.google.accompanist.permissions.shouldShowRationale
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+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.ui.common.dialog.InfoDialog
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.CustomSnackBar
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.ConfigScreen
@@ -61,14 +69,12 @@ import com.zaneschepke.wireguardautotunnel.util.StringValue
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
-
 	@Inject
-    lateinit var dataStoreManager: DataStoreManager
+	lateinit var appStateRepository: AppStateRepository
 
 	@Inject
 	lateinit var settingsRepository: SettingsRepository
@@ -82,26 +88,31 @@ class MainActivity : AppCompatActivity() {
 	override fun onCreate(savedInstanceState: Bundle?) {
 		super.onCreate(savedInstanceState)
 
+		val isPinLockEnabled = intent.extras?.getBoolean(SplashActivity.IS_PIN_LOCK_ENABLED_KEY)
+
 		enableEdgeToEdge(navigationBarStyle = SystemBarStyle.dark(Color.Transparent.toArgb()))
 
-        // load preferences into memory and init data
 		lifecycleScope.launch {
-            dataStoreManager.init()
 			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()
+			var showVpnPermissionDialog by remember { mutableStateOf(false) }
 
 			val notificationPermissionState =
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
+				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS) else null
+					rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS)
+				} else {
+					null
+				}
 
 			val snackbarHostState = remember { SnackbarHostState() }
 
@@ -112,6 +123,8 @@ class MainActivity : AppCompatActivity() {
 						val accepted = (it.resultCode == RESULT_OK)
 						if (accepted) {
 							appViewModel.onVpnPermissionAccepted()
+						} else {
+							showVpnPermissionDialog = true
 						}
 					},
 				)
@@ -125,7 +138,8 @@ class MainActivity : AppCompatActivity() {
 						)
 					when (result) {
 						SnackbarResult.ActionPerformed,
-                        SnackbarResult.Dismissed -> {
+						SnackbarResult.Dismissed,
+						-> {
 							snackbarHostState.currentSnackbarData?.dismiss()
 						}
 					}
@@ -137,15 +151,21 @@ class MainActivity : AppCompatActivity() {
 					appViewModel.permissionsRequested()
 					if (notificationPermissionState != null && !notificationPermissionState.status.isGranted
 					) {
-                        showSnackBarMessage(StringValue.StringResource(R.string.notification_permission_required))
+						notificationPermissionState.launchPermissionRequest()
-                        return@LaunchedEffect notificationPermissionState.launchPermissionRequest()
+						return@LaunchedEffect if (notificationPermissionState.status.shouldShowRationale || !notificationPermissionState.status.isGranted) {
+							showSnackBarMessage(
+								StringValue.StringResource(R.string.notification_permission_required),
+							)
+						} else {
+							Unit
+						}
 					}
 					if (!appUiState.vpnPermissionAccepted) {
 						return@LaunchedEffect appViewModel.vpnIntent?.let {
 							vpnActivityResultState.launch(
-                                it
+								it,
 							)
-                        }!!
+						} ?: Unit
 					}
 				}
 			}
@@ -155,7 +175,6 @@ class MainActivity : AppCompatActivity() {
 					appViewModel.setNotificationPermissionAccepted(
 						notificationPermissionState?.status?.isGranted ?: true,
 					)
-                    if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) appViewModel.readLogCatOutput()
 				}
 
 				LaunchedEffect(appUiState.snackbarMessageConsumed) {
@@ -167,6 +186,21 @@ class MainActivity : AppCompatActivity() {
 
 				val focusRequester = remember { FocusRequester() }
 
+				if (showVpnPermissionDialog) {
+					InfoDialog(
+						onDismiss = { showVpnPermissionDialog = false },
+						onAttest = { showVpnPermissionDialog = false },
+						title = { Text(text = stringResource(R.string.vpn_denied_dialog_title)) },
+						body = {
+							Column(verticalArrangement = Arrangement.spacedBy(15.dp)) {
+								Text(text = stringResource(R.string.vpn_denied_dialog_message))
+								Text(text = stringResource(R.string.vpn_denied_dialog_message2))
+							}
+						},
+						confirmText = { Text(text = stringResource(R.string.okay)) },
+					)
+				}
+
 				Scaffold(
 					snackbarHost = {
 						SnackbarHost(snackbarHostState) { snackbarData: SnackbarData ->
@@ -181,7 +215,8 @@ class MainActivity : AppCompatActivity() {
 						}
 					},
 					// TODO refactor
-                    modifier = Modifier
+					modifier =
+					Modifier
 						.focusable()
 						.focusProperties {
 							when (navBackStackEntry?.destination?.route) {
@@ -202,8 +237,7 @@ class MainActivity : AppCompatActivity() {
 				) { padding ->
 					NavHost(
 						navController,
-                        startDestination =
+						startDestination = (if (isPinLockEnabled == true) Screen.Lock.route else Screen.Main.route),
-                        (if (PinManager.pinExists()) Screen.Lock.route else Screen.Main.route),
 						modifier =
 						Modifier
 							.padding(padding)
@@ -237,10 +271,11 @@ class MainActivity : AppCompatActivity() {
 							)
 						}
 						composable(Screen.Support.Logs.route) {
-                            LogsScreen(appViewModel)
+							LogsScreen()
 						}
-                            //TODO fix navigation for amnezia
+						composable(
-                        composable("${Screen.Config.route}/{id}?configType={configType}", arguments =
+							"${Screen.Config.route}/{id}?configType={configType}",
+							arguments =
 							listOf(
 								navArgument("id") {
 									type = NavType.StringType
@@ -249,18 +284,21 @@ class MainActivity : AppCompatActivity() {
 								navArgument("configType") {
 									type = NavType.StringType
 									defaultValue = ConfigType.WIREGUARD.name
-                            }
+								},
-                        )
+							),
 						) {
 							val id = it.arguments?.getString("id")
-                            val configType = ConfigType.valueOf( it.arguments?.getString("configType") ?: ConfigType.WIREGUARD.name)
+							val configType =
+								ConfigType.valueOf(
+									it.arguments?.getString("configType") ?: ConfigType.WIREGUARD.name,
+								)
 							if (!id.isNullOrBlank()) {
 								ConfigScreen(
 									navController = navController,
 									tunnelId = id,
 									appViewModel = appViewModel,
 									focusRequester = focusRequester,
-                                    configType = configType
+									configType = configType,
 								)
 							}
 						}

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

@@ -0,0 +1,67 @@
+package com.zaneschepke.wireguardautotunnel.ui
+
+import android.annotation.SuppressLint
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+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.AppStateRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import xyz.teamgravity.pin_lock_compose.PinManager
+import javax.inject.Inject
+
+@SuppressLint("CustomSplashScreen")
+@AndroidEntryPoint
+class SplashActivity : ComponentActivity() {
+	@Inject
+	lateinit var appStateRepository: AppStateRepository
+
+	@Inject
+	lateinit var localLogCollector: LocalLogCollector
+
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	override fun onCreate(savedInstanceState: Bundle?) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+			val splashScreen = installSplashScreen()
+			splashScreen.setKeepOnScreenCondition { true }
+		}
+		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 intent =
+					Intent(this@SplashActivity, MainActivity::class.java).apply {
+						putExtra(IS_PIN_LOCK_ENABLED_KEY, pinLockEnabled)
+					}
+				startActivity(intent)
+				finish()
+			}
+		}
+	}
+
+	companion object {
+		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(
+fun ClickableIconButton(onClick: () -> Unit, onIconClick: () -> Unit, text: String, icon: ImageVector, enabled: Boolean) {
-    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,6 +15,9 @@ 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
@@ -30,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(
@@ -44,7 +49,8 @@ fun RowListItem(
 	) {
 		Column {
 			Row(
-                modifier = Modifier
+				modifier =
+				Modifier
 					.fillMaxWidth()
 					.padding(horizontal = 15.dp, vertical = 5.dp),
 				verticalAlignment = Alignment.CenterVertically,
@@ -52,9 +58,10 @@ fun RowListItem(
 			) {
 				Row(
 					verticalAlignment = Alignment.CenterVertically,
+					modifier = Modifier.fillMaxWidth(13 / 20f),
 				) {
 					icon()
-                    Text(text)
+					Text(text, maxLines = 1, overflow = TextOverflow.Ellipsis)
 				}
 				rowButton()
 			}

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

@@ -44,19 +44,21 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
 			onQuery(onQueryChanged)
 		},
 		leadingIcon = {
+			val icon = Icons.Rounded.Search
 			Icon(
-                imageVector = Icons.Rounded.Search,
+				imageVector = icon,
 				tint = MaterialTheme.colorScheme.onBackground,
-                contentDescription = stringResource(id = R.string.search_icon),
+				contentDescription = icon.name,
 			)
 		},
 		trailingIcon = {
 			if (showClearIcon) {
 				IconButton(onClick = { query = "" }) {
+					val icon = Icons.Rounded.Clear
 					Icon(
-                        imageVector = Icons.Rounded.Clear,
+						imageVector = icon,
 						tint = MaterialTheme.colorScheme.onBackground,
-                        contentDescription = stringResource(id = R.string.clear_icon),
+						contentDescription = icon.name,
 					)
 				}
 			}

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,27 +13,26 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.Dp
 
 @Composable
-fun ConfigurationToggle(
+fun ConfigurationToggle(label: String, enabled: Boolean, checked: Boolean, padding: Dp, onCheckChanged: () -> Unit, modifier: Modifier = Modifier) {
-    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
+		Text(
+			label,
+			textAlign = TextAlign.Start,
+			modifier =
+			Modifier
 				.weight(
 					weight = 1.0f,
 					fill = false,
 				),
-            softWrap = true)
+			softWrap = true,
+		)
 		Switch(
 			modifier = modifier,
 			enabled = enabled,

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/navigation/BottomNavBar.kt

@@ -24,7 +24,8 @@ fun BottomNavBar(navController: NavController, bottomNavItems: List<BottomNavIte
 	val navBackStackEntry by navController.currentBackStackEntryAsState()
 
 	// TODO find a better way to hide nav bar
-    showBottomBar = when (navBackStackEntry?.destination?.route) {
+	showBottomBar =
+		when (navBackStackEntry?.destination?.route) {
 			Screen.Lock.route -> false
 			else -> true
 		}
@@ -32,7 +33,8 @@ fun BottomNavBar(navController: NavController, bottomNavItems: List<BottomNavIte
 	NavigationBar(
 		containerColor = if (!showBottomBar) Color.Transparent else MaterialTheme.colorScheme.background,
 	) {
-        if (showBottomBar) bottomNavItems.forEach { item ->
+		if (showBottomBar) {
+			bottomNavItems.forEach { item ->
 				val selected = item.route == backStackEntry.value?.destination?.route
 
 				NavigationBarItem(
@@ -54,3 +56,4 @@ 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(
+					override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
-                        result: BiometricPrompt.AuthenticationResult
-                    ) {
 						super.onAuthenticationSucceeded(result)
 						onSuccess()
 					}

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

@@ -25,11 +25,7 @@ import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 
 @Composable
-fun CustomSnackBar(
+fun CustomSnackBar(message: String, isRtl: Boolean = true, containerColor: Color = MaterialTheme.colorScheme.surface) {
-    message: String,
-    isRtl: Boolean = true,
-    containerColor: Color = MaterialTheme.colorScheme.surface
-) {
 	Snackbar(
 		containerColor = containerColor,
 		modifier =
@@ -44,7 +40,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,

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

@@ -95,7 +95,7 @@ fun ConfigScreen(
 	navController: NavController,
 	appViewModel: AppViewModel,
 	tunnelId: String,
-    configType: ConfigType
+	configType: ConfigType,
 ) {
 	val context = LocalContext.current
 	val clipboardManager: ClipboardManager = LocalClipboardManager.current
@@ -128,16 +128,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 +156,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 +186,8 @@ fun ConfigScreen(
 					.fillMaxHeight(if (uiState.isAllApplicationsEnabled) 1 / 5f else 4 / 5f),
 			) {
 				Column(
-                    modifier = Modifier
+					modifier =
+					Modifier
 						.fillMaxWidth(),
 				) {
 					Row(
@@ -246,7 +258,8 @@ fun ConfigScreen(
 								Row(
 									verticalAlignment = Alignment.CenterVertically,
 									horizontalArrangement = Arrangement.SpaceBetween,
-                                    modifier = Modifier
+									modifier =
+									Modifier
 										.fillMaxSize()
 										.padding(5.dp),
 								) {
@@ -275,9 +288,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 +307,8 @@ fun ConfigScreen(
 					}
 					Row(
 						verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier
+						modifier =
+						Modifier
 							.fillMaxSize()
 							.padding(top = 5.dp),
 						horizontalArrangement = Arrangement.Center,
@@ -321,7 +337,9 @@ fun ConfigScreen(
 				},
 				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))
@@ -354,19 +372,22 @@ fun ConfigScreen(
 					shape = RoundedCornerShape(12.dp),
 					color = MaterialTheme.colorScheme.surface,
 					modifier =
-                    (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+					(
+						if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
 							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 +401,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 = {
@@ -450,7 +475,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 +496,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,98 +513,162 @@ 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),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.junkPacketMinSize,
-                                onValueChange = { value -> viewModel.onJunkPacketMinSizeChanged(value) },
+								onValueChange = { value ->
+									viewModel.onJunkPacketMinSizeChanged(
+										value,
+									)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.junk_packet_minimum_size),
-                                hint = stringResource(R.string.junk_packet_minimum_size).lowercase(),
+								hint =
-                                modifier = Modifier
+								stringResource(
+									R.string.junk_packet_minimum_size,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.junkPacketMaxSize,
-                                onValueChange = { value -> viewModel.onJunkPacketMaxSizeChanged(value) },
+								onValueChange = { value ->
+									viewModel.onJunkPacketMaxSizeChanged(
+										value,
+									)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.junk_packet_maximum_size),
-                                hint = stringResource(R.string.junk_packet_maximum_size).lowercase(),
+								hint =
-                                modifier = Modifier
+								stringResource(
+									R.string.junk_packet_maximum_size,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.initPacketJunkSize,
-                                onValueChange = { value -> viewModel.onInitPacketJunkSizeChanged(value) },
+								onValueChange = { value ->
+									viewModel.onInitPacketJunkSizeChanged(
+										value,
+									)
+								},
 								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(),
+								hint =
-                                modifier = Modifier
+								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(),
+								hint =
-                                modifier = Modifier
+								stringResource(
+									R.string.init_packet_magic_header,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.responsePacketMagicHeader,
-                                onValueChange = { value -> viewModel.onResponsePacketMagicHeader(value) },
+								onValueChange = { value ->
+									viewModel.onResponsePacketMagicHeader(
+										value,
+									)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.response_packet_magic_header),
-                                hint = stringResource(R.string.response_packet_magic_header).lowercase(),
+								hint =
-                                modifier = Modifier
+								stringResource(
+									R.string.response_packet_magic_header,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.underloadPacketMagicHeader,
-                                onValueChange = { value -> viewModel.onUnderloadPacketMagicHeader(value) },
+								onValueChange = { value ->
+									viewModel.onUnderloadPacketMagicHeader(
+										value,
+									)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.underload_packet_magic_header),
-                                hint = stringResource(R.string.underload_packet_magic_header).lowercase(),
+								hint =
-                                modifier = Modifier
+								stringResource(
+									R.string.underload_packet_magic_header,
+								).lowercase(),
+								modifier =
+								Modifier
 									.fillMaxWidth()
 									.focusRequester(focusRequester),
 							)
 							ConfigurationTextBox(
 								value = uiState.interfaceProxy.transportPacketMagicHeader,
-                                onValueChange = { value -> viewModel.onTransportPacketMagicHeader(value) },
+								onValueChange = { value ->
+									viewModel.onTransportPacketMagicHeader(
+										value,
+									)
+								},
 								keyboardActions = keyboardActions,
 								label = stringResource(R.string.transport_packet_magic_header),
-                                hint = stringResource(R.string.transport_packet_magic_header).lowercase(),
+								hint =
-                                modifier = Modifier
+								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,
@@ -595,26 +686,30 @@ fun ConfigScreen(
 						shape = RoundedCornerShape(12.dp),
 						color = MaterialTheme.colorScheme.surface,
 						modifier =
-                        (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+						(
+							if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
 								Modifier
 									.fillMaxHeight(fillMaxHeight)
 									.fillMaxWidth(fillMaxWidth)
 							} else {
 								Modifier.fillMaxWidth(fillMaxWidth)
-                        })
+							}
+							)
 							.padding(top = 10.dp, bottom = 10.dp),
 					) {
 						Column(
 							horizontalAlignment = Alignment.Start,
 							verticalArrangement = Arrangement.Top,
-                            modifier = Modifier
+							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),
 							) {
@@ -700,7 +795,8 @@ fun ConfigScreen(
 				Row(
 					horizontalArrangement = Arrangement.SpaceEvenly,
 					verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier
+					modifier =
+					Modifier
 						.fillMaxSize()
 						.padding(bottom = 140.dp),
 				) {

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

@@ -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 {
@@ -43,6 +43,7 @@ data class ConfigUiState(
 				isAllApplicationsEnabled,
 			)
 		}
+
 		fun from(config: org.amnezia.awg.config.Config): ConfigUiState {
 			// TODO update with new values
 			val proxyPeers = config.peers.map { PeerProxy.from(it) }

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

@@ -16,6 +16,7 @@ import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.model.PeerProxy
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
 import com.zaneschepke.wireguardautotunnel.util.Constants
@@ -25,7 +26,7 @@ import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
 import com.zaneschepke.wireguardautotunnel.util.removeAt
 import com.zaneschepke.wireguardautotunnel.util.update
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
@@ -38,16 +39,15 @@ class ConfigViewModel
 @Inject
 constructor(
 	private val settingsRepository: SettingsRepository,
-    private val appDataRepository: AppDataRepository
+	private val appDataRepository: AppDataRepository,
+	@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) =
+	fun init(tunnelId: String) = viewModelScope.launch(ioDispatcher) {
-        viewModelScope.launch(Dispatchers.IO) {
 		val packages = getQueriedPackages("")
 		val state =
 			if (tunnelId != Constants.MANUAL_TUNNEL_CONFIG_ID) {
@@ -56,15 +56,22 @@ constructor(
 						.firstOrNull { it.id.toString() == tunnelId }
 				val isAmneziaEnabled = settingsRepository.getSettings().isAmneziaEnabled
 				if (tunnelConfig != null) {
-                        (if(isAmneziaEnabled) {
+					(
-                            val amConfig = if(tunnelConfig.amQuick == "") tunnelConfig.wgQuick else tunnelConfig.amQuick
+						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,
 						tunnelName = tunnelConfig.name,
-                            isAmneziaEnabled = isAmneziaEnabled
+						isAmneziaEnabled = isAmneziaEnabled,
 					)
 				} else {
 					ConfigUiState(loading = false, packages = packages)
@@ -108,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> {
@@ -130,11 +137,9 @@ constructor(
 		return _uiState.value.isAllApplicationsEnabled
 	}
 
-    private fun saveConfig(tunnelConfig: TunnelConfig) =
+	private fun saveConfig(tunnelConfig: TunnelConfig) = viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }
-        viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }
 
-    private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) =
+	private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) = viewModelScope.launch {
-        viewModelScope.launch {
 		if (tunnelConfig != null) {
 			saveConfig(tunnelConfig).join()
 			WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
@@ -180,14 +185,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) {
-        if (!_uiState.value.include) builder.excludeApplications(_uiState.value.checkedPackageNames)
+			builder.includeApplications(
+				_uiState.value.checkedPackageNames,
+			)
+		}
+		if (!_uiState.value.include) {
+			builder.excludeApplications(
+				_uiState.value.checkedPackageNames,
+			)
+		}
 		return builder.build()
 	}
 
@@ -198,40 +212,67 @@ 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) {
-        if (!_uiState.value.include) builder.excludeApplications(_uiState.value.checkedPackageNames)
+			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(_uiState.value.interfaceProxy.junkPacketMinSize.trim().toInt())
+			builder.setJunkPacketMinSize(
+				_uiState.value.interfaceProxy.junkPacketMinSize.trim().toInt(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.junkPacketMaxSize.isNotEmpty()) {
-            builder.setJunkPacketMaxSize(_uiState.value.interfaceProxy.junkPacketMaxSize.trim().toInt())
+			builder.setJunkPacketMaxSize(
+				_uiState.value.interfaceProxy.junkPacketMaxSize.trim().toInt(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.initPacketJunkSize.isNotEmpty()) {
-            builder.setInitPacketJunkSize(_uiState.value.interfaceProxy.initPacketJunkSize.trim().toInt())
+			builder.setInitPacketJunkSize(
+				_uiState.value.interfaceProxy.initPacketJunkSize.trim().toInt(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.responsePacketJunkSize.isNotEmpty()) {
-            builder.setResponsePacketJunkSize(_uiState.value.interfaceProxy.responsePacketJunkSize.trim().toInt())
+			builder.setResponsePacketJunkSize(
+				_uiState.value.interfaceProxy.responsePacketJunkSize.trim().toInt(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.initPacketMagicHeader.isNotEmpty()) {
-            builder.setInitPacketMagicHeader(_uiState.value.interfaceProxy.initPacketMagicHeader.trim().toLong())
+			builder.setInitPacketMagicHeader(
+				_uiState.value.interfaceProxy.initPacketMagicHeader.trim().toLong(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.responsePacketMagicHeader.isNotEmpty()) {
-            builder.setResponsePacketMagicHeader(_uiState.value.interfaceProxy.responsePacketMagicHeader.trim().toLong())
+			builder.setResponsePacketMagicHeader(
+				_uiState.value.interfaceProxy.responsePacketMagicHeader.trim().toLong(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.transportPacketMagicHeader.isNotEmpty()) {
-            builder.setTransportPacketMagicHeader(_uiState.value.interfaceProxy.transportPacketMagicHeader.trim().toLong())
+			builder.setTransportPacketMagicHeader(
+				_uiState.value.interfaceProxy.transportPacketMagicHeader.trim().toLong(),
+			)
 		}
 		if (_uiState.value.interfaceProxy.underloadPacketMagicHeader.isNotEmpty()) {
-            builder.setUnderloadPacketMagicHeader(_uiState.value.interfaceProxy.underloadPacketMagicHeader.trim().toLong())
+			builder.setUnderloadPacketMagicHeader(
+				_uiState.value.interfaceProxy.underloadPacketMagicHeader.trim().toLong(),
+			)
 		}
 		return builder.build()
 	}
@@ -245,25 +286,35 @@ 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).build()
+		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) {
+			val amQuick =
+				if (configType == ConfigType.AMNEZIA) {
 					buildAmConfig().toAwgQuickString()
-            } else TunnelConfig.AM_QUICK_DEFAULT
+				} else {
-            val tunnelConfig = when (uiState.value.tunnel) {
+					TunnelConfig.AM_QUICK_DEFAULT
-                null -> TunnelConfig(
+				}
+			val tunnelConfig =
+				when (uiState.value.tunnel) {
+					null ->
+						TunnelConfig(
 							name = _uiState.value.tunnelName,
 							wgQuick = wgQuick,
-                    amQuick = amQuick
+							amQuick = amQuick,
 						)
-                else -> uiState.value.tunnel!!.copy(
+
+					else ->
+						uiState.value.tunnel!!.copy(
 							name = _uiState.value.tunnelName,
 							wgQuick = wgQuick,
-                    amQuick = amQuick
+							amQuick = amQuick,
 						)
 				}
 			updateTunnelConfig(tunnelConfig)
@@ -271,7 +322,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))
@@ -371,7 +423,6 @@ constructor(
 				interfaceProxy = _uiState.value.interfaceProxy.copy(addresses = value),
 			)
 		}
-
 	}
 
 	fun onListenPortChanged(value: String) {
@@ -402,7 +453,6 @@ constructor(
 				interfaceProxy = _uiState.value.interfaceProxy.copy(publicKey = value),
 			)
 		}
-
 	}
 
 	fun onPrivateKeyChange(value: String) {
@@ -430,14 +480,15 @@ constructor(
 	fun onJunkPacketCountChanged(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketCount = value)
+				interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketCount = value),
 			)
 		}
 	}
+
 	fun onJunkPacketMinSizeChanged(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketMinSize = value)
+				interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketMinSize = value),
 			)
 		}
 	}
@@ -445,7 +496,7 @@ constructor(
 	fun onJunkPacketMaxSizeChanged(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketMaxSize = value)
+				interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketMaxSize = value),
 			)
 		}
 	}
@@ -453,7 +504,7 @@ constructor(
 	fun onInitPacketJunkSizeChanged(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(initPacketJunkSize = value)
+				interfaceProxy = _uiState.value.interfaceProxy.copy(initPacketJunkSize = value),
 			)
 		}
 	}
@@ -461,7 +512,10 @@ constructor(
 	fun onResponsePacketJunkSize(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(responsePacketJunkSize = value)
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					responsePacketJunkSize = value,
+				),
 			)
 		}
 	}
@@ -469,7 +523,10 @@ constructor(
 	fun onInitPacketMagicHeader(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(initPacketMagicHeader = value)
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					initPacketMagicHeader = value,
+				),
 			)
 		}
 	}
@@ -477,7 +534,10 @@ constructor(
 	fun onResponsePacketMagicHeader(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(responsePacketMagicHeader = value)
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					responsePacketMagicHeader = value,
+				),
 			)
 		}
 	}
@@ -485,7 +545,10 @@ constructor(
 	fun onTransportPacketMagicHeader(value: String) {
 		_uiState.update {
 			it.copy(
-                interfaceProxy = _uiState.value.interfaceProxy.copy(transportPacketMagicHeader = value)
+				interfaceProxy =
+				_uiState.value.interfaceProxy.copy(
+					transportPacketMagicHeader = value,
+				),
 			)
 		}
 	}
@@ -493,7 +556,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

@@ -35,6 +35,7 @@ data class InterfaceProxy(
 				mtu = if (i.mtu.isPresent) i.mtu.get().toString().trim() else "",
 			)
 		}
+
 		fun from(i: org.amnezia.awg.config.Interface): InterfaceProxy {
 			return InterfaceProxy(
 				publicKey = i.keyPair.publicKey.toBase64().trim(),
@@ -48,15 +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 "",
+				junkPacketCount =
-                junkPacketMinSize = if(i.junkPacketMinSize.isPresent) i.junkPacketMinSize.get().toString() else "",
+				if (i.junkPacketCount.isPresent) {
-                junkPacketMaxSize = if(i.junkPacketMaxSize.isPresent) i.junkPacketMaxSize.get().toString() else "",
+					i.junkPacketCount.get()
-                initPacketJunkSize = if(i.initPacketJunkSize.isPresent) i.initPacketJunkSize.get().toString() else "",
+						.toString()
-                responsePacketJunkSize = if(i.responsePacketJunkSize.isPresent) i.responsePacketJunkSize.get().toString() else "",
+				} 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 "",
+				junkPacketMinSize =
-                underloadPacketMagicHeader = if(i.underloadPacketMagicHeader.isPresent) i.underloadPacketMagicHeader.get().toString() else "",
+				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

@@ -14,6 +14,7 @@ import androidx.compose.animation.slideInVertically
 import androidx.compose.animation.slideOutVertically
 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
@@ -42,7 +43,6 @@ 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
@@ -69,7 +69,6 @@ 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.focus.onFocusChanged
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
@@ -101,9 +100,9 @@ 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.CaptureActivityPortrait
 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.screen.LoadingScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.corn
 import com.zaneschepke.wireguardautotunnel.ui.theme.mint
@@ -111,8 +110,6 @@ 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.truncateWithEllipsis
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
@@ -123,19 +120,20 @@ 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 { Dispatchers.IO }
+	val scope = rememberCoroutineScope()
 
 	val sheetState = rememberModalBottomSheetState()
 	var showBottomSheet by remember { mutableStateOf(false) }
 	var configType by remember { mutableStateOf(ConfigType.WIREGUARD) }
 
 	// Nested scroll for control FAB
-    val nestedScrollConnection = remember {
+	val nestedScrollConnection =
+		remember {
 			object : NestedScrollConnection {
 				override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
 					// Hide FAB
@@ -152,7 +150,6 @@ fun MainScreen(
 			}
 		}
 
-
 	var showDeleteTunnelAlertDialog by remember { mutableStateOf(false) }
 	var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
 	val uiState by viewModel.uiState.collectAsStateWithLifecycle()
@@ -193,7 +190,9 @@ fun MainScreen(
 								name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
 						}
 					) {
-                        appViewModel.showSnackbarMessage(context.getString(R.string.error_no_file_explorer))
+						appViewModel.showSnackbarMessage(
+							context.getString(R.string.error_no_file_explorer),
+						)
 					}
 					return intent
 				}
@@ -212,41 +211,37 @@ fun MainScreen(
 			onResult = {
 				if (it.contents != null) {
 					scope.launch {
-                        viewModel.onTunnelQrResult(it.contents, configType).onFailure {
+						viewModel.onTunnelQrResult(it.contents, configType).onFailure { error ->
-                            appViewModel.showSnackbarMessage(it.getMessage(context))
+							appViewModel.showSnackbarMessage(error.getMessage(context))
 						}
 					}
 				}
 			},
 		)
 
-    AnimatedVisibility(showDeleteTunnelAlertDialog) {
+	if (showDeleteTunnelAlertDialog) {
-        AlertDialog(
+		InfoDialog(
-            onDismissRequest = { showDeleteTunnelAlertDialog = false },
+			onDismiss = { showDeleteTunnelAlertDialog = false },
-            confirmButton = {
+			onAttest = {
-                TextButton(
-                    onClick = {
 				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) {
+				viewModel.onTunnelStart(tunnel, context)
+			} else {
+				viewModel.onTunnelStop(
+					context,
+				)
+			}
 		}
 	}
 
@@ -262,8 +257,6 @@ fun MainScreen(
 			context.getString(R.string.scanning_qr),
 		)
 		scanOptions.setBeepEnabled(false)
-        scanOptions.captureActivity =
-            CaptureActivityPortrait::class.java
 		scanLauncher.launch(scanOptions)
 	}
 
@@ -277,7 +270,6 @@ fun MainScreen(
 					},
 				)
 			}
-
 		},
 		floatingActionButtonPosition = FabPosition.End,
 		floatingActionButton = {
@@ -285,51 +277,67 @@ fun MainScreen(
 				visible = isVisible.value,
 				enter = slideInVertically(initialOffsetY = { it * 2 }),
 				exit = slideOutVertically(targetOffsetY = { it * 2 }),
+				modifier =
+				Modifier
+					.focusRequester(focusRequester)
+					.focusGroup(),
 			) {
 				val secondaryColor = MaterialTheme.colorScheme.secondary
-                val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
+				val tvFobColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-                var fobColor by remember { mutableStateOf(secondaryColor) }
+				val fobColor =
+					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) tvFobColor else secondaryColor
+				val fobIconColor =
+					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) Color.White else MaterialTheme.colorScheme.background
 				MultiFloatingActionButton(
-                    modifier =
+					fabIcon =
-                    (if (
+					FabIcon(
-                        WireGuardAutoTunnel.isRunningOnAndroidTv() &&
-                        uiState.tunnels.isEmpty()
-                    )
-                        Modifier.focusRequester(focusRequester)
-                    else Modifier)
-                        .onFocusChanged {
-                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                                fobColor = if (it.isFocused) hoverColor else secondaryColor
-                            }
-                        },
-                    fabIcon = FabIcon(
 						iconRes = R.drawable.add,
 						iconResAfterRotate = R.drawable.close,
-                        iconRotate = 180f
+						iconRotate = 180f,
 					),
-                    fabOption = FabOption(
+					fabOption =
-                        iconTint = MaterialTheme.colorScheme.background,
+					FabOption(
-                        backgroundTint = MaterialTheme.colorScheme.primary,
+						iconTint = fobIconColor,
+						backgroundTint = fobColor,
 					),
-                    itemsMultiFab = listOf(
+					itemsMultiFab =
+					listOf(
 						MultiFabItem(
 							label = {
 								Text(
 									stringResource(id = R.string.amnezia),
 									color = Color.White,
 									textAlign = TextAlign.Center,
-                                    modifier = Modifier.padding(end = 10.dp)
+									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))
+								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
+							value = ConfigType.WIREGUARD.name,
+							miniFabOption =
+							FabOption(
+								backgroundTint = fobColor,
+								fobIconColor,
+							),
 						),
 					),
 					onFabItemClicked = {
@@ -343,7 +351,9 @@ fun MainScreen(
 	) {
 		if (showBottomSheet) {
 			ModalBottomSheet(
-                onDismissRequest = { showBottomSheet = false },
+				onDismissRequest = {
+					showBottomSheet = false
+				},
 				sheetState = sheetState,
 			) {
 				// Sheet content
@@ -400,7 +410,7 @@ fun MainScreen(
 						.clickable {
 							showBottomSheet = false
 							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),
@@ -432,11 +442,30 @@ fun MainScreen(
 			flingBehavior = ScrollableDefaults.flingBehavior(),
 		) {
 			item {
-                val gettingStarted = buildAnnotatedString {
+				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))
+								pushStringAnnotation(
-                    withStyle(style = SpanStyle(color = MaterialTheme.colorScheme.primary)) {
+									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()
@@ -444,20 +473,23 @@ fun MainScreen(
 								append(stringResource(R.string.unsure_how))
 								append(".")
 							}
-                AnimatedVisibility(
+						Text(
-                    uiState.tunnels.isEmpty(), exit = fadeOut(), enter = fadeIn()) {
+							text = stringResource(R.string.no_tunnels),
-                    Column(
+							fontStyle = FontStyle.Italic,
-                        horizontalAlignment = Alignment.CenterHorizontally,
+						)
-                        verticalArrangement = Arrangement.Center,
-                        modifier = Modifier.padding(top = 100.dp)
-                    ) {
-                        Text(text = stringResource(R.string.no_tunnels), fontStyle = FontStyle.Italic)
 						ClickableText(
-                            modifier = Modifier.padding(vertical = 10.dp, horizontal = 24.dp),
+							modifier =
+							Modifier
+								.padding(vertical = 10.dp, horizontal = 24.dp),
 							text = gettingStarted,
-                            style = MaterialTheme.typography.bodyMedium.copy(color = MaterialTheme.colorScheme.onSurfaceVariant, textAlign = TextAlign.Center),
+							style =
+							MaterialTheme.typography.bodyMedium.copy(
+								color = MaterialTheme.colorScheme.onSurfaceVariant,
+								textAlign = TextAlign.Center,
+							),
 						) {
-                            gettingStarted.getStringAnnotations(tag = "gettingStarted", it, it).firstOrNull()?.let { annotation ->
+							gettingStarted.getStringAnnotations(tag = "gettingStarted", it, it)
+								.firstOrNull()?.let { annotation ->
 									appViewModel.openWebPage(annotation.item, context)
 								}
 						}
@@ -466,49 +498,66 @@ fun MainScreen(
 			}
 			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
+								if (uiState.settings.isAutoTunnelPaused) {
-                                else mint,
+									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 (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+								itemFocusRequester.requestFocus()
+							}
+						},
 						onHold = {},
 						expanded = false,
 						statistics = null,
+						focusRequester = focusRequester,
 					)
 				}
 			}
@@ -517,7 +566,8 @@ fun MainScreen(
 				key = { tunnel -> tunnel.id },
 			) { tunnel ->
 				val leadingIconColor =
-                    (if (
+					(
+						if (
 							uiState.vpnState.tunnelConfig?.name == tunnel.name &&
 							uiState.vpnState.status == TunnelState.UP
 						) {
@@ -538,12 +588,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
@@ -554,7 +607,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,
@@ -562,13 +616,15 @@ fun MainScreen(
 								.size(if (icon == circleIcon) 15.dp else 20.dp),
 						)
 					},
-                    text = tunnel.name.truncateWithEllipsis(Constants.ALLOWED_DISPLAY_NAME_LENGTH),
+					text = tunnel.name,
 					onHold = {
 						if (
 							(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)
@@ -584,11 +640,12 @@ fun MainScreen(
 							}
 						} else {
 							selectedTunnel = tunnel
-                            focusRequester.requestFocus()
+							itemFocusRequester.requestFocus()
 						}
 					},
 					statistics = uiState.vpnState.statistics,
 					expanded = expanded.value,
+					focusRequester = focusRequester,
 					rowButton = {
 						if (
 							tunnel.id == selectedTunnel?.id &&
@@ -635,16 +692,17 @@ fun MainScreen(
 						} else {
 							val checked by remember {
 								derivedStateOf {
-                                    (uiState.vpnState.status == TunnelState.UP &&
+									(
-                                        tunnel.name == uiState.vpnState.tunnelConfig?.name)
+										uiState.vpnState.status == TunnelState.UP &&
+											tunnel.name == uiState.vpnState.tunnelConfig?.name
+										)
 								}
 							}
 							if (!checked) expanded.value = false
 
 							@Composable
-                            fun TunnelSwitch() =
+							fun TunnelSwitch() = Switch(
-                                Switch(
+								modifier = Modifier.focusRequester(itemFocusRequester),
-                                    modifier = Modifier.focusRequester(focusRequester),
 								checked = checked,
 								onCheckedChange = { checked ->
 									if (!checked) expanded.value = false
@@ -655,7 +713,7 @@ fun MainScreen(
 								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

@@ -8,5 +8,5 @@ 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

@@ -11,6 +11,7 @@ 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.util.Constants
@@ -18,7 +19,7 @@ import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
 import com.zaneschepke.wireguardautotunnel.util.toWgQuickString
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
@@ -35,9 +36,9 @@ class MainViewModel
 constructor(
 	private val appDataRepository: AppDataRepository,
 	private val serviceManager: ServiceManager,
-    val vpnService: VpnService
+	val vpnService: VpnService,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : ViewModel() {
-
 	val uiState =
 		combine(
 			appDataRepository.settings.getSettingsFlow(),
@@ -52,13 +53,12 @@ constructor(
 				MainUiState(),
 			)
 
-    private fun stopWatcherService(context: Context) =
+	private fun stopWatcherService(context: Context) {
-        viewModelScope.launch(Dispatchers.IO) {
 		serviceManager.stopWatcherService(context)
 	}
 
 	fun onDelete(tunnel: TunnelConfig, context: Context) {
-        viewModelScope.launch(Dispatchers.IO) {
+		viewModelScope.launch {
 			val settings = appDataRepository.settings.getSettings()
 			val isPrimary = tunnel.isPrimaryTunnel
 			if (appDataRepository.tunnels.count() == 1 || isPrimary) {
@@ -79,8 +79,7 @@ constructor(
 		)
 	}
 
-    fun onTunnelStart(tunnelConfig: TunnelConfig, context: Context) =
+	fun onTunnelStart(tunnelConfig: TunnelConfig, context: Context) = viewModelScope.launch {
-        viewModelScope.launch(Dispatchers.IO) {
 		Timber.d("On start called!")
 		serviceManager.startVpnService(
 			context,
@@ -89,9 +88,7 @@ constructor(
 		)
 	}
 
-
+	fun onTunnelStop(context: Context) = viewModelScope.launch {
-    fun onTunnelStop(context: Context) =
-        viewModelScope.launch(Dispatchers.IO) {
 		Timber.i("Stopping active tunnel")
 		serviceManager.stopVpnService(context, isManualStop = true)
 	}
@@ -109,6 +106,7 @@ constructor(
 				ConfigType.AMNEZIA -> {
 					TunnelConfig.configFromAmQuick(config).peers[0].endpoint.get().host
 				}
+
 				ConfigType.WIREGUARD -> {
 					TunnelConfig.configFromWgQuick(config).peers[0].endpoint.get().host
 				}
@@ -134,15 +132,29 @@ constructor(
 	}
 
 	suspend fun onTunnelQrResult(result: String, configType: ConfigType): Result<Unit> {
-        return try {
+		return withContext(ioDispatcher) {
+			try {
 				validateConfigString(result, configType)
-            val tunnelName = makeTunnelNameUnique(generateQrCodeTunnelName(result, configType))
+				val tunnelName =
-            val tunnelConfig = when(configType) {
+					makeTunnelNameUnique(generateQrCodeTunnelName(result, configType))
+				val tunnelConfig =
+					when (configType) {
 						ConfigType.AMNEZIA -> {
-                    TunnelConfig(name = tunnelName, amQuick = result,
+							TunnelConfig(
-                        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)
@@ -151,34 +163,47 @@ constructor(
 				Result.failure(WgTunnelExceptions.InvalidQrCode())
 			}
 		}
+	}
 
 	private suspend fun makeTunnelNameUnique(name: String): String {
+		return withContext(ioDispatcher) {
 			val tunnels = appDataRepository.tunnels.getAll()
 			var tunnelName = name
 			var num = 1
 			while (tunnels.any { it.name == tunnelName }) {
-            tunnelName = name + "(${num})"
+				tunnelName = name + "($num)"
 				num++
 			}
-        return tunnelName
+			tunnelName
+		}
 	}
 
-    private suspend 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()
 						config.toWgQuickString()
 					}
+
 					ConfigType.WIREGUARD -> {
 						Config.parse(it).toWgQuickString()
 					}
 				}
 			}
+		viewModelScope.launch {
 			val tunnelName = makeTunnelNameUnique(getNameFromFileName(fileName))
-        addTunnel(TunnelConfig(name = tunnelName, wgQuick = wgQuick, amQuick = amQuick ?: TunnelConfig.AM_QUICK_DEFAULT))
+			addTunnel(
+				TunnelConfig(
+					name = tunnelName,
+					wgQuick = wgQuick,
+					amQuick = amQuick ?: TunnelConfig.AM_QUICK_DEFAULT,
+				),
+			)
+		}
 	}
 
 	private fun getInputStreamFromUri(uri: Uri, context: Context): InputStream? {
@@ -186,13 +211,21 @@ constructor(
 	}
 
 	suspend fun onTunnelFileSelected(uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
-        return try {
+		return withContext(ioDispatcher) {
+			try {
 				if (isValidUriContentScheme(uri)) {
 					val fileName = getFileName(context, uri)
-                return when (getFileExtensionFromFileName(fileName)) {
+					return@withContext when (getFileExtensionFromFileName(fileName)) {
 						Constants.CONF_FILE_EXTENSION ->
 							saveTunnelFromConfUri(fileName, uri, configType, context)
-                    Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(uri, configType, context)
+
+						Constants.ZIP_FILE_EXTENSION ->
+							saveTunnelsFromZipUri(
+								uri,
+								configType,
+								context,
+							)
+
 						else -> Result.failure(WgTunnelExceptions.InvalidFileExtension())
 					}
 				} else {
@@ -203,9 +236,11 @@ constructor(
 				Result.failure(WgTunnelExceptions.FileReadFailed())
 			}
 		}
+	}
 
 	private suspend fun saveTunnelsFromZipUri(uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
-        return ZipInputStream(getInputStreamFromUri(uri, context)).use { zip ->
+		return withContext(ioDispatcher) {
+			ZipInputStream(getInputStreamFromUri(uri, context)).use { zip ->
 				generateSequence { zip.nextEntry }
 					.filterNot {
 						it.isDirectory ||
@@ -213,21 +248,31 @@ constructor(
 					}
 					.forEach {
 						val name = getNameFromFileName(it.name)
-                    withContext(viewModelScope.coroutineContext + Dispatchers.IO) {
+						withContext(viewModelScope.coroutineContext) {
 							try {
 								var amQuick: String? = null
 								val wgQuick =
 									when (configType) {
 										ConfigType.AMNEZIA -> {
-                                        val config = org.amnezia.awg.config.Config.parse(zip)
+											val config =
+												org.amnezia.awg.config.Config.parse(
+													zip,
+												)
 											amQuick = config.toAwgQuickString()
 											config.toWgQuickString()
 										}
+
 										ConfigType.WIREGUARD -> {
 											Config.parse(zip).toWgQuickString()
 										}
 									}
-                            addTunnel(TunnelConfig(name = makeTunnelNameUnique(name), wgQuick = wgQuick, amQuick = amQuick ?: TunnelConfig.AM_QUICK_DEFAULT))
+								addTunnel(
+									TunnelConfig(
+										name = makeTunnelNameUnique(name),
+										wgQuick = wgQuick,
+										amQuick = amQuick ?: TunnelConfig.AM_QUICK_DEFAULT,
+									),
+								)
 								Result.success(Unit)
 							} catch (e: Exception) {
 								Result.failure(WgTunnelExceptions.FileReadFailed())
@@ -237,36 +282,45 @@ constructor(
 				Result.success(Unit)
 			}
 		}
+	}
 
 	private suspend fun saveTunnelFromConfUri(name: String, uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
+		return withContext(ioDispatcher) {
 			val stream = getInputStreamFromUri(uri, context)
-        return if (stream != null) {
+			return@withContext if (stream != null) {
+				try {
 					saveTunnelConfigFromStream(stream, name, configType)
+				} catch (e: Exception) {
+					return@withContext Result.failure(WgTunnelExceptions.ConfigParseError())
+				}
 				Result.success(Unit)
 			} else {
 				Result.failure(WgTunnelExceptions.FileReadFailed())
 			}
 		}
+	}
 
-    private suspend fun addTunnel(tunnelConfig: TunnelConfig) {
+	private fun addTunnel(tunnelConfig: TunnelConfig) = viewModelScope.launch {
 		val firstTunnel = appDataRepository.tunnels.count() == 0
 		saveTunnel(tunnelConfig)
 		if (firstTunnel) WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
 	}
 
-    fun pauseAutoTunneling() =
+	fun pauseAutoTunneling() = viewModelScope.launch {
-        viewModelScope.launch {
+		appDataRepository.settings.save(
-            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = true))
+			uiState.value.settings.copy(isAutoTunnelPaused = true),
+		)
 		WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
 	}
 
-    fun resumeAutoTunneling() =
+	fun resumeAutoTunneling() = viewModelScope.launch {
-        viewModelScope.launch {
+		appDataRepository.settings.save(
-            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = false))
+			uiState.value.settings.copy(isAutoTunnelPaused = false),
+		)
 		WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
 	}
 
-    private suspend fun saveTunnel(tunnelConfig: TunnelConfig) {
+	private fun saveTunnel(tunnelConfig: TunnelConfig) = viewModelScope.launch {
 		appDataRepository.tunnels.save(tunnelConfig)
 	}
 
@@ -291,8 +345,12 @@ constructor(
 			val index = getDisplayNameColumnIndex(cursor)
 			if (index != null) {
 				cursor.getString(index)
-            } else null
+			} else {
-        } else null
+				null
+			}
+		} else {
+			null
+		}
 	}
 
 	private fun isValidUriContentScheme(uri: Uri): Boolean {
@@ -316,9 +374,7 @@ constructor(
 		}
 	}
 
-    private fun saveSettings(settings: Settings) =
+	private fun saveSettings(settings: Settings) = viewModelScope.launch { appDataRepository.settings.save(settings) }
-        viewModelScope.launch(Dispatchers.IO) { appDataRepository.settings.save(settings) }
-
 
 	fun onCopyTunnel(tunnel: TunnelConfig?) = viewModelScope.launch {
 		tunnel?.let {

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

@@ -1,7 +1,11 @@
 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
@@ -12,6 +16,7 @@ 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
@@ -39,7 +44,6 @@ 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.focus.onFocusChanged
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
@@ -77,7 +81,7 @@ fun OptionsScreen(
 	navController: NavController,
 	appViewModel: AppViewModel,
 	focusRequester: FocusRequester,
-    tunnelId: String
+	tunnelId: String,
 ) {
 	val scrollState = rememberScrollState()
 	val uiState by optionsViewModel.uiState.collectAsStateWithLifecycle()
@@ -114,59 +118,82 @@ fun OptionsScreen(
 	Scaffold(
 		floatingActionButton = {
 			val secondaryColor = MaterialTheme.colorScheme.secondary
-            val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
+			val tvFobColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-            var fobColor by remember { mutableStateOf(secondaryColor) }
+			val fobColor =
-            MultiFloatingActionButton(
+				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 =
-                (if (
+				Modifier
-                    WireGuardAutoTunnel.isRunningOnAndroidTv()
+					.focusRequester(focusRequester)
-                )
+					.focusGroup(),
-                    Modifier.focusRequester(focusRequester)
+			) {
-                else Modifier)
+				MultiFloatingActionButton(
-                    .onFocusChanged {
+					fabIcon =
-                        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+					FabIcon(
-                            fobColor = if (it.isFocused) hoverColor else secondaryColor
-                        }
-                    },
-                fabIcon = FabIcon(
 						iconRes = R.drawable.edit,
 						iconResAfterRotate = R.drawable.close,
-                    iconRotate = 180f
+						iconRotate = 180f,
 					),
-                fabOption = FabOption(
+					fabOption =
-                    iconTint = MaterialTheme.colorScheme.background,
+					FabOption(
-                    backgroundTint = MaterialTheme.colorScheme.primary,
+						iconTint = fobIconColor,
+						backgroundTint = fobColor,
 					),
-                itemsMultiFab = listOf(
+					itemsMultiFab =
+					listOf(
 						MultiFabItem(
 							label = {
 								Text(
 									stringResource(id = R.string.amnezia),
 									color = Color.White,
 									textAlign = TextAlign.Center,
-                                modifier = Modifier.padding(end = 10.dp)
+									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))
+								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
+							value = ConfigType.WIREGUARD.name,
+							miniFabOption =
+							FabOption(
+								backgroundTint = fobColor,
+								fobIconColor,
+							),
 						),
 					),
 					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(
 			horizontalAlignment = Alignment.CenterHorizontally,
@@ -188,7 +215,8 @@ fun OptionsScreen(
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
 				modifier =
-                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+				(
+					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
 						Modifier
 							.height(IntrinsicSize.Min)
 							.fillMaxWidth(fillMaxWidth)
@@ -197,7 +225,8 @@ fun OptionsScreen(
 						Modifier
 							.fillMaxWidth(fillMaxWidth)
 							.padding(top = 20.dp)
-                })
+					}
+					)
 					.padding(bottom = 10.dp),
 			) {
 				Column(
@@ -213,7 +242,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() },
@@ -226,7 +256,8 @@ fun OptionsScreen(
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
 				modifier =
-                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+				(
+					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
 						Modifier
 							.height(IntrinsicSize.Min)
 							.fillMaxWidth(fillMaxWidth)
@@ -235,7 +266,8 @@ fun OptionsScreen(
 						Modifier
 							.fillMaxWidth(fillMaxWidth)
 							.padding(top = 20.dp)
-                })
+					}
+					)
 					.padding(bottom = 10.dp),
 			) {
 				Column(
@@ -256,7 +288,8 @@ fun OptionsScreen(
 					)
 					Column {
 						FlowRow(
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.padding(screenPadding)
 								.fillMaxWidth(),
 							horizontalArrangement = Arrangement.spacedBy(5.dp),
@@ -272,7 +305,6 @@ fun OptionsScreen(
 									onIconClick = {
 										if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
 										optionsViewModel.onDeleteRunSSID(ssid)
-
 									},
 									text = ssid,
 									icon = Icons.Filled.Close,

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

@@ -9,7 +9,6 @@ import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
@@ -20,14 +19,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 ->
@@ -35,7 +35,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),
@@ -45,22 +47,23 @@ constructor(
 	fun init(tunnelId: String) {
 		_optionState.update {
 			it.copy(
-                id = tunnelId
+				id = tunnelId,
 			)
 		}
 	}
 
-    fun onDeleteRunSSID(ssid: String) = viewModelScope.launch(Dispatchers.IO) {
+	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(),
 				),
 			)
 		}
 	}
 
-    private fun saveTunnel(tunnelConfig: TunnelConfig?) = viewModelScope.launch(Dispatchers.IO) {
+	private fun saveTunnel(tunnelConfig: TunnelConfig?) = viewModelScope.launch {
 		tunnelConfig?.let {
 			appDataRepository.tunnels.save(it)
 		}
@@ -68,11 +71,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)
@@ -81,15 +86,17 @@ constructor(
 		}
 	}
 
-    fun onToggleIsMobileDataTunnel() = viewModelScope.launch(Dispatchers.IO) {
+	fun onToggleIsMobileDataTunnel() = viewModelScope.launch {
 		uiState.value.tunnel?.let {
 			if (it.isMobileDataTunnel) {
 				appDataRepository.tunnels.updateMobileDataTunnel(null)
-            } else appDataRepository.tunnels.updateMobileDataTunnel(it)
+			} else {
+				appDataRepository.tunnels.updateMobileDataTunnel(it)
+			}
 		}
 	}
 
-    fun onTogglePrimaryTunnel() = viewModelScope.launch(Dispatchers.IO) {
+	fun onTogglePrimaryTunnel() = viewModelScope.launch {
 		if (uiState.value.tunnel != null) {
 			appDataRepository.tunnels.updatePrimaryTunnel(
 				when (uiState.value.isDefaultTunnel) {

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

@@ -19,9 +19,14 @@ 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,
@@ -35,7 +40,6 @@ fun PinLockScreen(navController: NavController, appViewModel: AppViewModel) {
 					navController.navigate(Screen.Main.route)
 				}
 			}
-
 		},
 		onPinIncorrect = {
 			// pin is incorrect, show error

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

@@ -44,6 +44,7 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -70,7 +71,6 @@ import androidx.navigation.NavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
-import com.wireguard.android.backend.WgQuickBackend
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
@@ -81,12 +81,9 @@ 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.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.getMessage
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import xyz.teamgravity.pin_lock_compose.PinManager
 import java.io.File
 
 @OptIn(
@@ -100,14 +97,14 @@ fun SettingsScreen(
 	navController: NavController,
 	focusRequester: FocusRequester,
 ) {
-    val scope = rememberCoroutineScope { Dispatchers.IO }
 	val context = LocalContext.current
 	val focusManager = LocalFocusManager.current
+	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()
 
 	val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
 	var currentText by remember { mutableStateOf("") }
@@ -119,8 +116,14 @@ fun SettingsScreen(
 	val screenPadding = 5.dp
 	val fillMaxWidth = .85f
 
+	LaunchedEffect(Unit) {
+		viewModel.checkKernelSupport()
+	}
+
 	val startForResult =
-        rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
+		rememberLauncherForActivityResult(
+			ActivityResultContracts.StartActivityForResult(),
+		) { result: ActivityResult ->
 			if (result.resultCode == Activity.RESULT_OK) {
 				result.data
 				// Handle the Intent
@@ -130,25 +133,35 @@ fun SettingsScreen(
 
 	fun exportAllConfigs() {
 		try {
-            val wgFiles = uiState.tunnels.map { config ->
+			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 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 }
+					} else {
-            FileUtils.saveFilesToZip(context, wgFiles + amFiles).onFailure {
+						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))
+					appViewModel.showSnackbarMessage(
+						context.getString(R.string.exported_configs_message),
+					)
+				}
 			}
 		} catch (e: Exception) {
 			Timber.e(e)
@@ -190,12 +203,10 @@ fun SettingsScreen(
 	}
 
 	fun openSettings() {
-        scope.launch {
 		val intentSettings = Intent(ACTION_APPLICATION_DETAILS_SETTINGS)
 		intentSettings.data = Uri.fromParts("package", context.packageName, null)
 		context.startActivity(intentSettings)
 	}
-    }
 
 	fun checkFineLocationGranted() {
 		isBackgroundLocationGranted =
@@ -257,14 +268,16 @@ fun SettingsScreen(
 		Column(
 			horizontalAlignment = Alignment.CenterHorizontally,
 			verticalArrangement = Arrangement.Top,
-            modifier = Modifier
+			modifier =
+			Modifier
 				.fillMaxSize()
 				.verticalScroll(scrollState),
 		) {
 			Icon(
 				Icons.Rounded.LocationOff,
 				contentDescription = stringResource(id = R.string.map),
-                modifier = Modifier
+				modifier =
+				Modifier
 					.padding(30.dp)
 					.size(128.dp),
 			)
@@ -318,11 +331,15 @@ fun SettingsScreen(
 			},
 			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),
+				)
 			},
 		)
 	}
@@ -362,7 +379,8 @@ fun SettingsScreen(
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
 				modifier =
-                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+				(
+					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
 						Modifier
 							.height(IntrinsicSize.Min)
 							.fillMaxWidth(fillMaxWidth)
@@ -371,7 +389,8 @@ fun SettingsScreen(
 						Modifier
 							.fillMaxWidth(fillMaxWidth)
 							.padding(top = 20.dp)
-                })
+					}
+					)
 					.padding(bottom = 10.dp),
 			) {
 				Column(
@@ -386,21 +405,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
+						if (uiState.settings.isAutoTunnelEnabled) {
-                        else
 							Modifier
-                                .focusRequester(focusRequester),
+						} else {
+							Modifier
+								.focusRequester(focusRequester)
+						},
 					)
 					AnimatedVisibility(visible = uiState.settings.isTunnelOnWifiEnabled) {
 						Column {
 							FlowRow(
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.padding(screenPadding)
 									.fillMaxWidth(),
 								horizontalArrangement = Arrangement.spacedBy(5.dp),
@@ -416,13 +440,14 @@ fun SettingsScreen(
 										onIconClick = {
 											if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
 											viewModel.onDeleteTrustedSSID(ssid)
-
 										},
 										text = ssid,
 										icon = Icons.Filled.Close,
 										enabled =
-                                        !(uiState.settings.isAutoTunnelEnabled ||
+										!(
-                                            uiState.settings.isAlwaysOnVpnEnabled),
+											uiState.settings.isAutoTunnelEnabled ||
+												uiState.settings.isAlwaysOnVpnEnabled
+											),
 									)
 								}
 								if (uiState.settings.trustedNetworkSSIDs.isEmpty()) {
@@ -435,8 +460,10 @@ fun SettingsScreen(
 							}
 							OutlinedTextField(
 								enabled =
-                                !(uiState.settings.isAutoTunnelEnabled ||
+								!(
-                                    uiState.settings.isAlwaysOnVpnEnabled),
+									uiState.settings.isAutoTunnelEnabled ||
+										uiState.settings.isAlwaysOnVpnEnabled
+									),
 								value = currentText,
 								onValueChange = { currentText = it },
 								label = { Text(stringResource(R.string.add_trusted_ssid)) },
@@ -484,8 +511,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() },
@@ -493,8 +522,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() },
@@ -502,8 +533,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() },
@@ -511,11 +544,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,
@@ -530,12 +567,16 @@ fun SettingsScreen(
 									when (false) {
 										isBackgroundLocationGranted ->
 											appViewModel.showSnackbarMessage(
-                                                context.getString(R.string.background_location_required),
+												context.getString(
+													R.string.background_location_required,
+												),
 											)
 
 										fineLocationState.status.isGranted ->
 											appViewModel.showSnackbarMessage(
-                                                context.getString(R.string.precise_location_required),
+												context.getString(
+													R.string.precise_location_required,
+												),
 											)
 
 										viewModel.isLocationEnabled(context) ->
@@ -566,7 +607,8 @@ fun SettingsScreen(
 				shadowElevation = 2.dp,
 				shape = RoundedCornerShape(12.dp),
 				color = MaterialTheme.colorScheme.surface,
-                modifier = Modifier
+				modifier =
+				Modifier
 					.fillMaxWidth(fillMaxWidth)
 					.padding(vertical = 10.dp),
 			) {
@@ -582,28 +624,34 @@ 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 = {
 							viewModel.onToggleAmnezia()
 						},
 					)
-                    if (WgQuickBackend.hasKernelSupport()) {
+					if (kernelSupport) {
 						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))
 									}
+								}
 							},
 						)
 					}
@@ -646,15 +694,24 @@ fun SettingsScreen(
 						)
 					}
 					ConfigurationToggle(
-                        stringResource(R.string.enable_app_lock),
+						stringResource(R.string.restart_at_boot),
 						enabled = true,
-                        checked = pinExists.value,
+						checked = uiState.settings.isRestoreOnBootEnabled,
 						padding = screenPadding,
 						onCheckChanged = {
-                            if (pinExists.value) {
+							viewModel.onToggleRestartAtBoot()
-                                PinManager.clearPin()
+						},
-                                pinExists.value = PinManager.pinExists()
+					)
+					ConfigurationToggle(
+						stringResource(R.string.enable_app_lock),
+						enabled = true,
+						checked = uiState.isPinLockEnabled,
+						padding = screenPadding,
+						onCheckChanged = {
+							if (uiState.isPinLockEnabled) {
+								viewModel.onPinLockDisabled()
 							} else {
+								viewModel.onPinLockEnabled()
 								navController.navigate(Screen.Lock.route)
 							}
 						},
@@ -662,7 +719,8 @@ fun SettingsScreen(
 					if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
 						Row(
 							verticalAlignment = Alignment.CenterVertically,
-                            modifier = Modifier
+							modifier =
+							Modifier
 								.fillMaxSize()
 								.padding(top = 5.dp),
 							horizontalArrangement = Arrangement.Center,

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

@@ -9,5 +9,6 @@ data class SettingsUiState(
 	val tunnels: List<TunnelConfig> = emptyList(),
 	val vpnState: VpnState = VpnState(),
 	val isLocationDisclosureShown: Boolean = true,
-    val isBatteryOptimizeDisableShown: Boolean = false
+	val isBatteryOptimizeDisableShown: Boolean = false,
+	val isPinLockEnabled: Boolean = false,
 )

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

@@ -5,21 +5,32 @@ import android.location.LocationManager
 import androidx.core.location.LocationManagerCompat
 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.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import timber.log.Timber
+import xyz.teamgravity.pin_lock_compose.PinManager
+import java.io.File
 import javax.inject.Inject
+import javax.inject.Provider
 
 @HiltViewModel
 class SettingsViewModel
@@ -27,9 +38,13 @@ class SettingsViewModel
 constructor(
 	private val appDataRepository: AppDataRepository,
 	private val serviceManager: ServiceManager,
-    private val rootShell: RootShell,
+	private val rootShell: Provider<RootShell>,
-    vpnService: VpnService
+	private val fileUtils: FileUtils,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+	vpnService: VpnService,
 ) : ViewModel() {
+	private val _kernelSupport = MutableStateFlow(false)
+	val kernelSupport = _kernelSupport.asStateFlow()
 
 	val uiState =
 		combine(
@@ -42,8 +57,9 @@ constructor(
 				settings,
 				tunnels,
 				tunnelState,
-                generalState.locationDisclosureShown,
+				generalState.isLocationDisclosureShown,
-                generalState.batteryOptimizationDisableShown,
+				generalState.isBatteryOptimizationDisableShown,
+				generalState.isPinLockEnabled,
 			)
 		}
 			.stateIn(
@@ -63,13 +79,11 @@ constructor(
 		}
 	}
 
-    fun setLocationDisclosureShown() =
+	fun setLocationDisclosureShown() = viewModelScope.launch {
-        viewModelScope.launch {
 		appDataRepository.appState.setLocationDisclosureShown(true)
 	}
 
-    fun setBatteryOptimizeDisableShown() =
+	fun setBatteryOptimizeDisableShown() = viewModelScope.launch {
-        viewModelScope.launch {
 		appDataRepository.appState.setBatteryOptimizationDisableShown(true)
 	}
 
@@ -90,8 +104,11 @@ constructor(
 		)
 	}
 
-    fun onToggleAutoTunnel(context: Context) =
+	suspend fun onExportTunnels(files: List<File>): Result<Unit> {
-        viewModelScope.launch {
+		return fileUtils.saveFilesToZip(files)
+	}
+
+	fun onToggleAutoTunnel(context: Context) = viewModelScope.launch {
 		val isAutoTunnelEnabled = uiState.value.settings.isAutoTunnelEnabled
 		var isAutoTunnelPaused = uiState.value.settings.isAutoTunnelPaused
 
@@ -110,8 +127,7 @@ constructor(
 		WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
 	}
 
-    fun onToggleAlwaysOnVPN() =
+	fun onToggleAlwaysOnVPN() = viewModelScope.launch {
-        viewModelScope.launch {
 		saveSettings(
 			uiState.value.settings.copy(
 				isAlwaysOnVpnEnabled = !uiState.value.settings.isAlwaysOnVpnEnabled,
@@ -119,8 +135,7 @@ constructor(
 		)
 	}
 
-    private fun saveSettings(settings: Settings) =
+	private fun saveSettings(settings: Settings) = viewModelScope.launch { appDataRepository.settings.save(settings) }
-        viewModelScope.launch { appDataRepository.settings.save(settings) }
 
 	fun onToggleTunnelOnEthernet() {
 		saveSettings(
@@ -131,7 +146,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)
 	}
 
@@ -169,15 +187,16 @@ constructor(
 	private fun saveAmneziaMode(on: Boolean) {
 		saveSettings(
 			uiState.value.settings.copy(
-                isAmneziaEnabled = on
+				isAmneziaEnabled = on,
-            )
+			),
 		)
 	}
 
-    fun onToggleKernelMode(): Result<Unit> {
+	suspend fun onToggleKernelMode(): Result<Unit> {
+		return withContext(ioDispatcher) {
 			if (!uiState.value.settings.isKernelEnabled) {
 				try {
-                rootShell.start()
+					rootShell.get().start()
 					Timber.i("Root shell accepted!")
 					saveSettings(
 						uiState.value.settings.copy(
@@ -185,16 +204,16 @@ constructor(
 							isAmneziaEnabled = false,
 						),
 					)
-
 				} catch (e: RootShell.RootShellException) {
 					Timber.e(e)
 					saveKernelMode(on = false)
-                return Result.failure(WgTunnelExceptions.RootDenied())
+					return@withContext Result.failure(WgTunnelExceptions.RootDenied())
 				}
 			} else {
 				saveKernelMode(on = false)
 			}
-        return Result.success(Unit)
+			Result.success(Unit)
+		}
 	}
 
 	fun onToggleRestartOnPing() = viewModelScope.launch {
@@ -204,4 +223,32 @@ constructor(
 			),
 		)
 	}
+
+	fun checkKernelSupport() = viewModelScope.launch {
+		val kernelSupport =
+			withContext(ioDispatcher) {
+				WgQuickBackend.hasKernelSupport()
+			}
+		_kernelSupport.update {
+			kernelSupport
+		}
+	}
+
+	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,
+			),
+		)
+	}
 }

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

@@ -57,7 +57,7 @@ fun SupportScreen(
 	viewModel: SupportViewModel = hiltViewModel(),
 	appViewModel: AppViewModel,
 	navController: NavController,
-    focusRequester: FocusRequester
+	focusRequester: FocusRequester,
 ) {
 	val context = LocalContext.current
 	val fillMaxWidth = .85f
@@ -79,7 +79,8 @@ fun SupportScreen(
 			shape = RoundedCornerShape(12.dp),
 			color = MaterialTheme.colorScheme.surface,
 			modifier =
-            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+			(
+				if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
 					Modifier
 						.height(IntrinsicSize.Min)
 						.fillMaxWidth(fillMaxWidth)
@@ -88,7 +89,8 @@ fun SupportScreen(
 					Modifier
 						.fillMaxWidth(fillMaxWidth)
 						.padding(top = 20.dp)
-            })
+				}
+				)
 				.padding(bottom = 25.dp),
 		) {
 			Column(modifier = Modifier.padding(20.dp)) {
@@ -107,8 +109,14 @@ fun SupportScreen(
 					modifier = Modifier.padding(bottom = 20.dp),
 				)
 				TextButton(
-                    onClick = { appViewModel.openWebPage(context.resources.getString(R.string.docs_url), context) },
+					onClick = {
-                    modifier = Modifier
+						appViewModel.openWebPage(
+							context.resources.getString(R.string.docs_url),
+							context,
+						)
+					},
+					modifier =
+					Modifier
 						.padding(vertical = 5.dp)
 						.focusRequester(focusRequester),
 				) {
@@ -123,13 +131,14 @@ fun SupportScreen(
 							Text(
 								stringResource(id = R.string.docs_description),
 								textAlign = TextAlign.Justify,
-                                modifier = Modifier
+								modifier =
+								Modifier
 									.padding(start = 10.dp)
 									.weight(
 										weight = 1.0f,
 										fill = false,
 									),
-                                softWrap = true
+								softWrap = true,
 							)
 						}
 						Icon(
@@ -143,7 +152,12 @@ fun SupportScreen(
 					color = MaterialTheme.colorScheme.onBackground,
 				)
 				TextButton(
-                    onClick = { appViewModel.openWebPage(context.resources.getString(R.string.telegram_url), context) },
+					onClick = {
+						appViewModel.openWebPage(
+							context.resources.getString(R.string.telegram_url),
+							context,
+						)
+					},
 					modifier = Modifier.padding(vertical = 5.dp),
 				) {
 					Row(
@@ -175,7 +189,12 @@ fun SupportScreen(
 					color = MaterialTheme.colorScheme.onBackground,
 				)
 				TextButton(
-                    onClick = { appViewModel.openWebPage(context.resources.getString(R.string.github_url), context) },
+					onClick = {
+						appViewModel.openWebPage(
+							context.resources.getString(R.string.github_url),
+							context,
+						)
+					},
 					modifier = Modifier.padding(vertical = 5.dp),
 				) {
 					Row(
@@ -269,7 +288,10 @@ fun SupportScreen(
 			fontSize = 16.sp,
 			modifier =
 			Modifier.clickable {
-                appViewModel.openWebPage(context.resources.getString(R.string.privacy_policy_url), context)
+				appViewModel.openWebPage(
+					context.resources.getString(R.string.privacy_policy_url),
+					context,
+				)
 			},
 		)
 		Row(
@@ -277,12 +299,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

@@ -1,6 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.support.logs
 
 import android.annotation.SuppressLint
+import android.widget.Toast
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
@@ -8,7 +9,7 @@ import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.itemsIndexed
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
@@ -32,17 +33,16 @@ import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
+import androidx.hilt.navigation.compose.hiltViewModel
+import com.zaneschepke.logcatter.model.LogMessage
+import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.common.text.LogTypeLabel
 import kotlinx.coroutines.launch
 
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
 @Composable
-fun LogsScreen(appViewModel: AppViewModel) {
+fun LogsScreen(viewModel: LogsViewModel = hiltViewModel()) {
-
+	val logs = viewModel.logs
-    val logs = remember {
-        appViewModel.logs
-    }
 
 	val context = LocalContext.current
 
@@ -60,7 +60,15 @@ fun LogsScreen(appViewModel: AppViewModel) {
 		floatingActionButton = {
 			FloatingActionButton(
 				onClick = {
-                    appViewModel.saveLogsToFile(context)
+					scope.launch {
+						viewModel.saveLogsToFile().onSuccess {
+							Toast.makeText(
+								context,
+								context.getString(R.string.logs_saved),
+								Toast.LENGTH_SHORT,
+							).show()
+						}
+					}
 				},
 				shape = RoundedCornerShape(16.dp),
 				containerColor = MaterialTheme.colorScheme.primary,
@@ -78,21 +86,29 @@ fun LogsScreen(appViewModel: AppViewModel) {
 			horizontalAlignment = Alignment.CenterHorizontally,
 			verticalArrangement = Arrangement.spacedBy(16.dp, Alignment.Top),
 			state = lazyColumnListState,
-            modifier = Modifier
+			modifier =
+			Modifier
 				.fillMaxSize()
 				.padding(horizontal = 24.dp),
 		) {
-            items(logs) {
+			itemsIndexed(
+				logs,
+				key = { index, _ -> index },
+				contentType = { _: Int, _: LogMessage -> null },
+			) { _, it ->
 				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

@@ -0,0 +1,56 @@
+package com.zaneschepke.wireguardautotunnel.ui.screens.support.logs
+
+import androidx.compose.runtime.mutableStateListOf
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.zaneschepke.logcatter.LocalLogCollector
+import com.zaneschepke.logcatter.model.LogMessage
+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 dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.time.Duration
+import java.time.Instant
+import javax.inject.Inject
+
+@HiltViewModel
+class LogsViewModel
+@Inject
+constructor(
+	private val localLogCollector: LocalLogCollector,
+	private val fileUtils: FileUtils,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+	@MainDispatcher private val mainDispatcher: CoroutineDispatcher,
+) : ViewModel() {
+	val logs = mutableStateListOf<LogMessage>()
+
+	init {
+		viewModelScope.launch(ioDispatcher) {
+			localLogCollector.bufferedLogs.chunked(500, Duration.ofSeconds(1)).collect {
+				withContext(mainDispatcher) {
+					logs.addAll(it)
+				}
+				if (logs.size > Constants.LOG_BUFFER_SIZE) {
+					withContext(mainDispatcher) {
+						logs.removeRange(0, (logs.size - Constants.LOG_BUFFER_SIZE).toInt())
+					}
+				}
+			}
+		}
+	}
+
+	suspend fun saveLogsToFile(): Result<Unit> {
+		val file =
+			localLogCollector.getLogFile().getOrElse {
+				return Result.failure(it)
+			}
+		val fileContent = fileUtils.readBytesFromFile(file)
+		val fileName = "${Constants.BASE_LOG_FILE_NAME}-${Instant.now().epochSecond}.txt"
+		return fileUtils.saveByteArrayToDownloads(fileContent, fileName)
+	}
+}

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

@@ -49,7 +49,7 @@ fun WireguardAutoTunnelTheme(
 	// Dynamic color is available on Android 12+
 	// turning off dynamic color for now
 	dynamicColor: Boolean = false,
-    content: @Composable () -> Unit
+	content: @Composable () -> Unit,
 ) {
 	val colorScheme =
 		when {

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/Constants.kt

@@ -1,7 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.util
 
 object Constants {
-
 	const val BASE_LOG_FILE_NAME = "wg_tunnel_logs"
 	const val LOG_BUFFER_SIZE = 3_000L
 
@@ -16,10 +15,11 @@ object Constants {
 	const val URI_CONTENT_SCHEME = "content"
 	const val ALLOWED_FILE_TYPES = "*/*"
 	const val TEXT_MIME_TYPE = "text/plain"
+	const val ZIP_FILE_MIME_TYPE = "application/zip"
 	const val GOOGLE_TV_EXPLORER_STUB = "com.google.android.tv.frameworkpackagestubs"
 	const val ANDROID_TV_EXPLORER_STUB = "com.android.tv.frameworkpackagestubs"
 	const val ALWAYS_ON_VPN_ACTION = "android.net.VpnService"
-    const val EMAIL_MIME_TYPE = "message/rfc822"
+	const val EMAIL_MIME_TYPE = "plain/text"
 	const val SYSTEM_EXEMPT_SERVICE_TYPE_ID = 1024
 
 	const val SUBSCRIPTION_TIMEOUT = 5_000L
@@ -31,13 +31,10 @@ object Constants {
 	const val PING_INTERVAL = 60_000L
 	const val PING_COOLDOWN = PING_INTERVAL * 60 // one hour
 
-    const val ALLOWED_DISPLAY_NAME_LENGTH = 20
-
 	const val TUNNEL_EXTRA_KEY = "tunnelId"
 
 	const val UNREADABLE_SSID = "<unknown ssid>"
 
 	val amneziaProperties = listOf("Jc", "Jmin", "Jmax", "S1", "S2", "H1", "H2", "H3", "H4")
 	const val QR_CODE_NAME_PROPERTY = "# Name ="
-
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/Extensions.kt

@@ -1,6 +1,5 @@
 package com.zaneschepke.wireguardautotunnel.util
 
-import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.pm.PackageInfo
 import com.zaneschepke.wireguardautotunnel.R
@@ -9,34 +8,23 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.ObsoleteCoroutinesApi
+import kotlinx.coroutines.channels.ClosedReceiveChannelException
+import kotlinx.coroutines.channels.ReceiveChannel
+import kotlinx.coroutines.channels.produce
+import kotlinx.coroutines.channels.ticker
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.selects.whileSelect
 import org.amnezia.awg.config.Config
+import timber.log.Timber
 import java.math.BigDecimal
 import java.text.DecimalFormat
-import kotlin.coroutines.CoroutineContext
+import java.time.Duration
-import kotlin.coroutines.EmptyCoroutineContext
+import java.util.concurrent.ConcurrentLinkedQueue
-
+import kotlin.coroutines.cancellation.CancellationException
-fun BroadcastReceiver.goAsync(
-    context: CoroutineContext = EmptyCoroutineContext,
-    block: suspend CoroutineScope.() -> Unit
-) {
-    val pendingResult = goAsync()
-    @OptIn(DelicateCoroutinesApi::class) // Must run globally; there's no teardown callback.
-    GlobalScope.launch(context) {
-        try {
-            block()
-        } finally {
-            pendingResult.finish()
-        }
-    }
-}
-
-fun String.truncateWithEllipsis(allowedLength: Int): String {
-    return if (this.length > allowedLength + 3) {
-        this.substring(0, allowedLength) + "***"
-    } else this
-}
 
 fun BigDecimal.toThreeDecimalPlaceString(): String {
 	val df = DecimalFormat("#.###")
@@ -94,3 +82,63 @@ fun Throwable.getMessage(context: Context) : String {
 		else -> this.message ?: StringValue.StringResource(R.string.unknown_error).asString(context)
 	}
 }
+
+/**
+ * Chunks based on a time or size threshold.
+ *
+ * Borrowed from this [Stack Overflow question](https://stackoverflow.com/questions/51022533/kotlin-chunk-sequence-based-on-size-and-time).
+ */
+@OptIn(ObsoleteCoroutinesApi::class, ExperimentalCoroutinesApi::class)
+fun <T> ReceiveChannel<T>.chunked(scope: CoroutineScope, size: Int, time: Duration) = scope.produce<List<T>> {
+	while (true) { // this loop goes over each chunk
+		val chunk = ConcurrentLinkedQueue<T>() // current chunk
+		val ticker = ticker(time.toMillis()) // time-limit for this chunk
+		try {
+			whileSelect {
+				ticker.onReceive {
+					false // done with chunk when timer ticks, takes priority over received elements
+				}
+				this@chunked.onReceive {
+					chunk += it
+					chunk.size < size // continue whileSelect if chunk is not full
+				}
+			}
+		} catch (e: ClosedReceiveChannelException) {
+			Timber.e(e)
+			return@produce
+		} finally {
+			ticker.cancel()
+			if (chunk.isNotEmpty()) {
+				send(chunk.toList())
+			}
+		}
+	}
+}
+
+@OptIn(DelicateCoroutinesApi::class, ExperimentalCoroutinesApi::class)
+fun <T> Flow<T>.chunked(size: Int, time: Duration) = channelFlow {
+	coroutineScope {
+		val channel = asChannel(this@chunked).chunked(this, size, time)
+		try {
+			while (!channel.isClosedForReceive) {
+				send(channel.receive())
+			}
+		} catch (e: ClosedReceiveChannelException) {
+			// Channel was closed by the flow completing, nothing to do
+			Timber.w(e)
+		} catch (e: CancellationException) {
+			channel.cancel(e)
+			throw e
+		} catch (e: Exception) {
+			channel.cancel(CancellationException("Closing channel due to flow exception", e))
+			throw e
+		}
+	}
+}
+
+@ExperimentalCoroutinesApi
+fun <T> CoroutineScope.asChannel(flow: Flow<T>): ReceiveChannel<T> = produce {
+	flow.collect { value ->
+		channel.send(value)
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/FileUtils.kt

@@ -6,23 +6,103 @@ import android.os.Build
 import android.os.Environment
 import android.provider.MediaStore
 import android.provider.MediaStore.MediaColumns
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
 import timber.log.Timber
 import java.io.File
+import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.io.OutputStream
 import java.time.Instant
 import java.util.zip.ZipEntry
 import java.util.zip.ZipOutputStream
 
-object FileUtils {
+class FileUtils(
-    private const val ZIP_FILE_MIME_TYPE = "application/zip"
+	private val context: Context,
+	private val ioDispatcher: CoroutineDispatcher,
+) {
+	suspend fun readBytesFromFile(file: File): ByteArray {
+		return withContext(ioDispatcher) {
+			FileInputStream(file).use {
+				it.readBytes()
+			}
+		}
+	}
+
+	suspend fun readTextFromFileName(fileName: String): String {
+		return withContext(ioDispatcher) {
+			context.assets.open(fileName).use { stream ->
+				stream.bufferedReader(Charsets.UTF_8).use {
+					it.readText()
+				}
+			}
+		}
+	}
+
+	suspend fun saveByteArrayToDownloads(content: ByteArray, fileName: String): Result<Unit> {
+		return withContext(ioDispatcher) {
+			try {
+				if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+					val contentValues =
+						ContentValues().apply {
+							put(MediaColumns.DISPLAY_NAME, fileName)
+							put(MediaColumns.MIME_TYPE, Constants.TEXT_MIME_TYPE)
+							put(MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
+						}
+					val resolver = context.contentResolver
+					val uri =
+						resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues)
+					if (uri != null) {
+						resolver.openOutputStream(uri).use { output ->
+							output?.write(content)
+						}
+					}
+				} else {
+					val target =
+						File(
+							Environment.getExternalStoragePublicDirectory(
+								Environment.DIRECTORY_DOWNLOADS,
+							),
+							fileName,
+						)
+					FileOutputStream(target).use { output ->
+						output.write(content)
+					}
+				}
+				Result.success(Unit)
+			} catch (e: Exception) {
+				Result.failure(e)
+			}
+		}
+	}
+
+	suspend fun saveFilesToZip(files: List<File>): Result<Unit> {
+		return withContext(ioDispatcher) {
+			try {
+				val zipOutputStream =
+					createDownloadsFileOutputStream(
+						"wg-export_${Instant.now().epochSecond}.zip",
+						Constants.ZIP_FILE_MIME_TYPE,
+					)
+				ZipOutputStream(zipOutputStream).use { zos ->
+					files.forEach { file ->
+						val entry = ZipEntry(file.name)
+						zos.putNextEntry(entry)
+						if (file.isFile) {
+							file.inputStream().use { fis -> fis.copyTo(zos) }
+						}
+					}
+					return@withContext Result.success(Unit)
+				}
+			} catch (e: Exception) {
+				Timber.e(e)
+				Result.failure(WgTunnelExceptions.ConfigExportFailed())
+			}
+		}
+	}
 
 	// TODO issue with android 9
-    private fun createDownloadsFileOutputStream(
+	private fun createDownloadsFileOutputStream(fileName: String, mimeType: String = Constants.ALLOWED_FILE_TYPES): OutputStream? {
-        context: Context,
-        fileName: String,
-        mimeType: String = Constants.ALLOWED_FILE_TYPES
-    ): OutputStream? {
 		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
 			val resolver = context.contentResolver
 			val contentValues =
@@ -45,53 +125,4 @@ object FileUtils {
 		}
 		return null
 	}
-
-    fun saveFileToDownloads(context: Context, content: String, fileName: String) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            val contentValues = ContentValues().apply {
-                put(MediaColumns.DISPLAY_NAME, fileName)
-                put(MediaColumns.MIME_TYPE, Constants.TEXT_MIME_TYPE)
-                put(MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
-            }
-            val resolver = context.contentResolver
-            val uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues)
-            if (uri != null) {
-                resolver.openOutputStream(uri).use { output ->
-                    output?.write(content.toByteArray())
-                }
-            }
-        } else {
-            val target = File(
-                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
-                fileName,
-            )
-            FileOutputStream(target).use { output ->
-                output.write(content.toByteArray())
-            }
-        }
-    }
-
-    fun saveFilesToZip(context: Context, files: List<File>) : Result<Unit> {
-        return try {
-            val zipOutputStream =
-                createDownloadsFileOutputStream(
-                    context,
-                    "wg-export_${Instant.now().epochSecond}.zip",
-                    ZIP_FILE_MIME_TYPE,
-                )
-            ZipOutputStream(zipOutputStream).use { zos ->
-                files.forEach { file ->
-                    val entry = ZipEntry(file.name)
-                    zos.putNextEntry(entry)
-                    if (file.isFile) {
-                        file.inputStream().use { fis -> fis.copyTo(zos) }
-                    }
-                }
-                return Result.success(Unit)
-            }
-        } catch (e : Exception) {
-            Timber.e(e)
-            Result.failure(WgTunnelExceptions.ConfigExportFailed())
-        }
-    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/StringValue.kt

@@ -4,14 +4,13 @@ import android.content.Context
 import androidx.annotation.StringRes
 
 sealed class StringValue {
-
 	data class DynamicString(val value: String) : StringValue()
 
 	data object Empty : StringValue()
 
 	class StringResource(
 		@StringRes val resId: Int,
-        vararg val args: Any
+		vararg val args: Any,
 	) : StringValue()
 
 	fun asString(context: Context?): String {

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/WgTunnelExceptions.kt

@@ -5,120 +5,155 @@ import com.zaneschepke.wireguardautotunnel.R
 
 sealed class WgTunnelExceptions : Exception() {
 	abstract fun getMessage(context: Context): String
+
 	data class General(private val userMessage: StringValue) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class SsidConflict(private val userMessage : StringValue = StringValue.StringResource(R.string.error_ssid_exists)) : WgTunnelExceptions() {
+	data class SsidConflict(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_ssid_exists,
+			),
+	) :
+		WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class ConfigExportFailed(private val userMessage : StringValue = StringValue.StringResource(R.string.export_configs_failed)) : WgTunnelExceptions() {
+	data class ConfigExportFailed(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.export_configs_failed,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class ConfigParseError(private val appendMessage : StringValue = StringValue.Empty) : WgTunnelExceptions() {
+	data class ConfigParseError(private val appendMessage: StringValue = StringValue.Empty) :
+		WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return StringValue.StringResource(R.string.config_parse_error).asString(context) + (
-                if (appendMessage != StringValue.Empty) ": ${appendMessage.asString(context)}" else "")
+				if (appendMessage != StringValue.Empty) ": ${appendMessage.asString(context)}" else ""
+				)
 		}
 	}
 
-    data class RootDenied(private val userMessage : StringValue = StringValue.StringResource(R.string.error_root_denied)) : WgTunnelExceptions() {
+	data class RootDenied(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_root_denied,
+			),
+	) :
+		WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class InvalidQrCode(private val userMessage : StringValue = StringValue.StringResource(R.string.error_invalid_code)) : WgTunnelExceptions() {
+	data class InvalidQrCode(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_invalid_code,
+			),
+	) :
+		WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class InvalidFileExtension(private val userMessage : StringValue = StringValue.StringResource(R.string.error_file_extension)) : WgTunnelExceptions() {
+	data class InvalidFileExtension(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_file_extension,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class FileReadFailed(private val userMessage : StringValue = StringValue.StringResource(R.string.error_file_format)) : WgTunnelExceptions() {
+	data class FileReadFailed(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_file_format,
+			),
+	) :
+		WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class AuthenticationFailed(private val userMessage : StringValue = StringValue.StringResource(R.string.error_authentication_failed)) : WgTunnelExceptions() {
+	data class AuthenticationFailed(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_authentication_failed,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class AuthorizationFailed(private val userMessage : StringValue = StringValue.StringResource(R.string.error_authorization_failed)) : WgTunnelExceptions() {
+	data class AuthorizationFailed(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_authorization_failed,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class BackgroundLocationRequired(private val userMessage : StringValue = StringValue.StringResource(R.string.background_location_required)) : WgTunnelExceptions() {
+	data class BackgroundLocationRequired(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.background_location_required,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class LocationServicesRequired(private val userMessage : StringValue = StringValue.StringResource(R.string.location_services_required)) : WgTunnelExceptions() {
+	data class LocationServicesRequired(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.location_services_required,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class PreciseLocationRequired(private val userMessage : StringValue = StringValue.StringResource(R.string.precise_location_required)) : WgTunnelExceptions() {
+	data class PreciseLocationRequired(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.precise_location_required,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
 
-    data class FileExplorerRequired (private val userMessage : StringValue = StringValue.StringResource(R.string.error_no_file_explorer)) : WgTunnelExceptions() {
+	data class FileExplorerRequired(
+		private val userMessage: StringValue =
+			StringValue.StringResource(
+				R.string.error_no_file_explorer,
+			),
+	) : WgTunnelExceptions() {
 		override fun getMessage(context: Context): String {
 			return userMessage.asString(context)
 		}
 	}
-
-
-
-
-
-//        sealed class Message : Event() {
-//            data object ConfigSaved : Message() {
-//                override val message: String
-//                    get() = WireGuardAutoTunnel.instance.getString(R.string.config_changes_saved)
-//            }
-//
-//            data object ConfigsExported : Message() {
-//                override val message: String
-//                    get() = WireGuardAutoTunnel.instance.getString(R.string.exported_configs_message)
-//            }
-//
-//            data object TunnelOffAction : Message() {
-//                override val message: String
-//                    get() = WireGuardAutoTunnel.instance.getString(R.string.turn_off_tunnel)
-//            }
-//
-//            data object TunnelOnAction : Message() {
-//                override val message: String
-//                    get() = WireGuardAutoTunnel.instance.getString(R.string.turn_on_tunnel)
-//            }
-//
-//            data object AutoTunnelOffAction : Message() {
-//                override val message: String
-//                    get() = WireGuardAutoTunnel.instance.getString(R.string.turn_off_auto)
-//            }
-//        }
 }
-

app/src/main/res/drawable/add.xml

@@ -4,6 +4,6 @@
     android:viewportWidth="960"
     android:viewportHeight="960">
     <path
-      android:pathData="M440,520L200,520v-80h240v-240h80v240h240v80L520,520v240h-80v-240Z"
+        android:fillColor="#e8eaed"
-      android:fillColor="#e8eaed"/>
+        android:pathData="M440,520L200,520v-80h240v-240h80v240h240v80L520,520v240h-80v-240Z" />
 </vector>

app/src/main/res/drawable/close.xml

@@ -4,6 +4,6 @@
     android:viewportWidth="960"
     android:viewportHeight="960">
     <path
-      android:pathData="m256,760 l-56,-56 224,-224 -224,-224 56,-56 224,224 224,-224 56,56 -224,224 224,224 -56,56 -224,-224 -224,224Z"
+        android:fillColor="#e8eaed"
-      android:fillColor="#e8eaed"/>
+        android:pathData="m256,760 l-56,-56 224,-224 -224,-224 56,-56 224,224 224,-224 56,56 -224,224 224,224 -56,56 -224,-224 -224,224Z" />
 </vector>

app/src/main/res/drawable/edit.xml

@@ -4,6 +4,6 @@
     android:viewportWidth="960"
     android:viewportHeight="960">
     <path
-      android:pathData="M200,760h57l391,-391 -57,-57 -391,391v57ZM120,840v-170l528,-527q12,-11 26.5,-17t30.5,-6q16,0 31,6t26,18l55,56q12,11 17.5,26t5.5,30q0,16 -5.5,30.5T817,313L290,840L120,840ZM760,256 L704,200 760,256ZM619,341 L591,312 648,369 619,341Z"
+        android:fillColor="#e8eaed"
-      android:fillColor="#e8eaed"/>
+        android:pathData="M200,760h57l391,-391 -57,-57 -391,391v57ZM120,840v-170l528,-527q12,-11 26.5,-17t30.5,-6q16,0 31,6t26,18l55,56q12,11 17.5,26t5.5,30q0,16 -5.5,30.5T817,313L290,840L120,840ZM760,256 L704,200 760,256ZM619,341 L591,312 648,369 619,341Z" />
 </vector>

app/src/main/res/values-cs/strings.xml

@@ -0,0 +1,154 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="no_tunnels">Žádné tunely ještě nebyly přidány!</string>
+    <string name="watcher_notification_text_paused">Monitorování změn ve stavu sítě: pozastaveno</string>
+    <string name="notification_permission_required">Je vyžadováno oprávnění pro oznámení.</string>
+    <string name="add_trusted_ssid">Přidat název důvěryhodné Wi-Fi</string>
+    <string name="enable_auto_tunnel">Spustit automatické tunelování</string>
+    <string name="tunnel_mobile_data">Tunelování na mobilních datech</string>
+    <string name="one_tunnel_required">Alespoň jeden tunel je vyžadován pro použití této funkce</string>
+    <string name="privacy_policy">Otevřít zásady soukromí</string>
+    <string name="okay">OK</string>
+    <string name="thank_you">Děkujeme za používání WG Tunnel!</string>
+    <string name="add_tunnels_text">Přidat ze souboru nebo zipu</string>
+    <string name="open_file">Otevřít soubor</string>
+    <string name="add_from_qr">Přidat z QR kódu</string>
+    <string name="qr_scan">QR skenování</string>
+    <string name="tunnel_name">Název tunelu</string>
+    <string name="add_tunnel">Přidat tunel</string>
+    <string name="exclude">Vyloučit</string>
+    <string name="include">Zahrnout</string>
+    <string name="save_changes">Uložit</string>
+    <string name="endpoint">Koncový bod</string>
+    <string name="vpn_connection_failed">Připojení selhalo</string>
+    <string name="always_on_vpn_support">Povolit trvalé připojení VPN</string>
+    <string name="location_services_not_detected">Služby polohy nebyly detekovány</string>
+    <string name="hint_search_packages">Hledat balíčky</string>
+    <string name="attempt_connection">Pokus o připojení...</string>
+    <string name="vpn_starting">VPN se spouští</string>
+    <string name="vpn_on">VPN zapnuto</string>
+    <string name="vpn_off">VPN vypnuto</string>
+    <string name="default_vpn_on">Hlavní VPN zapnuto</string>
+    <string name="default_vpn_off">Hlavní VPN vypnuto</string>
+    <string name="create_import">Vytvořit od základu</string>
+    <string name="turn_off_auto">Akce vyžaduje, aby bylo automatické tunelování vypnuté či pozastavené</string>
+    <string name="add_peer">Přidat peer</string>
+    <string name="comma_separated_list">seznam oddělený čárkami</string>
+    <string name="random">(náhodné)</string>
+    <string name="optional">(volitelné)</string>
+    <string name="optional_no_recommend">(volitelné, nedoporučeno)</string>
+    <string name="preshared_key">Předsdílený klíč</string>
+    <string name="seconds">vteřin(y)</string>
+    <string name="cancel">Zrušit</string>
+    <string name="error_authentication_failed">Autentizace selhala</string>
+    <string name="error_authorization_failed">Nepovedlo se autorizovat</string>
+    <string name="enabled_app_shortcuts">Zapnout zkratky</string>
+    <string name="export_configs">Exportovat konfigurace</string>
+    <string name="export_configs_failed">Nepovedlo se exportovat konfigurace</string>
+    <string name="location_services_required">Služby polohy vyžadovány</string>
+    <string name="background_location_required">Oprávnění pro polohu na pozadí vyžadováno</string>
+    <string name="precise_location_required">Oprávnění pro přesnou polohu vyžadováno</string>
+    <string name="unknown_error">Došlo k neznámé chybě</string>
+    <string name="exported_configs_message">Konfigurace exportovány do stažených souborů</string>
+    <string name="tunnel_on_wifi">Tunelovat na nedůvěryhodné Wi-Fi</string>
+    <string name="email_subject">WG Tunnel podpora</string>
+    <string name="email_chooser">Poslat email…</string>
+    <string name="use_kernel">Použít kernel modul</string>
+    <string name="error_ssid_exists">SSID již existuje</string>
+    <string name="error_root_denied">Oprávnění root zamítnuto</string>
+    <string name="error_no_file_explorer">Žádný průzkumník souborů není nainstalován</string>
+    <string name="error_invalid_code">Neplatný QR kód</string>
+    <string name="error_none">Žádná chyba</string>
+    <string name="auto_tunnel_title">Služba automatického tunelování</string>
+    <string name="resume">Obnovit</string>
+    <string name="active">aktivní</string>
+    <string name="open_issue">Otevřít případ</string>
+    <string name="incorrect_pin">PIN je nesprávný</string>
+    <string name="create_pin">Vytvořte PIN</string>
+    <string name="set_primary_tunnel">Nastavit jako hlavní tunel</string>
+    <string name="use_tunnel_on_wifi_name">Použít tunel pro Wi-Fi</string>
+    <string name="edit_tunnel">Upravit tunel</string>
+    <string name="disabled">vypnuto</string>
+    <string name="auto_tun_on">Obnovit automatické tunelování</string>
+    <string name="auto_tun_off">Pozastavit automatické tunelování</string>
+    <string name="version">Verze</string>
+    <string name="mode">Mód</string>
+    <string name="use_amnezia">"Použít Amnezia userspace "</string>
+    <string name="junk_packet_count">Junk packet počet</string>
+    <string name="junk_packet_minimum_size">Junk packet minimální velikost</string>
+    <string name="junk_packet_maximum_size">Junk packet maximální velikost</string>
+    <string name="init_packet_junk_size">Init packet junk velikost</string>
+    <string name="response_packet_junk_size">Response packet junk velikost</string>
+    <string name="unsure_how">pokud si nejste jisti, jak postupovat</string>
+    <string name="see_the">Podívejte se na</string>
+    <string name="getting_started_guide">začátečnickou příručku</string>
+    <string name="error_file_format">Neplatný formát konfigurace</string>
+    <string name="error_file_extension">Soubor není ve formátu .conf nebo .zip</string>
+    <string name="turn_off_tunnel">Akce vyžaduje vypnutí tunelu</string>
+    <string name="watcher_notification_text_active">Monitorování změn ve stavu sítě: aktivní</string>
+    <string name="tunnel_on_ethernet">Tunelovat na ethernetu</string>
+    <string name="tunnel_start_title">VPN připojeno</string>
+    <string name="prominent_background_location_message">Tato funkce vyžaduje oprávnění pro přístup k poloze na pozadí pro zapnutí monitorování Wi-Fi SSID, i když je aplikace zavřená. Pro více detailů, podívejte se prosím na zásady soukromí umístěné v kategorii Podpora.</string>
+    <string name="tunnel_start_text">Připojeno k tunelu</string>
+    <string name="tunnels">Tunely</string>
+    <string name="disable_auto_tunnel">Zastavit automatické tunelování</string>
+    <string name="tunnel_all">Tunelovat všechny aplikace</string>
+    <string name="config_changes_saved">Změny v konfiguraci uloženy.</string>
+    <string name="icon">Ikona</string>
+    <string name="no_thanks">Ne, děkuji</string>
+    <string name="turn_on">Zapnout</string>
+    <string name="map">Mapa</string>
+    <string name="public_key">Veřejný klíč</string>
+    <string name="addresses">Adresy</string>
+    <string name="dns_servers">DNS servery</string>
+    <string name="allowed_ips">Povolené IP adresy</string>
+    <string name="name">Název</string>
+    <string name="restart">Restartovat tunel</string>
+    <string name="scanning_qr">Skenování QR</string>
+    <string name="none">Žádné názvy důvěryhodných Wi-Fi</string>
+    <string name="other">Ostatní</string>
+    <string name="auto_tunneling">Automatické tunelování</string>
+    <string name="turn_on_tunnel">Akce vyžaduje aktivní tunel</string>
+    <string name="interface_">Rozhraní</string>
+    <string name="done">Hotovo</string>
+    <string name="rotate_keys">Rotovat klíče</string>
+    <string name="private_key">Soukromý klíč</string>
+    <string name="copy_public_key">Kopírovat veřejný klíč</string>
+    <string name="base64_key">base64 klíč</string>
+    <string name="docs_description">Přečíst si dokumentaci</string>
+    <string name="discord_description">Přidat se ke komunitě</string>
+    <string name="email_description">Poslat mi email</string>
+    <string name="support_help_text">Pokud máte potíže, nápady pro zlepšení, nebo se chcete jen zapojit, následující prostředky jsou k dispozici:</string>
+    <string name="location_services_missing_message">Aplikace nenašla žádné služby polohy zapnuté na Vašem zařízení. Dle Vašeho zařízení, tohle může způsobit, že funkce nedůvěryhodné Wi-Fi nedokáže přečíst jméno připojené Wi-Fi. Chcete i přesto pokračovat?</string>
+    <string name="delete_tunnel">Smazat tunel</string>
+    <string name="delete_tunnel_message">Jste si jisti, že chcete smazat tento tunel?</string>
+    <string name="yes">Ano</string>
+    <string name="pause">Pozastavit</string>
+    <string name="paused">pozastaveno</string>
+    <string name="tunneling_apps">Tunelování aplikací</string>
+    <string name="all">vše</string>
+    <string name="included">zahrnuto</string>
+    <string name="excluded">vyloučeno</string>
+    <string name="always_on_disabled">Trvalé VPN připojení se pokusilo spustit tunel, ale tato funkce je vypnutá v nastavení.</string>
+    <string name="no_email_detected">Žádná emailová aplikace nebyla nalezena</string>
+    <string name="no_browser_detected">Žádný prohlížeč nebyl nalezen</string>
+    <string name="logs_saved">Logy uloženy do stažených souborů</string>
+    <string name="read_logs">Přečíst si logy</string>
+    <string name="config_parse_error">Nepovedlo se vložit konfiguraci</string>
+    <string name="pin_created">PIN úspěšně vytvořen</string>
+    <string name="enter_pin">Vložte Váš PIN</string>
+    <string name="no_wifi_names_configured">Žádné názvy Wi-Fi nebyly nastaveny pro tento tunel</string>
+    <string name="enable_app_lock">Zapnout zámek aplikace</string>
+    <string name="restart_on_ping">Restartovat při selhání pingu</string>
+    <string name="mobile_data_tunnel">Nastavit jako tunel pro mobilní data</string>
+    <string name="general">Obecné</string>
+    <string name="settings">Nastavení</string>
+    <string name="support">Podpora</string>
+    <string name="app_name">WG Tunnel</string>
+    <string name="mtu">MTU</string>
+    <string name="db_name">wg-tunnel-db</string>
+    <string name="listen_port">Naslouchací port</string>
+    <string name="auto">(automaticky)</string>
+    <string name="kernel">Kernel</string>
+    <string name="backend">Backend</string>
+</resources>