Automated build update

Fixes auto tunnel bug that can happen on startup
Fixes auto tunnel bug that didn't allow manual toggle override of tunnel while auto tunnel is active
Add basic foreground persistent notifications (optionally turned off via android settings)

.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/FUNDING.yml

@@ -1,2 +1,3 @@
 ko_fi: zaneschepke
 liberapay: zaneschepke
+github: zaneschepke

.github/ISSUE_TEMPLATE/bug_report.md

@@ -15,6 +15,7 @@ A clear and concise description of what the bug is.
 - Device: [e.g. Pixel 4a]
 - Android Version: [e.g. Android 13]
 - App Version [e.g. 3.3.3]
+- Backend: [e.g. Kernel, Userspace]
 
 **To Reproduce**
 Steps to reproduce the behavior:

.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/on-issue.yml

@@ -1,4 +1,4 @@
-name: Issue Updates Workflow
+name: on-issue
 
 on:
   issues:
@@ -7,8 +7,8 @@ on:
 
 jobs:
 
-  build:
+  on-issue:
-    name: Build
+    name: On new issue
     runs-on: ubuntu-latest
     steps:
       - name: Send Telegram Message

.github/workflows/on-publish.yml

@@ -1,4 +1,4 @@
-name: Release Updates Workflow
+name: on-publish
 
 on:
   release:
@@ -7,8 +7,8 @@ on:
 
 jobs:
 
-  build:
+  on-publish:
-    name: Build
+    name: On publish
     runs-on: ubuntu-latest
     steps:
       - name: Send Telegram Message

.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,19 +1,63 @@
-# 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: none
+        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
+  workflow_call:
 
 jobs:
-  build:
+  check_commits:
-    name: Build Signed APK
+    name: Check for New Commits
-
     runs-on: ubuntu-latest
+    outputs:
+      has_new_commits: ${{ steps.check.outputs.new_commits }}
 
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # This fetches all history so we can check commits
+
+      - name: Check for new commits
+        id: check
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          # This script checks for commits newer than 23 hours ago
+          NEW_COMMITS=$(git rev-list --count --after="$(date -Iseconds -d '23 hours ago')" ${{ github.sha }})
+          echo "new_commits=$NEW_COMMITS" >> $GITHUB_OUTPUT
+  build:
+    needs: check_commits
+    if: ${{ needs.check_commits.outputs.has_new_commits > 0 && inputs.release_type != 'none' }}
+    name: Build Signed APK
+    runs-on: ubuntu-latest
     env:
       SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
       SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
@@ -21,7 +65,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 +80,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 +107,167 @@ 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
+
+      - name: Commit and push versionCode changes
+        if: ${{ inputs.release_type == '' || inputs.release_type == 'nightly'  || inputs.release_type == 'prerelease' }}
+        run: |
+          git config --global user.name 'GitHub Actions'
+          git config --global user.email 'actions@github.com'
+          git add versionCode.txt
+          git commit -m "Automated build update"
+
+      - name: Push changes
+        if: ${{ inputs.release_type == '' || inputs.release_type == 'nightly'  || inputs.release_type == 'prerelease' }}
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ github.ref }}
+
       # 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.4.3
         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
+          git push origin :nightly || 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 }})
 

.gitignore

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

README.md

@@ -55,32 +55,30 @@ and on while on different networks. This app was created to offer a free solutio
 * Split tunneling by application with search
 * WireGuard support for kernel and userspace modes
 * Amnezia support for userspace mode for DPI/censorship protection
+* Pre/Post Up/Down scripts support for all modes on a rooted device
 * Always-On VPN support
 * Export Amnezia and WireGuard tunnels to zip
 * Quick tile support for tunnel toggling, auto-tunneling
 * Static shortcuts support for tunnel toggling, auto-tunneling
 * Intent automation support for all tunnels
-* Automatic auto-tunneling service restart after reboot
+* Automatic auto-tunneling service and/or tunnel restart after reboot or app update
-* Automatic tunnel restart after reboot
 * 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.
@@ -102,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,214 +1,245 @@
-import java.util.Properties
-
 plugins {
-    alias(libs.plugins.android.application)
+	alias(libs.plugins.android.application)
-    alias(libs.plugins.kotlin.android)
+	alias(libs.plugins.kotlin.android)
-    alias(libs.plugins.hilt.android)
+	alias(libs.plugins.hilt.android)
-    alias(libs.plugins.kotlinxSerialization)
+	alias(libs.plugins.kotlinxSerialization)
-    alias(libs.plugins.ksp)
+	alias(libs.plugins.ksp)
+	alias(libs.plugins.compose.compiler)
+	alias(libs.plugins.grgit)
+}
+
+val versionFile = file("$rootDir/versionCode.txt")
+
+val versionCodeIncrement = with(getBuildTaskName().lowercase()) {
+	when {
+		this.contains(Constants.NIGHTLY) || this.contains(Constants.PRERELEASE) -> {
+			if (versionFile.exists()) {
+				versionFile.readText().toInt() + 1
+			} else {
+				1
+			}
+		}
+		else -> 0
+	}
 }
 
 android {
-    namespace = Constants.APP_ID
+	namespace = Constants.APP_ID
-    compileSdk = Constants.TARGET_SDK
+	compileSdk = Constants.TARGET_SDK
 
-    androidResources {
+	androidResources {
-        generateLocaleConfig = true
+		generateLocaleConfig = true
-    }
+	}
 
-    defaultConfig {
+	defaultConfig {
-        applicationId = Constants.APP_ID
+		applicationId = Constants.APP_ID
-        minSdk = Constants.MIN_SDK
+		minSdk = Constants.MIN_SDK
-        targetSdk = Constants.TARGET_SDK
+		targetSdk = Constants.TARGET_SDK
-        versionCode = Constants.VERSION_CODE
+		versionCode = Constants.VERSION_CODE + versionCodeIncrement
-        versionName = Constants.VERSION_NAME
+		versionName = determineVersionName()
 
-        ksp { arg("room.schemaLocation", "$projectDir/schemas") }
+		ksp { arg("room.schemaLocation", "$projectDir/schemas") }
 
-        sourceSets {
+		sourceSets {
-            getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
+			getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
-        }
+		}
 
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+		buildConfigField("String[]", "LANGUAGES", "new String[]{ ${languageList().joinToString(separator = ", ") { "\"$it\"" }} }")
-        vectorDrawables { useSupportLibrary = true }
-    }
 
-    signingConfigs {
+		testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        create(Constants.RELEASE) {
+		vectorDrawables { useSupportLibrary = true }
-            val properties =
+	}
-                Properties().apply {
-                    // created local file for signing details
-                    try {
-                        load(file("signing.properties").reader())
-                    } catch (_: Exception) {
-                        load(file("signing_template.properties").reader())
-                    }
-                }
 
-            // try to get secrets from env first for pipeline build, then properties file for local
+	signingConfigs {
-            // build
+		create(Constants.RELEASE) {
-            storeFile =
+			storeFile = getStoreFile()
-                file(
+			storePassword = getSigningProperty(Constants.STORE_PASS_VAR)
-                    System.getenv()
+			keyAlias = getSigningProperty(Constants.KEY_ALIAS_VAR)
-                        .getOrDefault(
+			keyPassword = getSigningProperty(Constants.KEY_PASS_VAR)
-                            Constants.KEY_STORE_PATH_VAR,
+		}
-                            properties.getProperty(Constants.KEY_STORE_PATH_VAR),
+	}
-                        ),
-                )
-            storePassword =
-                System.getenv()
-                    .getOrDefault(
-                        Constants.STORE_PASS_VAR,
-                        properties.getProperty(Constants.STORE_PASS_VAR),
-                    )
-            keyAlias =
-                System.getenv()
-                    .getOrDefault(
-                        Constants.KEY_ALIAS_VAR,
-                        properties.getProperty(Constants.KEY_ALIAS_VAR),
-                    )
-            keyPassword =
-                System.getenv()
-                    .getOrDefault(
-                        Constants.KEY_PASS_VAR,
-                        properties.getProperty(Constants.KEY_PASS_VAR),
-                    )
-        }
-    }
 
-    buildTypes {
+	buildTypes {
-        // don't strip
+		// don't strip
-        packaging.jniLibs.keepDebugSymbols.addAll(
+		packaging.jniLibs.keepDebugSymbols.addAll(
-            listOf("libwg-go.so", "libwg-quick.so", "libwg.so"),
+			listOf("libwg-go.so", "libwg-quick.so", "libwg.so"),
-        )
+		)
 
-        applicationVariants.all {
+		release {
-            val variant = this
+			isDebuggable = false
-            variant.outputs
+			isMinifyEnabled = true
-                .map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
+			isShrinkResources = true
-                .forEach { output ->
+			proguardFiles(
-                    val outputFileName =
+				getDefaultProguardFile("proguard-android-optimize.txt"),
-                        "${Constants.APP_NAME}-${variant.flavorName}-${variant.buildType.name}-${variant.versionName}.apk"
+				"proguard-rules.pro",
-                    output.outputFileName = outputFileName
+			)
-                }
+			signingConfig = signingConfigs.getByName(Constants.RELEASE)
-        }
+			resValue("string", "provider", "\"${Constants.APP_NAME}.provider\"")
-        release {
+		}
-            isDebuggable = false
+		debug {
-            isMinifyEnabled = true
+			applicationIdSuffix = ".debug"
-            isShrinkResources = true
+			versionNameSuffix = "-debug"
-            proguardFiles(
+			resValue("string", "app_name", "WG Tunnel - Debug")
-                getDefaultProguardFile("proguard-android-optimize.txt"),
+			isDebuggable = true
-                "proguard-rules.pro",
+			resValue("string", "provider", "\"${Constants.APP_NAME}.provider.debug\"")
-            )
+		}
-            signingConfig = signingConfigs.getByName(Constants.RELEASE)
+
-        }
+		create(Constants.PRERELEASE) {
-        debug { isDebuggable = true }
+			initWith(buildTypes.getByName(Constants.RELEASE))
-    }
+			applicationIdSuffix = ".prerelease"
-    flavorDimensions.add(Constants.TYPE)
+			versionNameSuffix = "-pre"
-    productFlavors {
+			resValue("string", "app_name", "WG Tunnel - Pre")
-        create("fdroid") {
+			resValue("string", "provider", "\"${Constants.APP_NAME}.provider.pre\"")
-            dimension = Constants.TYPE
+		}
-            proguardFile("fdroid-rules.pro")
+
-        }
+		create(Constants.NIGHTLY) {
-        create("general") {
+			initWith(buildTypes.getByName(Constants.RELEASE))
-            dimension = Constants.TYPE
+			applicationIdSuffix = ".nightly"
-            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
+			versionNameSuffix = "-nightly"
-                //any plugins general specific
+			resValue("string", "app_name", "WG Tunnel - Nightly")
-            }
+			resValue("string", "provider", "\"${Constants.APP_NAME}.provider.nightly\"")
-        }
+		}
-    }
+
-    compileOptions {
+		applicationVariants.all {
-        sourceCompatibility = JavaVersion.VERSION_17
+			val variant = this
-        targetCompatibility = JavaVersion.VERSION_17
+			variant.outputs
-        isCoreLibraryDesugaringEnabled = true
+				.map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
-    }
+				.forEach { output ->
-    kotlinOptions { jvmTarget = Constants.JVM_TARGET }
+					val outputFileName =
-    buildFeatures {
+						"${Constants.APP_NAME}-${variant.flavorName}-" +
-        compose = true
+							"${variant.buildType.name}-${variant.versionName}.apk"
-        buildConfig = true
+					output.outputFileName = outputFileName
-    }
+				}
-    composeOptions { kotlinCompilerExtensionVersion = Constants.COMPOSE_COMPILER_EXTENSION_VERSION }
+		}
-    packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
+	}
+	flavorDimensions.add(Constants.TYPE)
+	productFlavors {
+		create("fdroid") {
+			dimension = Constants.TYPE
+			proguardFile("fdroid-rules.pro")
+		}
+		create("general") {
+			dimension = Constants.TYPE
+		}
+	}
+	compileOptions {
+		sourceCompatibility = JavaVersion.VERSION_17
+		targetCompatibility = JavaVersion.VERSION_17
+		isCoreLibraryDesugaringEnabled = true
+	}
+	kotlinOptions { jvmTarget = Constants.JVM_TARGET }
+	buildFeatures {
+		compose = true
+		buildConfig = true
+	}
+	packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
-val generalImplementation by configurations
-
 dependencies {
 
-    implementation(project(":logcatter"))
+	implementation(project(":logcatter"))
 
-    implementation(libs.androidx.core.ktx)
+	implementation(libs.androidx.core.ktx)
-    implementation(libs.androidx.lifecycle.runtime.ktx)
+	implementation(libs.androidx.lifecycle.runtime.ktx)
 
-    // helpers for implementing LifecycleOwner in a Service
+	// helpers for implementing LifecycleOwner in a Service
-    implementation(libs.androidx.lifecycle.service)
+	implementation(libs.androidx.lifecycle.service)
-    implementation(libs.androidx.activity.compose)
+	implementation(libs.androidx.activity.compose)
-    implementation(platform(libs.androidx.compose.bom))
+	implementation(platform(libs.androidx.compose.bom))
-    implementation(libs.androidx.compose.ui)
+	implementation(libs.androidx.compose.ui)
-    implementation(libs.androidx.compose.ui.graphics)
+	implementation(libs.androidx.compose.ui.graphics)
-    implementation(libs.androidx.compose.ui.tooling.preview)
+	implementation(libs.androidx.compose.ui.tooling.preview)
-    implementation(libs.androidx.material3)
+	implementation(libs.androidx.material3)
-    implementation(libs.androidx.appcompat)
+	implementation(libs.androidx.appcompat)
+	implementation(libs.material)
 
-    // test
+	// test
-    testImplementation(libs.junit)
+	testImplementation(libs.junit)
-    testImplementation(libs.androidx.junit)
+	testImplementation(libs.androidx.junit)
-    androidTestImplementation(libs.androidx.junit)
+	androidTestImplementation(libs.androidx.junit)
-    androidTestImplementation(libs.androidx.espresso.core)
+	androidTestImplementation(libs.androidx.espresso.core)
-    androidTestImplementation(platform(libs.androidx.compose.bom))
+	androidTestImplementation(platform(libs.androidx.compose.bom))
-    androidTestImplementation(libs.androidx.compose.ui.test)
+	androidTestImplementation(libs.androidx.compose.ui.test)
-    androidTestImplementation(libs.androidx.room.testing)
+	androidTestImplementation(libs.androidx.room.testing)
-    debugImplementation(libs.androidx.compose.ui.tooling)
+	debugImplementation(libs.androidx.compose.ui.tooling)
-    debugImplementation(libs.androidx.compose.manifest)
+	debugImplementation(libs.androidx.compose.manifest)
 
-    // get tunnel lib from github packages or mavenLocal
+	// get tunnel lib from github packages or mavenLocal
-    implementation(libs.tunnel)
+// 	implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
-    implementation(libs.amneziawg.android)
+	implementation(libs.tunnel)
-    coreLibraryDesugaring(libs.desugar.jdk.libs)
+	implementation(libs.amneziawg.android)
+	coreLibraryDesugaring(libs.desugar.jdk.libs)
 
-    // logging
+	// logging
-    implementation(libs.timber)
+	implementation(libs.timber)
 
+	// compose navigation
+	implementation(libs.androidx.navigation.compose)
+	implementation(libs.androidx.hilt.navigation.compose)
 
-    // compose navigation
+	// hilt
-    implementation(libs.androidx.navigation.compose)
+	implementation(libs.hilt.android)
-    implementation(libs.androidx.hilt.navigation.compose)
+	ksp(libs.hilt.android.compiler)
 
-    implementation(libs.zaneschepke.multifab)
+	// accompanist
+	implementation(libs.accompanist.permissions)
+	implementation(libs.accompanist.flowlayout)
+	implementation(libs.accompanist.drawablepainter)
 
-    // hilt
+	// storage
-    implementation(libs.hilt.android)
+	implementation(libs.androidx.room.runtime)
-    ksp(libs.hilt.android.compiler)
+	ksp(libs.androidx.room.compiler)
+	implementation(libs.androidx.room.ktx)
+	implementation(libs.androidx.datastore.preferences)
 
-    // accompanist
+	// lifecycle
-    implementation(libs.accompanist.permissions)
+	implementation(libs.lifecycle.runtime.compose)
-    implementation(libs.accompanist.flowlayout)
+	implementation(libs.androidx.lifecycle.runtime.ktx)
-    implementation(libs.accompanist.drawablepainter)
+	implementation(libs.androidx.lifecycle.process)
 
-    // storage
+	// icons
-    implementation(libs.androidx.room.runtime)
+	implementation(libs.material.icons.extended)
-    ksp(libs.androidx.room.compiler)
+	// serialization
-    implementation(libs.androidx.room.ktx)
+	implementation(libs.kotlinx.serialization.json)
-    implementation(libs.androidx.datastore.preferences)
 
-    // lifecycle
+	// barcode scanning
-    implementation(libs.lifecycle.runtime.compose)
+	implementation(libs.zxing.android.embedded)
-    implementation(libs.androidx.lifecycle.runtime.ktx)
-    implementation(libs.androidx.lifecycle.process)
 
-    // icons
+	// bio
-    implementation(libs.material.icons.extended)
+	implementation(libs.androidx.biometric.ktx)
-    // serialization
+	implementation(libs.pin.lock.compose)
-    implementation(libs.kotlinx.serialization.json)
 
-    // barcode scanning
+	// shortcuts
-    implementation(libs.zxing.android.embedded)
+	implementation(libs.androidx.core)
+	implementation(libs.androidx.core.google.shortcuts)
 
-    // bio
+	// splash
-    implementation(libs.androidx.biometric.ktx)
+	implementation(libs.androidx.core.splashscreen)
-    implementation(libs.pin.lock.compose)
+}
-
+
-    // shortcuts
+fun determineVersionName(): String {
-    implementation(libs.androidx.core)
+	return with(getBuildTaskName().lowercase()) {
-    implementation(libs.androidx.core.google.shortcuts)
+		when {
+			contains(Constants.NIGHTLY) || contains(Constants.PRERELEASE) ->
+				Constants.VERSION_NAME +
+					"-${grgitService.service.get().grgit.head().abbreviatedId}"
+			else -> Constants.VERSION_NAME
+		}
+	}
+}
+
+val incrementVersionCode by tasks.registering {
+	doLast {
+		val versionFile = file("$rootDir/versionCode.txt")
+		if (versionFile.exists()) {
+			versionFile.writeText(versionCodeIncrement.toString())
+			println("Incremented versionCode to $versionCodeIncrement")
+		}
+	}
+}
+
+tasks.whenTaskAdded {
+	if (name.startsWith("assemble") && !name.lowercase().contains("debug")) {
+		dependsOn(incrementVersionCode)
+	}
 }

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

@@ -0,0 +1,225 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 10,
+    "identityHash": "c8621055524f90b4d1972f6171f59e80",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_enabled` INTEGER NOT NULL DEFAULT false, `is_restore_on_boot_enabled` INTEGER NOT NULL DEFAULT false, `is_multi_tunnel_enabled` INTEGER NOT NULL DEFAULT false, `is_auto_tunnel_paused` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false, `is_amnezia_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnWifiEnabled",
+            "columnName": "is_tunnel_on_wifi_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelEnabled",
+            "columnName": "is_kernel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isRestoreOnBootEnabled",
+            "columnName": "is_restore_on_boot_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isMultiTunnelEnabled",
+            "columnName": "is_multi_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isAutoTunnelPaused",
+            "columnName": "is_auto_tunnel_paused",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPingEnabled",
+            "columnName": "is_ping_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isAmneziaEnabled",
+            "columnName": "is_amnezia_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false, `ping_interval` INTEGER DEFAULT null, `ping_cooldown` INTEGER DEFAULT null, `ping_ip` TEXT DEFAULT null)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "tunnelNetworks",
+            "columnName": "tunnel_networks",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isMobileDataTunnel",
+            "columnName": "is_mobile_data_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPrimaryTunnel",
+            "columnName": "is_primary_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "amQuick",
+            "columnName": "am_quick",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isActive",
+            "columnName": "is_Active",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPingEnabled",
+            "columnName": "is_ping_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "pingInterval",
+            "columnName": "ping_interval",
+            "affinity": "INTEGER",
+            "notNull": false,
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingCooldown",
+            "columnName": "ping_cooldown",
+            "affinity": "INTEGER",
+            "notNull": false,
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingIp",
+            "columnName": "ping_ip",
+            "affinity": "TEXT",
+            "notNull": false,
+            "defaultValue": "null"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'c8621055524f90b4d1972f6171f59e80')"
+    ]
+  }
+}

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

@@ -0,0 +1,232 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 11,
+    "identityHash": "4c9418386f72dfac5d28ab96c1e5ea0b",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_enabled` INTEGER NOT NULL DEFAULT false, `is_restore_on_boot_enabled` INTEGER NOT NULL DEFAULT false, `is_multi_tunnel_enabled` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false, `is_amnezia_enabled` INTEGER NOT NULL DEFAULT false, `is_wildcards_enabled` INTEGER NOT NULL DEFAULT false, `is_wifi_by_shell_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnWifiEnabled",
+            "columnName": "is_tunnel_on_wifi_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelEnabled",
+            "columnName": "is_kernel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isRestoreOnBootEnabled",
+            "columnName": "is_restore_on_boot_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isMultiTunnelEnabled",
+            "columnName": "is_multi_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPingEnabled",
+            "columnName": "is_ping_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isAmneziaEnabled",
+            "columnName": "is_amnezia_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isWildcardsEnabled",
+            "columnName": "is_wildcards_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isWifiNameByShellEnabled",
+            "columnName": "is_wifi_by_shell_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL, `tunnel_networks` TEXT NOT NULL DEFAULT '', `is_mobile_data_tunnel` INTEGER NOT NULL DEFAULT false, `is_primary_tunnel` INTEGER NOT NULL DEFAULT false, `am_quick` TEXT NOT NULL DEFAULT '', `is_Active` INTEGER NOT NULL DEFAULT false, `is_ping_enabled` INTEGER NOT NULL DEFAULT false, `ping_interval` INTEGER DEFAULT null, `ping_cooldown` INTEGER DEFAULT null, `ping_ip` TEXT DEFAULT null)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "tunnelNetworks",
+            "columnName": "tunnel_networks",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isMobileDataTunnel",
+            "columnName": "is_mobile_data_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPrimaryTunnel",
+            "columnName": "is_primary_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "amQuick",
+            "columnName": "am_quick",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "isActive",
+            "columnName": "is_Active",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isPingEnabled",
+            "columnName": "is_ping_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "pingInterval",
+            "columnName": "ping_interval",
+            "affinity": "INTEGER",
+            "notNull": false,
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingCooldown",
+            "columnName": "ping_cooldown",
+            "affinity": "INTEGER",
+            "notNull": false,
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingIp",
+            "columnName": "ping_ip",
+            "affinity": "TEXT",
+            "notNull": false,
+            "defaultValue": "null"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '4c9418386f72dfac5d28ab96c1e5ea0b')"
+    ]
+  }
+}

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

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

app/src/androidTest/java/com/zaneschepke/wireguardautotunnel/ExampleInstrumentedTest.kt

@@ -13,10 +13,10 @@ import org.junit.runner.RunWith
  */
 @RunWith(AndroidJUnit4::class)
 class ExampleInstrumentedTest {
-    @Test
+	@Test
-    fun useAppContext() {
+	fun useAppContext() {
-        // Context of the app under test.
+		// Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+		val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("com.zaneschepke.wireguardautotunnel", appContext.packageName)
+		assertEquals("com.zaneschepke.wireguardautotunnel", appContext.packageName)
-    }
+	}
 }

app/src/androidTest/java/com/zaneschepke/wireguardautotunnel/MigrationTest.kt

@@ -12,33 +12,33 @@ import java.io.IOException
 
 @RunWith(AndroidJUnit4::class)
 class MigrationTest {
-    private val dbName = "migration-test"
+	private val dbName = "migration-test"
 
-    @get:Rule
+	@get:Rule
-    val helper: MigrationTestHelper =
+	val helper: MigrationTestHelper =
-        MigrationTestHelper(
+		MigrationTestHelper(
-            InstrumentationRegistry.getInstrumentation(),
+			InstrumentationRegistry.getInstrumentation(),
-            AppDatabase::class.java,
+			AppDatabase::class.java,
-        )
+		)
 
-    @Test
+	@Test
-    @Throws(IOException::class)
+	@Throws(IOException::class)
-    fun migrate6To7() {
+	fun migrate6To7() {
-        helper.createDatabase(dbName, 6).apply {
+		helper.createDatabase(dbName, 6).apply {
-            // Database has schema version 1. Insert some data using SQL queries.
+			// Database has schema version 1. Insert some data using SQL queries.
-            // You can't use DAO classes because they expect the latest schema.
+			// You can't use DAO classes because they expect the latest schema.
-            execSQL(Queries.createDefaultSettings())
+			execSQL(Queries.createDefaultSettings())
-            execSQL(
+			execSQL(
-                Queries.createTunnelConfig(),
+				Queries.createTunnelConfig(),
-            )
+			)
-            // Prepare for the next version.
+			// Prepare for the next version.
-            close()
+			close()
-        }
+		}
 
-        // Re-open the database with version 2 and provide
+		// Re-open the database with version 2 and provide
-        // MIGRATION_1_2 as the migration process.
+		// MIGRATION_1_2 as the migration process.
-        helper.runMigrationsAndValidate(dbName, 7, true)
+		helper.runMigrationsAndValidate(dbName, 7, true)
-        // MigrationTestHelper automatically verifies the schema changes,
+		// MigrationTestHelper automatically verifies the schema changes,
-        // but you need to validate that the data was migrated properly.
+		// but you need to validate that the data was migrated properly.
-    }
+	}
 }

app/src/main/AndroidManifest.xml

@@ -3,17 +3,7 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
-        android:name="android.permission.READ_EXTERNAL_STORAGE"
-        android:maxSdkVersion="32" />
-    <uses-permission
-        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
-        android:maxSdkVersion="32"
-        tools:ignore="ScopedStorage" />
-    <uses-permission
-        android:name="android.permission.ACCESS_WIFI_STATE"
-        android:maxSdkVersion="30"
-        tools:ignore="LeanbackUsesWifi" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
@@ -22,7 +12,8 @@
     <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
     <!--foreground service exempt android 14-->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED" />
-    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"
+		tools:ignore="ProtectedPermissions" />
 
     <!--foreground service permissions-->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
@@ -31,6 +22,12 @@
     <!--start service on boot permission-->
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <!--android tv support-->
+
+	<permission
+		android:name="${applicationId}.permission.CONTROL_TUNNELS"
+		android:icon="@mipmap/ic_launcher"
+		android:protectionLevel="dangerous" />
+
     <uses-feature
         android:name="android.software.leanback"
         android:required="false" />
@@ -43,6 +40,12 @@
     <uses-feature
         android:name="android.hardware.screen.portrait"
         android:required="false" />
+	<uses-feature
+		android:name="android.hardware.gamepad"
+		android:required="false"/>
+
+	<uses-feature android:name="android.hardware.wifi"
+		android:required="false"/>
 
     <queries>
         <intent>
@@ -51,7 +54,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,7 +63,7 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.WireguardAutoTunnel"
+        android:theme="@style/Theme.App.Start"
         tools:targetApi="tiramisu">
         <activity
             android:name=".ui.MainActivity"
@@ -71,7 +74,6 @@
 
                 <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,25 +81,30 @@
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
-            android:name=".ui.CaptureActivityPortrait"
+            android:name="com.journeyapps.barcodescanner.CaptureActivity"
-            android:screenOrientation="fullSensor"
+            android:screenOrientation="portrait"
-            android:stateNotNeeded="true"
+            tools:replace="screenOrientation" />
-            android:theme="@style/zxing_CaptureTheme"
+
-            android:windowSoftInputMode="stateAlwaysHidden"
-            tools:ignore="DiscouragedApi" />
         <activity
             android:name=".service.shortcut.ShortcutsActivity"
             android:enabled="true"
             android:exported="true"
-            android:finishOnTaskLaunch="true"
+			android:noHistory="true"
+			android:excludeFromRecents="true"
+			android:finishOnTaskLaunch="true"
+			android:launchMode="singleInstance"
             android:theme="@android:style/Theme.NoDisplay" />
 
-        <service
+		<provider
-            android:name=".service.foreground.ForegroundService"
+			android:name="androidx.core.content.FileProvider"
-            android:enabled="true"
+			android:authorities="@string/provider"
-            android:exported="false"
+			android:exported="false"
-            android:foregroundServiceType="systemExempted"
+			android:grantUriPermissions="true">
-            tools:node="merge" />
+			<meta-data
+				android:name="android.support.FILE_PROVIDER_PATHS"
+				android:resource="@xml/file_paths" />
+		</provider>
+
         <service
             android:name=".service.tile.TunnelControlTile"
             android:exported="true"
@@ -132,23 +139,23 @@
                 <action android:name="android.service.quicksettings.action.QS_TILE" />
             </intent-filter>
         </service>
+		<service
+			android:name=".service.tunnel.AlwaysOnVpnService"
+			android:enabled="true"
+			android:exported="false"
+			android:foregroundServiceType="systemExempted"
+			android:permission="android.permission.BIND_VPN_SERVICE"
+			android:persistent="true"
+			tools:node="merge">
+			<intent-filter>
+				<action android:name="android.net.VpnService" />
+			</intent-filter>
+			<meta-data
+				android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
+				android:value="true" />
+		</service>
         <service
-            android:name=".service.foreground.WireGuardTunnelService"
+            android:name=".service.foreground.AutoTunnelService"
-            android:enabled="true"
-            android:exported="false"
-            android:foregroundServiceType="systemExempted"
-            android:permission="android.permission.BIND_VPN_SERVICE"
-            android:persistent="true"
-            tools:node="merge">
-            <intent-filter>
-                <action android:name="android.net.VpnService" />
-            </intent-filter>
-            <meta-data
-                android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
-                android:value="true" />
-        </service>
-        <service
-            android:name=".service.foreground.WireGuardConnectivityWatcherService"
             android:enabled="true"
             android:exported="false"
             android:foregroundServiceType="systemExempted"
@@ -156,6 +163,17 @@
             android:stopWithTask="false"
             tools:node="merge" />
 
+		<service
+			android:name=".service.foreground.TunnelBackgroundService"
+			android:exported="false"
+			android:persistent="true"
+			android:foregroundServiceType="systemExempted"
+			android:permission="android.permission.BIND_VPN_SERVICE">
+			<intent-filter>
+				<action android:name="android.net.VpnService" />
+			</intent-filter>
+		</service>
+
         <receiver
             android:name=".receiver.BootReceiver"
             android:enabled="true"
@@ -169,8 +187,20 @@
                 <action android:name="com.htc.intent.action.QUICKBOOT_POWERON" />
             </intent-filter>
         </receiver>
-        <receiver
+		<receiver
-            android:name=".receiver.NotificationActionReceiver"
+			android:name=".receiver.AppUpdateReceiver"
-            android:exported="false" />
+			android:exported="false">
+			<intent-filter>
+				<action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+			</intent-filter>
+		</receiver>
+		<receiver
+			android:name=".receiver.KernelReceiver"
+			android:exported="false"
+			android:permission="${applicationId}.permission.CONTROL_TUNNELS">
+			<intent-filter>
+				<action android:name="com.wireguard.android.action.REFRESH_TUNNEL_STATES" />
+			</intent-filter>
+		</receiver>
     </application>
 </manifest>

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

@@ -1,80 +1,70 @@
 package com.zaneschepke.wireguardautotunnel
 
 import android.app.Application
-import android.content.ComponentName
+import android.content.Context
-import android.content.pm.PackageManager
 import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
-import android.service.quicksettings.TileService
+import com.zaneschepke.logcatter.LogReader
-import com.zaneschepke.logcatter.LocalLogCollector
+import com.zaneschepke.wireguardautotunnel.data.datastore.LocaleStorage
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
+import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
-import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
 import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import dagger.hilt.android.HiltAndroidApp
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
 
-    @Inject
+	val localeStorage: LocaleStorage by lazy {
-    lateinit var localLogCollector: LocalLogCollector
+		LocaleStorage(this)
+	}
 
-    @Inject
+	@Inject
-    @ApplicationScope
+	@ApplicationScope
-    lateinit var applicationScope: CoroutineScope
+	lateinit var applicationScope: CoroutineScope
 
-    @Inject
+	@Inject
-    @IoDispatcher
+	lateinit var logReader: LogReader
-    lateinit var ioDispatcher: CoroutineDispatcher
 
-    override fun onCreate() {
+	@Inject
-        super.onCreate()
+	@IoDispatcher
-        instance = this
+	lateinit var ioDispatcher: CoroutineDispatcher
-        if (BuildConfig.DEBUG) {
-            Timber.plant(Timber.DebugTree())
-            StrictMode.setThreadPolicy(
-                ThreadPolicy.Builder()
-                    .detectDiskReads()
-                    .detectDiskWrites()
-                    .detectNetwork()
-                    .penaltyLog()
-                    .build(),
-            )
-        } else Timber.plant(ReleaseTree())
-        applicationScope.launch(ioDispatcher) {
-            PinManager.initialize(this@WireGuardAutoTunnel)
-            if (!isRunningOnAndroidTv()) localLogCollector.start()
-        }
-    }
 
-    companion object {
+	override fun onCreate() {
+		super.onCreate()
+		instance = this
+		if (BuildConfig.DEBUG) {
+			Timber.plant(Timber.DebugTree())
+			StrictMode.setThreadPolicy(
+				ThreadPolicy.Builder()
+					.detectDiskReads()
+					.detectDiskWrites()
+					.detectNetwork()
+					.penaltyLog()
+					.build(),
+			)
+		} else {
+			Timber.plant(ReleaseTree())
+		}
+		if (!isRunningOnTv()) {
+			applicationScope.launch(ioDispatcher) {
+				logReader.start()
+			}
+		}
+	}
 
-        lateinit var instance: WireGuardAutoTunnel
+	override fun attachBaseContext(base: Context) {
-            private set
+		super.attachBaseContext(LocaleUtil.getLocalizedContext(base, LocaleStorage(base).getPreferredLocale()))
+	}
 
-        fun isRunningOnAndroidTv(): Boolean {
+	companion object {
-            return instance.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
+		lateinit var instance: WireGuardAutoTunnel
-        }
+			private set
-
+	}
-        fun requestTunnelTileServiceStateUpdate() {
-            TileService.requestListeningState(
-                instance,
-                ComponentName(instance, TunnelControlTile::class.java),
-            )
-        }
-
-        fun requestAutoTunnelTileServiceUpdate() {
-            TileService.requestListeningState(
-                instance,
-                ComponentName(instance, AutoTunnelControlTile::class.java),
-            )
-        }
-    }
 }

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

@@ -10,46 +10,59 @@ import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 
 @Database(
-    entities = [Settings::class, TunnelConfig::class],
+	entities = [Settings::class, TunnelConfig::class],
-    version = 8,
+	version = 11,
-    autoMigrations =
+	autoMigrations =
-    [
+	[
-        AutoMigration(from = 1, to = 2),
+		AutoMigration(from = 1, to = 2),
-        AutoMigration(from = 2, to = 3),
+		AutoMigration(from = 2, to = 3),
-        AutoMigration(
+		AutoMigration(
-            from = 3,
+			from = 3,
-            to = 4,
+			to = 4,
-        ),
+		),
-        AutoMigration(
+		AutoMigration(
-            from = 4,
+			from = 4,
-            to = 5,
+			to = 5,
-        ),
+		),
-        AutoMigration(
+		AutoMigration(
-            from = 5,
+			from = 5,
-            to = 6,
+			to = 6,
-        ),
+		),
-        AutoMigration(
+		AutoMigration(
-            from = 6,
+			from = 6,
-            to = 7,
+			to = 7,
-            spec = RemoveLegacySettingColumnsMigration::class,
+			spec = RemoveLegacySettingColumnsMigration::class,
-        ),
+		),
-        AutoMigration(7, 8),
+		AutoMigration(7, 8),
-    ],
+		AutoMigration(8, 9),
-    exportSchema = true,
+		AutoMigration(9, 10),
+		AutoMigration(
+			from = 10,
+			to = 11,
+			spec = RemoveTunnelPauseMigration::class,
+		),
+	],
+	exportSchema = true,
 )
 @TypeConverters(DatabaseListConverters::class)
 abstract class AppDatabase : RoomDatabase() {
-    abstract fun settingDao(): SettingsDao
+	abstract fun settingDao(): SettingsDao
 
-    abstract fun tunnelConfigDoa(): TunnelConfigDao
+	abstract fun tunnelConfigDoa(): TunnelConfigDao
 }
 
 @DeleteColumn(
-    tableName = "Settings",
+	tableName = "Settings",
-    columnName = "default_tunnel",
+	columnName = "default_tunnel",
 )
 @DeleteColumn(
-    tableName = "Settings",
+	tableName = "Settings",
-    columnName = "is_battery_saver_enabled",
+	columnName = "is_battery_saver_enabled",
 )
 class RemoveLegacySettingColumnsMigration : AutoMigrationSpec
+
+@DeleteColumn(
+	tableName = "Settings",
+	columnName = "is_auto_tunnel_paused",
+)
+class RemoveTunnelPauseMigration : AutoMigrationSpec

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

@@ -5,17 +5,17 @@ import androidx.sqlite.db.SupportSQLiteDatabase
 import timber.log.Timber
 
 class DatabaseCallback : RoomDatabase.Callback() {
-    override fun onCreate(db: SupportSQLiteDatabase) = db.run {
+	override fun onCreate(db: SupportSQLiteDatabase) = db.run {
-        // Notice non-ui thread is here
+		// Notice non-ui thread is here
-        beginTransaction()
+		beginTransaction()
-        try {
+		try {
-            execSQL(Queries.createDefaultSettings())
+			execSQL(Queries.createDefaultSettings())
-            Timber.i("Bootstrapping settings data")
+			Timber.i("Bootstrapping settings data")
-            setTransactionSuccessful()
+			setTransactionSuccessful()
-        } catch (e: Exception) {
+		} catch (e: Exception) {
-            Timber.e(e)
+			Timber.e(e)
-        } finally {
+		} finally {
-            endTransaction()
+			endTransaction()
-        }
+		}
-    }
+	}
 }

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

@@ -5,20 +5,20 @@ import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 
 class DatabaseListConverters {
-    @TypeConverter
+	@TypeConverter
-    fun listToString(value: MutableList<String>): String {
+	fun listToString(value: MutableList<String>): String {
-        return Json.encodeToString(value)
+		return Json.encodeToString(value)
-    }
+	}
 
-    @TypeConverter
+	@TypeConverter
-    fun stringToList(value: String): MutableList<String> {
+	fun stringToList(value: String): MutableList<String> {
-        if (value.isBlank() || value.isEmpty()) return mutableListOf()
+		if (value.isBlank() || value.isEmpty()) return mutableListOf()
-        return try {
+		return try {
-            Json.decodeFromString<MutableList<String>>(value)
+			Json.decodeFromString<MutableList<String>>(value)
-        } catch (e: Exception) {
+		} catch (e: Exception) {
-            val list = value.split(",").toMutableList()
+			val list = value.split(",").toMutableList()
-            val json = listToString(list)
+			val json = listToString(list)
-            Json.decodeFromString<MutableList<String>>(json)
+			Json.decodeFromString<MutableList<String>>(json)
-        }
+		}
-    }
+	}
 }

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

@@ -1,35 +1,35 @@
 package com.zaneschepke.wireguardautotunnel.data
 
 object Queries {
-    fun createDefaultSettings(): String {
+	fun createDefaultSettings(): String {
-        return """
+		return """
-            INSERT INTO Settings (is_tunnel_enabled,
+		INSERT INTO Settings (is_tunnel_enabled,
-                    is_tunnel_on_mobile_data_enabled,
+		        is_tunnel_on_mobile_data_enabled,
-                    trusted_network_ssids,
+		        trusted_network_ssids,
-                    is_always_on_vpn_enabled,
+		        is_always_on_vpn_enabled,
-                    is_tunnel_on_ethernet_enabled,
+		        is_tunnel_on_ethernet_enabled,
-                    is_shortcuts_enabled,
+		        is_shortcuts_enabled,
-                    is_tunnel_on_wifi_enabled,
+		        is_tunnel_on_wifi_enabled,
-                    is_kernel_enabled,
+		        is_kernel_enabled,
-                    is_restore_on_boot_enabled,
+		        is_restore_on_boot_enabled,
-                    is_multi_tunnel_enabled)
+		        is_multi_tunnel_enabled)
-                    VALUES
+		        VALUES
-                    ('false',
+		        ('false',
-                    'false',
+		        'false',
-                    'sampleSSID1,sampleSSID2',
+		        'sampleSSID1,sampleSSID2',
-                    'false',
+		        'false',
-                    'false',
+		        'false',
-                    'false',
+		        'false',
-                    'false',
+		        'false',
-                    'false',
+		        'false',
-                    'false',
+		        'false',
-                    'false')
+		        'false')
-        """.trimIndent()
+		""".trimIndent()
-    }
+	}
 
-    fun createTunnelConfig(): String {
+	fun createTunnelConfig(): String {
-        return """
+		return """
-            INSERT INTO TunnelConfig (name, wg_quick) VALUES ('test', 'test')
+		INSERT INTO TunnelConfig (name, wg_quick) VALUES ('test', 'test')
-        """.trimIndent()
+		""".trimIndent()
-    }
+	}
 }

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

@@ -10,27 +10,27 @@ import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface SettingsDao {
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
+	@Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun save(t: Settings)
+	suspend fun save(t: Settings)
 
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
+	@Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun saveAll(t: List<Settings>)
+	suspend fun saveAll(t: List<Settings>)
 
-    @Query("SELECT * FROM settings WHERE id=:id")
+	@Query("SELECT * FROM settings WHERE id=:id")
-    suspend fun getById(id: Long): Settings?
+	suspend fun getById(id: Long): Settings?
 
-    @Query("SELECT * FROM settings")
+	@Query("SELECT * FROM settings")
-    suspend fun getAll(): List<Settings>
+	suspend fun getAll(): List<Settings>
 
-    @Query("SELECT * FROM settings LIMIT 1")
+	@Query("SELECT * FROM settings LIMIT 1")
-    fun getSettingsFlow(): Flow<Settings>
+	fun getSettingsFlow(): Flow<Settings>
 
-    @Query("SELECT * FROM settings")
+	@Query("SELECT * FROM settings")
-    fun getAllFlow(): Flow<MutableList<Settings>>
+	fun getAllFlow(): Flow<MutableList<Settings>>
 
-    @Delete
+	@Delete
-    suspend fun delete(t: Settings)
+	suspend fun delete(t: Settings)
 
-    @Query("SELECT COUNT('id') FROM settings")
+	@Query("SELECT COUNT('id') FROM settings")
-    suspend fun count(): Long
+	suspend fun count(): Long
 }

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

@@ -6,47 +6,50 @@ import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface TunnelConfigDao {
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
+	@Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun save(t: TunnelConfig)
+	suspend fun save(t: TunnelConfig)
 
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
+	@Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun saveAll(t: TunnelConfigs)
+	suspend fun saveAll(t: TunnelConfigs)
 
-    @Query("SELECT * FROM TunnelConfig WHERE id=:id")
+	@Query("SELECT * FROM TunnelConfig WHERE id=:id")
-    suspend fun getById(id: Long): TunnelConfig?
+	suspend fun getById(id: Long): TunnelConfig?
 
-    @Query("SELECT * FROM TunnelConfig WHERE name=:name")
+	@Query("SELECT * FROM TunnelConfig WHERE name=:name")
-    suspend fun getByName(name: String): TunnelConfig?
+	suspend fun getByName(name: String): TunnelConfig?
 
-    @Query("SELECT * FROM TunnelConfig")
+	@Query("SELECT * FROM TunnelConfig WHERE is_Active=1")
-    suspend fun getAll(): TunnelConfigs
+	suspend fun getActive(): TunnelConfigs
 
-    @Delete
+	@Query("SELECT * FROM TunnelConfig")
-    suspend fun delete(t: TunnelConfig)
+	suspend fun getAll(): TunnelConfigs
 
-    @Query("SELECT COUNT('id') FROM TunnelConfig")
+	@Delete
-    suspend fun count(): Long
+	suspend fun delete(t: TunnelConfig)
 
-    @Query("SELECT * FROM TunnelConfig WHERE tunnel_networks LIKE '%' || :name || '%'")
+	@Query("SELECT COUNT('id') FROM TunnelConfig")
-    suspend fun findByTunnelNetworkName(name: String): TunnelConfigs
+	suspend fun count(): Long
 
-    @Query("UPDATE TunnelConfig SET is_primary_tunnel = 0 WHERE is_primary_tunnel =1")
+	@Query("SELECT * FROM TunnelConfig WHERE tunnel_networks LIKE '%' || :name || '%'")
-    suspend fun resetPrimaryTunnel()
+	suspend fun findByTunnelNetworkName(name: String): TunnelConfigs
 
-    @Query("UPDATE TunnelConfig SET is_mobile_data_tunnel = 0 WHERE is_mobile_data_tunnel =1")
+	@Query("UPDATE TunnelConfig SET is_primary_tunnel = 0 WHERE is_primary_tunnel =1")
-    suspend fun resetMobileDataTunnel()
+	suspend fun resetPrimaryTunnel()
 
-    @Query("SELECT * FROM TUNNELCONFIG WHERE is_primary_tunnel=1")
+	@Query("UPDATE TunnelConfig SET is_mobile_data_tunnel = 0 WHERE is_mobile_data_tunnel =1")
-    suspend fun findByPrimary(): TunnelConfigs
+	suspend fun resetMobileDataTunnel()
 
-    @Query("SELECT * FROM TUNNELCONFIG WHERE is_mobile_data_tunnel=1")
+	@Query("SELECT * FROM TUNNELCONFIG WHERE is_primary_tunnel=1")
-    suspend fun findByMobileDataTunnel(): TunnelConfigs
+	suspend fun findByPrimary(): TunnelConfigs
 
-    @Query("SELECT * FROM tunnelconfig")
+	@Query("SELECT * FROM TUNNELCONFIG WHERE is_mobile_data_tunnel=1")
-    fun getAllFlow(): Flow<MutableList<TunnelConfig>>
+	suspend fun findByMobileDataTunnel(): TunnelConfigs
+
+	@Query("SELECT * FROM tunnelconfig")
+	fun getAllFlow(): Flow<MutableList<TunnelConfig>>
 }

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

@@ -4,7 +4,6 @@ import android.content.Context
 import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.intPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
@@ -18,65 +17,75 @@ import timber.log.Timber
 import java.io.IOException
 
 class DataStoreManager(
-    private val context: Context,
+	private val context: Context,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) {
-    companion object {
+	companion object {
-        val LOCATION_DISCLOSURE_SHOWN = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
+		val locationDisclosureShown = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
-        val BATTERY_OPTIMIZE_DISABLE_SHOWN = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
+		val batteryDisableShown = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
-        val TUNNEL_RUNNING_FROM_MANUAL_START =
+		val currentSSID = stringPreferencesKey("CURRENT_SSID")
-            booleanPreferencesKey("TUNNEL_RUNNING_FROM_MANUAL_START")
+		val pinLockEnabled = booleanPreferencesKey("PIN_LOCK_ENABLED")
-        val ACTIVE_TUNNEL = intPreferencesKey("ACTIVE_TUNNEL")
+		val tunnelStatsExpanded = booleanPreferencesKey("TUNNEL_STATS_EXPANDED")
-        val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
+		val theme = stringPreferencesKey("THEME")
-    }
+	}
 
-    // preferences
+	// preferences
-    private val preferencesKey = "preferences"
+	private val preferencesKey = "preferences"
-    private val Context.dataStore by
+	private val Context.dataStore by
-    preferencesDataStore(
+		preferencesDataStore(
-        name = preferencesKey,
+			name = preferencesKey,
-    )
+		)
 
-    suspend fun init() {
+	suspend fun init() {
-        withContext(ioDispatcher) {
+		withContext(ioDispatcher) {
-            try {
+			try {
-                context.dataStore.data.first()
+				context.dataStore.data.first()
-            } catch (e: IOException) {
+			} catch (e: IOException) {
-                Timber.e(e)
+				Timber.e(e)
-            }
+			}
-        }
+		}
-    }
+	}
 
-    suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) {
+	suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) {
-        withContext(ioDispatcher) {
+		withContext(ioDispatcher) {
-            try {
+			try {
-                context.dataStore.edit { it[key] = value }
+				context.dataStore.edit { it[key] = value }
-            } catch (e: IOException) {
+			} catch (e: IOException) {
-                Timber.e(e)
+				Timber.e(e)
-            } catch (e: Exception) {
+			} catch (e: Exception) {
-                Timber.e(e)
+				Timber.e(e)
-            }
+			}
-        }
+		}
-    }
+	}
 
+	suspend fun <T> removeFromDataStore(key: Preferences.Key<T>) {
+		withContext(ioDispatcher) {
+			try {
+				context.dataStore.edit { it.remove(key) }
+			} catch (e: IOException) {
+				Timber.e(e)
+			} catch (e: Exception) {
+				Timber.e(e)
+			}
+		}
+	}
 
-    fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map { it[key] }
+	fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map { it[key] }
 
-    suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
+	suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
-        return withContext(ioDispatcher) {
+		return withContext(ioDispatcher) {
-            try {
+			try {
-                context.dataStore.data.map { it[key] }.first()
+				context.dataStore.data.map { it[key] }.first()
-            } catch (e: IOException) {
+			} catch (e: IOException) {
-                Timber.e(e)
+				Timber.e(e)
-                null
+				null
-            }
+			}
-        }
+		}
-    }
+	}
 
+	fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
+		context.dataStore.data.map { it[key] }.first()
+	}
 
-    fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
+	val preferencesFlow: Flow<Preferences?> = context.dataStore.data
-        context.dataStore.data.map { it[key] }.first()
-    }
-
-    val preferencesFlow: Flow<Preferences?> = context.dataStore.data
 }

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

@@ -0,0 +1,17 @@
+package com.zaneschepke.wireguardautotunnel.data.datastore
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
+
+class LocaleStorage(context: Context) {
+	private var preferences: SharedPreferences = context.getSharedPreferences("sp", Context.MODE_PRIVATE)
+
+	fun getPreferredLocale(): String {
+		return preferences.getString("preferred_locale", LocaleUtil.OPTION_PHONE_LANGUAGE)!!
+	}
+
+	fun setPreferredLocale(localeCode: String) {
+		preferences.edit().putString("preferred_locale", localeCode).apply()
+	}
+}

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

@@ -1,14 +1,18 @@
 package com.zaneschepke.wireguardautotunnel.data.domain
 
+import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
+
 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 isPinLockEnabled: Boolean = PIN_LOCK_ENABLED_DEFAULT,
-    val activeTunnelId: Int? = null
+	val isTunnelStatsExpanded: Boolean = IS_TUNNEL_STATS_EXPANDED,
+	val theme: Theme = Theme.AUTOMATIC,
 ) {
-    companion object {
+	companion object {
-        const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
+		const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
-        const val BATTERY_OPTIMIZATION_DISABLE_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
-    }
+		const val IS_TUNNEL_STATS_EXPANDED = false
+	}
 }

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

@@ -6,53 +6,58 @@ import androidx.room.PrimaryKey
 
 @Entity
 data class Settings(
-    @PrimaryKey(autoGenerate = true) val id: Int = 0,
+	@PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "is_tunnel_enabled") val isAutoTunnelEnabled: Boolean = false,
+	@ColumnInfo(name = "is_tunnel_enabled") val isAutoTunnelEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled")
+	@ColumnInfo(name = "is_tunnel_on_mobile_data_enabled")
-    val isTunnelOnMobileDataEnabled: Boolean = false,
+	val isTunnelOnMobileDataEnabled: Boolean = false,
-    @ColumnInfo(name = "trusted_network_ssids")
+	@ColumnInfo(name = "trusted_network_ssids")
-    val trustedNetworkSSIDs: MutableList<String> = mutableListOf(),
+	val trustedNetworkSSIDs: MutableList<String> = mutableListOf(),
-    @ColumnInfo(name = "is_always_on_vpn_enabled") val isAlwaysOnVpnEnabled: Boolean = false,
+	@ColumnInfo(name = "is_always_on_vpn_enabled") val isAlwaysOnVpnEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled")
+	@ColumnInfo(name = "is_tunnel_on_ethernet_enabled")
-    val isTunnelOnEthernetEnabled: Boolean = false,
+	val isTunnelOnEthernetEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_shortcuts_enabled",
+		name = "is_shortcuts_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isShortcutsEnabled: Boolean = false,
+	val isShortcutsEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_tunnel_on_wifi_enabled",
+		name = "is_tunnel_on_wifi_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isTunnelOnWifiEnabled: Boolean = false,
+	val isTunnelOnWifiEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_kernel_enabled",
+		name = "is_kernel_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isKernelEnabled: Boolean = false,
+	val isKernelEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_restore_on_boot_enabled",
+		name = "is_restore_on_boot_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isRestoreOnBootEnabled: Boolean = false,
+	val isRestoreOnBootEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_multi_tunnel_enabled",
+		name = "is_multi_tunnel_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isMultiTunnelEnabled: Boolean = false,
+	val isMultiTunnelEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_auto_tunnel_paused",
+		name = "is_ping_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isAutoTunnelPaused: Boolean = false,
+	val isPingEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_ping_enabled",
+		name = "is_amnezia_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isPingEnabled: Boolean = false,
+	val isAmneziaEnabled: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_amnezia_enabled",
+		name = "is_wildcards_enabled",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isAmneziaEnabled: Boolean = false,
+	val isWildcardsEnabled: Boolean = false,
+	@ColumnInfo(
+		name = "is_wifi_by_shell_enabled",
+		defaultValue = "false",
+	)
+	val isWifiNameByShellEnabled: Boolean = false,
 )

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

@@ -9,45 +9,76 @@ import java.io.InputStream
 
 @Entity(indices = [Index(value = ["name"], unique = true)])
 data class TunnelConfig(
-    @PrimaryKey(autoGenerate = true) val id: Int = 0,
+	@PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "name") val name: String,
+	@ColumnInfo(name = "name") val name: String,
-    @ColumnInfo(name = "wg_quick") val wgQuick: String,
+	@ColumnInfo(name = "wg_quick") val wgQuick: String,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "tunnel_networks",
+		name = "tunnel_networks",
-        defaultValue = "",
+		defaultValue = "",
-    )
+	)
-    val tunnelNetworks: MutableList<String> = mutableListOf(),
+	val tunnelNetworks: MutableList<String> = mutableListOf(),
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_mobile_data_tunnel",
+		name = "is_mobile_data_tunnel",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isMobileDataTunnel: Boolean = false,
+	val isMobileDataTunnel: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "is_primary_tunnel",
+		name = "is_primary_tunnel",
-        defaultValue = "false",
+		defaultValue = "false",
-    )
+	)
-    val isPrimaryTunnel: Boolean = false,
+	val isPrimaryTunnel: Boolean = false,
-    @ColumnInfo(
+	@ColumnInfo(
-        name = "am_quick",
+		name = "am_quick",
-        defaultValue = "",
+		defaultValue = "",
-    )
+	)
-    val amQuick: String = AM_QUICK_DEFAULT,
+	val amQuick: String = AM_QUICK_DEFAULT,
+	@ColumnInfo(
+		name = "is_Active",
+		defaultValue = "false",
+	)
+	val isActive: Boolean = false,
+	@ColumnInfo(
+		name = "is_ping_enabled",
+		defaultValue = "false",
+	)
+	val isPingEnabled: Boolean = false,
+	@ColumnInfo(
+		name = "ping_interval",
+		defaultValue = "null",
+	)
+	val pingInterval: Long? = null,
+	@ColumnInfo(
+		name = "ping_cooldown",
+		defaultValue = "null",
+	)
+	val pingCooldown: Long? = null,
+	@ColumnInfo(
+		name = "ping_ip",
+		defaultValue = "null",
+	)
+	var pingIp: String? = null,
 ) {
-    companion object {
-        fun configFromWgQuick(wgQuick: String): Config {
-            val inputStream: InputStream = wgQuick.byteInputStream()
-            return inputStream.bufferedReader(Charsets.UTF_8).use {
-                Config.parse(it)
-            }
-        }
 
-        fun configFromAmQuick(amQuick: String): org.amnezia.awg.config.Config {
+	fun toAmConfig(): org.amnezia.awg.config.Config {
-            val inputStream: InputStream = amQuick.byteInputStream()
+		return configFromAmQuick(if (amQuick != "") amQuick else wgQuick)
-            return inputStream.bufferedReader(Charsets.UTF_8).use {
+	}
-                org.amnezia.awg.config.Config.parse(it)
-            }
-        }
 
-        const val AM_QUICK_DEFAULT = ""
+	companion object {
-    }
+
+		fun configFromWgQuick(wgQuick: String): Config {
+			val inputStream: InputStream = wgQuick.byteInputStream()
+			return inputStream.bufferedReader(Charsets.UTF_8).use {
+				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

@@ -3,12 +3,11 @@ package com.zaneschepke.wireguardautotunnel.data.repository
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 
 interface AppDataRepository {
-    suspend fun getPrimaryOrFirstTunnel(): TunnelConfig?
+	suspend fun getPrimaryOrFirstTunnel(): TunnelConfig?
-    suspend fun getStartTunnelConfig(): TunnelConfig?
 
-    suspend fun toggleWatcherServicePause()
+	suspend fun getStartTunnelConfig(): TunnelConfig?
 
-    val settings: SettingsRepository
+	val settings: SettingsRepository
-    val tunnels: TunnelConfigRepository
+	val tunnels: TunnelConfigRepository
-    val appState: AppStateRepository
+	val appState: AppStateRepository
 }

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

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

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

@@ -1,26 +1,33 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
 import kotlinx.coroutines.flow.Flow
 
 interface AppStateRepository {
-    suspend fun isLocationDisclosureShown(): Boolean
+	suspend fun isLocationDisclosureShown(): Boolean
-    suspend fun setLocationDisclosureShown(shown: Boolean)
 
-    suspend fun isBatteryOptimizationDisableShown(): Boolean
+	suspend fun setLocationDisclosureShown(shown: Boolean)
-    suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
 
-    suspend fun isTunnelRunningFromManualStart(): Boolean
+	suspend fun isPinLockEnabled(): Boolean
-    suspend fun setTunnelRunningFromManualStart(id: Int)
 
-    suspend fun setManualStop()
+	suspend fun setPinLockEnabled(enabled: Boolean)
 
-    suspend fun getActiveTunnelId(): Int?
+	suspend fun isBatteryOptimizationDisableShown(): Boolean
 
-    suspend fun getCurrentSsid(): String?
+	suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
 
-    suspend fun setCurrentSsid(ssid: String)
+	suspend fun getCurrentSsid(): String?
 
-    val generalStateFlow: Flow<GeneralState>
+	suspend fun setCurrentSsid(ssid: String)
 
+	suspend fun isTunnelStatsExpanded(): Boolean
+
+	suspend fun setTunnelStatsExpanded(expanded: Boolean)
+
+	suspend fun setTheme(theme: Theme)
+
+	suspend fun getTheme(): Theme
+
+	val generalStateFlow: Flow<GeneralState>
 }

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

@@ -2,80 +2,94 @@ package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
 import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import timber.log.Timber
 
-class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager) :
+class DataStoreAppStateRepository(
-    AppStateRepository {
+	private val dataStoreManager: DataStoreManager,
-    override suspend fun isLocationDisclosureShown(): Boolean {
+) :
-        return dataStoreManager.getFromStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN)
+	AppStateRepository {
-            ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
+	override suspend fun isLocationDisclosureShown(): Boolean {
-    }
+		return dataStoreManager.getFromStore(DataStoreManager.locationDisclosureShown)
+			?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
+	}
 
-    override suspend fun setLocationDisclosureShown(shown: Boolean) {
+	override suspend fun setLocationDisclosureShown(shown: Boolean) {
-        dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown)
+		dataStoreManager.saveToDataStore(DataStoreManager.locationDisclosureShown, shown)
-    }
+	}
 
-    override suspend fun isBatteryOptimizationDisableShown(): Boolean {
+	override suspend fun isPinLockEnabled(): Boolean {
-        return dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
+		return dataStoreManager.getFromStore(DataStoreManager.pinLockEnabled)
-            ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
+			?: GeneralState.PIN_LOCK_ENABLED_DEFAULT
-    }
+	}
 
-    override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
+	override suspend fun setPinLockEnabled(enabled: Boolean) {
-        dataStoreManager.saveToDataStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN, shown)
+		dataStoreManager.saveToDataStore(DataStoreManager.pinLockEnabled, enabled)
-    }
+	}
 
-    override suspend fun isTunnelRunningFromManualStart(): Boolean {
+	override suspend fun isBatteryOptimizationDisableShown(): Boolean {
-        return dataStoreManager.getFromStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START)
+		return dataStoreManager.getFromStore(DataStoreManager.batteryDisableShown)
-            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT
+			?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
-    }
+	}
 
-    override suspend fun setTunnelRunningFromManualStart(id: Int) {
+	override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
-        setTunnelRunningFromManualStart(true)
+		dataStoreManager.saveToDataStore(DataStoreManager.batteryDisableShown, shown)
-        setActiveTunnelId(id)
+	}
-    }
 
-    override suspend fun setManualStop() {
+	override suspend fun getCurrentSsid(): String? {
-        setTunnelRunningFromManualStart(false)
+		return dataStoreManager.getFromStore(DataStoreManager.currentSSID)
-    }
+	}
 
-    private suspend fun setTunnelRunningFromManualStart(running: Boolean) {
+	override suspend fun setCurrentSsid(ssid: String) {
-        dataStoreManager.saveToDataStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START, running)
+		dataStoreManager.saveToDataStore(DataStoreManager.currentSSID, ssid)
-    }
+	}
 
-    override suspend fun getActiveTunnelId(): Int? {
+	override suspend fun isTunnelStatsExpanded(): Boolean {
-        return dataStoreManager.getFromStore(DataStoreManager.ACTIVE_TUNNEL)
+		return dataStoreManager.getFromStore(DataStoreManager.tunnelStatsExpanded)
-    }
+			?: GeneralState.IS_TUNNEL_STATS_EXPANDED
+	}
 
-    private suspend fun setActiveTunnelId(id: Int) {
+	override suspend fun setTunnelStatsExpanded(expanded: Boolean) {
-        dataStoreManager.saveToDataStore(DataStoreManager.ACTIVE_TUNNEL, id)
+		dataStoreManager.saveToDataStore(DataStoreManager.tunnelStatsExpanded, expanded)
-    }
+	}
 
-    override suspend fun getCurrentSsid(): String? {
+	override suspend fun setTheme(theme: Theme) {
-        return dataStoreManager.getFromStore(DataStoreManager.CURRENT_SSID)
+		dataStoreManager.saveToDataStore(DataStoreManager.theme, theme.name)
-    }
+	}
 
-    override suspend fun setCurrentSsid(ssid: String) {
+	override suspend fun getTheme(): Theme {
-        dataStoreManager.saveToDataStore(DataStoreManager.CURRENT_SSID, ssid)
+		return dataStoreManager.getFromStore(DataStoreManager.theme)?.let {
-    }
+			try {
+				Theme.valueOf(it)
+			} catch (_: IllegalArgumentException) {
+				Theme.AUTOMATIC
+			}
+		} ?: Theme.AUTOMATIC
+	}
 
-    override val generalStateFlow: Flow<GeneralState> =
+	override val generalStateFlow: Flow<GeneralState> =
-        dataStoreManager.preferencesFlow.map { prefs ->
+		dataStoreManager.preferencesFlow.map { prefs ->
-            prefs?.let { pref ->
+			prefs?.let { pref ->
-                try {
+				try {
-                    GeneralState(
+					GeneralState(
-                        locationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
+						isLocationDisclosureShown =
-                            ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+						pref[DataStoreManager.locationDisclosureShown]
-                        batteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
+							?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-                            ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+						isBatteryOptimizationDisableShown =
-                        tunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
+						pref[DataStoreManager.batteryDisableShown]
-                            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
+							?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-                    )
+						isPinLockEnabled =
-                } catch (e: IllegalArgumentException) {
+						pref[DataStoreManager.pinLockEnabled]
-                    Timber.e(e)
+							?: GeneralState.PIN_LOCK_ENABLED_DEFAULT,
-                    GeneralState()
+						isTunnelStatsExpanded = pref[DataStoreManager.tunnelStatsExpanded] ?: GeneralState.IS_TUNNEL_STATS_EXPANDED,
-                }
+						theme = getTheme(),
-            } ?: GeneralState()
+					)
-        }
+				} catch (e: IllegalArgumentException) {
+					Timber.e(e)
+					GeneralState()
+				}
+			} ?: GeneralState()
+		}
 }

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

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

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

@@ -2,71 +2,90 @@ package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
 
-class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
+class RoomTunnelConfigRepository(
-    TunnelConfigRepository {
+	private val tunnelConfigDao: TunnelConfigDao,
-    override fun getTunnelConfigsFlow(): Flow<TunnelConfigs> {
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-        return tunnelConfigDao.getAllFlow()
+) :
-    }
+	TunnelConfigRepository {
+	override fun getTunnelConfigsFlow(): Flow<TunnelConfigs> {
+		return tunnelConfigDao.getAllFlow()
+	}
 
-    override suspend fun getAll(): TunnelConfigs {
+	override suspend fun getAll(): TunnelConfigs {
-        return tunnelConfigDao.getAll()
+		return withContext(ioDispatcher) { tunnelConfigDao.getAll() }
-    }
+	}
 
-    override suspend fun save(tunnelConfig: TunnelConfig) {
+	override suspend fun save(tunnelConfig: TunnelConfig) {
-        tunnelConfigDao.save(tunnelConfig)
+		withContext(ioDispatcher) {
-    }
+			tunnelConfigDao.save(tunnelConfig)
+		}
+	}
 
-    override suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?) {
+	override suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?) {
-        tunnelConfigDao.resetPrimaryTunnel()
+		withContext(ioDispatcher) {
-        tunnelConfig?.let {
+			tunnelConfigDao.resetPrimaryTunnel()
-            save(
+			tunnelConfig?.let {
-                it.copy(
+				save(
-                    isPrimaryTunnel = true,
+					it.copy(
-                ),
+						isPrimaryTunnel = true,
-            )
+					),
-        }
+				)
+			}
+		}
+	}
 
-    }
+	override suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?) {
+		withContext(ioDispatcher) {
+			tunnelConfigDao.resetMobileDataTunnel()
+			tunnelConfig?.let {
+				save(
+					it.copy(
+						isMobileDataTunnel = true,
+					),
+				)
+			}
+		}
+	}
 
-    override suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?) {
+	override suspend fun delete(tunnelConfig: TunnelConfig) {
-        tunnelConfigDao.resetMobileDataTunnel()
+		withContext(ioDispatcher) {
-        tunnelConfig?.let {
+			tunnelConfigDao.delete(tunnelConfig)
-            save(
+		}
-                it.copy(
+	}
-                    isMobileDataTunnel = true,
-                ),
-            )
-        }
-    }
 
-    override suspend fun delete(tunnelConfig: TunnelConfig) {
+	override suspend fun getById(id: Int): TunnelConfig? {
-        tunnelConfigDao.delete(tunnelConfig)
+		return withContext(ioDispatcher) { tunnelConfigDao.getById(id.toLong()) }
-    }
+	}
 
-    override suspend fun getById(id: Int): TunnelConfig? {
+	override suspend fun getActive(): TunnelConfigs {
-        return tunnelConfigDao.getById(id.toLong())
+		return withContext(ioDispatcher) {
-    }
+			tunnelConfigDao.getActive()
+		}
+	}
 
-    override suspend fun count(): Int {
+	override suspend fun count(): Int {
-        return tunnelConfigDao.count().toInt()
+		return withContext(ioDispatcher) { tunnelConfigDao.count().toInt() }
-    }
+	}
 
-    override suspend fun findByTunnelName(name: String): TunnelConfig? {
+	override suspend fun findByTunnelName(name: String): TunnelConfig? {
-        return tunnelConfigDao.getByName(name)
+		return withContext(ioDispatcher) { tunnelConfigDao.getByName(name) }
-    }
+	}
 
-    override suspend fun findByTunnelNetworksName(name: String): TunnelConfigs {
+	override suspend fun findByTunnelNetworksName(name: String): TunnelConfigs {
-        return tunnelConfigDao.findByTunnelNetworkName(name)
+		return withContext(ioDispatcher) { tunnelConfigDao.findByTunnelNetworkName(name) }
-    }
+	}
 
-    override suspend fun findByMobileDataTunnel(): TunnelConfigs {
+	override suspend fun findByMobileDataTunnel(): TunnelConfigs {
-        return tunnelConfigDao.findByMobileDataTunnel()
+		return withContext(ioDispatcher) { tunnelConfigDao.findByMobileDataTunnel() }
-    }
+	}
 
-    override suspend fun findPrimary(): TunnelConfigs {
+	override suspend fun findPrimary(): TunnelConfigs {
-        return tunnelConfigDao.findByPrimary()
+		return withContext(ioDispatcher) { tunnelConfigDao.findByPrimary() }
-    }
+	}
 }

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

@@ -4,11 +4,11 @@ import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import kotlinx.coroutines.flow.Flow
 
 interface SettingsRepository {
-    suspend fun save(settings: Settings)
+	suspend fun save(settings: Settings)
 
-    fun getSettingsFlow(): Flow<Settings>
+	fun getSettingsFlow(): Flow<Settings>
 
-    suspend fun getSettings(): Settings
+	suspend fun getSettings(): Settings
 
-    suspend fun getAll(): List<Settings>
+	suspend fun getAll(): List<Settings>
 }

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

@@ -1,32 +1,33 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 interface TunnelConfigRepository {
+	fun getTunnelConfigsFlow(): Flow<TunnelConfigs>
 
-    fun getTunnelConfigsFlow(): Flow<TunnelConfigs>
+	suspend fun getAll(): TunnelConfigs
 
-    suspend fun getAll(): TunnelConfigs
+	suspend fun save(tunnelConfig: TunnelConfig)
 
-    suspend fun save(tunnelConfig: TunnelConfig)
+	suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?)
 
-    suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?)
+	suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?)
 
-    suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?)
+	suspend fun delete(tunnelConfig: TunnelConfig)
 
-    suspend fun delete(tunnelConfig: TunnelConfig)
+	suspend fun getById(id: Int): TunnelConfig?
 
-    suspend fun getById(id: Int): TunnelConfig?
+	suspend fun getActive(): TunnelConfigs
 
-    suspend fun count(): Int
+	suspend fun count(): Int
 
-    suspend fun findByTunnelName(name: String): TunnelConfig?
+	suspend fun findByTunnelName(name: String): TunnelConfig?
 
-    suspend fun findByTunnelNetworksName(name: String): TunnelConfigs
+	suspend fun findByTunnelNetworksName(name: String): TunnelConfigs
 
-    suspend fun findByMobileDataTunnel(): TunnelConfigs
+	suspend fun findByMobileDataTunnel(): TunnelConfigs
 
-    suspend fun findPrimary(): TunnelConfigs
+	suspend fun findPrimary(): TunnelConfigs
 }

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

@@ -1,8 +1,8 @@
 package com.zaneschepke.wireguardautotunnel.module
 
 import android.content.Context
-import com.zaneschepke.logcatter.LocalLogCollector
+import com.zaneschepke.logcatter.LogReader
-import com.zaneschepke.logcatter.LogcatHelper
+import com.zaneschepke.logcatter.LogcatCollector
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -16,15 +16,15 @@ import javax.inject.Singleton
 @Module
 @InstallIn(SingletonComponent::class)
 class AppModule {
-    @Singleton
+	@Singleton
-    @ApplicationScope
+	@ApplicationScope
-    @Provides
+	@Provides
-    fun providesApplicationScope(@DefaultDispatcher defaultDispatcher: CoroutineDispatcher): CoroutineScope =
+	fun providesApplicationScope(@DefaultDispatcher defaultDispatcher: CoroutineDispatcher): CoroutineScope =
-        CoroutineScope(SupervisorJob() + defaultDispatcher)
+		CoroutineScope(SupervisorJob() + defaultDispatcher)
 
-    @Singleton
+	@Singleton
-    @Provides
+	@Provides
-    fun provideLogCollect(@ApplicationContext context: Context): LocalLogCollector {
+	fun provideLogCollect(@ApplicationContext context: Context): LogReader {
-        return LogcatHelper.init(context = context)
+		return LogcatCollector.init(context = context)
-    }
+	}
 }

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

@@ -9,3 +9,11 @@ annotation class Kernel
 @Qualifier
 @Retention(AnnotationRetention.BINARY)
 annotation class Userspace
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class TunnelShell
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class AppShell

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

@@ -10,19 +10,19 @@ import kotlinx.coroutines.Dispatchers
 @Module
 @InstallIn(SingletonComponent::class)
 object CoroutinesDispatchersModule {
-    @DefaultDispatcher
+	@DefaultDispatcher
-    @Provides
+	@Provides
-    fun providesDefaultDispatcher(): CoroutineDispatcher = Dispatchers.Default
+	fun providesDefaultDispatcher(): CoroutineDispatcher = Dispatchers.Default
 
-    @IoDispatcher
+	@IoDispatcher
-    @Provides
+	@Provides
-    fun providesIoDispatcher(): CoroutineDispatcher = Dispatchers.IO
+	fun providesIoDispatcher(): CoroutineDispatcher = Dispatchers.IO
 
-    @MainDispatcher
+	@MainDispatcher
-    @Provides
+	@Provides
-    fun providesMainDispatcher(): CoroutineDispatcher = Dispatchers.Main
+	fun providesMainDispatcher(): CoroutineDispatcher = Dispatchers.Main
 
-    @MainImmediateDispatcher
+	@MainImmediateDispatcher
-    @Provides
+	@Provides
-    fun providesMainImmediateDispatcher(): CoroutineDispatcher = Dispatchers.Main.immediate
+	fun providesMainImmediateDispatcher(): CoroutineDispatcher = Dispatchers.Main.immediate
 }

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

@@ -27,67 +27,62 @@ import javax.inject.Singleton
 @Module
 @InstallIn(SingletonComponent::class)
 class RepositoryModule {
-    @Provides
+	@Provides
-    @Singleton
+	@Singleton
-    fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
+	fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
-        return Room.databaseBuilder(
+		return Room.databaseBuilder(
-            context,
+			context,
-            AppDatabase::class.java,
+			AppDatabase::class.java,
-            context.getString(R.string.db_name),
+			context.getString(R.string.db_name),
-        )
+		)
-            .fallbackToDestructiveMigration()
+			.fallbackToDestructiveMigration()
-            .addCallback(DatabaseCallback())
+			.addCallback(DatabaseCallback())
-            .build()
+			.build()
-    }
+	}
 
-    @Singleton
+	@Singleton
-    @Provides
+	@Provides
-    fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
+	fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
-        return appDatabase.settingDao()
+		return appDatabase.settingDao()
-    }
+	}
 
-    @Singleton
+	@Singleton
-    @Provides
+	@Provides
-    fun provideTunnelConfigDoa(appDatabase: AppDatabase): TunnelConfigDao {
+	fun provideTunnelConfigDoa(appDatabase: AppDatabase): TunnelConfigDao {
-        return appDatabase.tunnelConfigDoa()
+		return appDatabase.tunnelConfigDoa()
-    }
+	}
 
-    @Singleton
+	@Singleton
-    @Provides
+	@Provides
-    fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao): TunnelConfigRepository {
+	fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): TunnelConfigRepository {
-        return RoomTunnelConfigRepository(tunnelConfigDao)
+		return RoomTunnelConfigRepository(tunnelConfigDao, ioDispatcher)
-    }
+	}
 
-    @Singleton
+	@Singleton
-    @Provides
+	@Provides
-    fun provideSettingsRepository(settingsDao: SettingsDao): SettingsRepository {
+	fun provideSettingsRepository(settingsDao: SettingsDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): SettingsRepository {
-        return RoomSettingsRepository(settingsDao)
+		return RoomSettingsRepository(settingsDao, ioDispatcher)
-    }
+	}
 
-    @Singleton
+	@Singleton
-    @Provides
+	@Provides
-    fun providePreferencesDataStore(
+	fun providePreferencesDataStore(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): DataStoreManager {
-        @ApplicationContext context: Context,
+		return DataStoreManager(context, ioDispatcher)
-        @IoDispatcher ioDispatcher: CoroutineDispatcher
+	}
-    ): DataStoreManager {
-        return DataStoreManager(context, ioDispatcher)
-    }
-
-    @Provides
-    @Singleton
-    fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
-        return DataStoreAppStateRepository(dataStoreManager)
-    }
-
-    @Provides
-    @Singleton
-    fun provideAppDataRepository(
-        settingsRepository: SettingsRepository,
-        tunnelConfigRepository: TunnelConfigRepository,
-        appStateRepository: AppStateRepository
-    ): AppDataRepository {
-        return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
-    }
 
+	@Provides
+	@Singleton
+	fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
+		return DataStoreAppStateRepository(dataStoreManager)
+	}
 
+	@Provides
+	@Singleton
+	fun provideAppDataRepository(
+		settingsRepository: SettingsRepository,
+		tunnelConfigRepository: TunnelConfigRepository,
+		appStateRepository: AppStateRepository,
+	): AppDataRepository {
+		return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
+	}
 }

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

@@ -15,25 +15,19 @@ import dagger.hilt.android.scopes.ServiceScoped
 @Module
 @InstallIn(ServiceComponent::class)
 abstract class ServiceModule {
-    @Binds
+	@Binds
-    @ServiceScoped
+	@ServiceScoped
-    abstract fun provideNotificationService(
+	abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification): NotificationService
-        wireGuardNotification: WireGuardNotification
-    ): NotificationService
 
-    @Binds
+	@Binds
-    @ServiceScoped
+	@ServiceScoped
-    abstract fun provideWifiService(wifiService: WifiService): NetworkService<WifiService>
+	abstract fun provideWifiService(wifiService: WifiService): NetworkService<WifiService>
 
-    @Binds
+	@Binds
-    @ServiceScoped
+	@ServiceScoped
-    abstract fun provideMobileDataService(
+	abstract fun provideMobileDataService(mobileDataService: MobileDataService): NetworkService<MobileDataService>
-        mobileDataService: MobileDataService
-    ): NetworkService<MobileDataService>
 
-    @Binds
+	@Binds
-    @ServiceScoped
+	@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

@@ -3,12 +3,14 @@ package com.zaneschepke.wireguardautotunnel.module
 import android.content.Context
 import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.GoBackend
+import com.wireguard.android.backend.RootTunnelActionHandler
 import com.wireguard.android.backend.WgQuickBackend
 import com.wireguard.android.util.RootShell
 import com.wireguard.android.util.ToolsInstaller
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
 import dagger.Provides
@@ -17,63 +19,78 @@ 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
 @InstallIn(SingletonComponent::class)
 class TunnelModule {
-    @Provides
-    @Singleton
-    fun provideRootShell(@ApplicationContext context: Context): RootShell {
-        return RootShell(context)
-    }
 
-    @Provides
+	@Provides
-    @Singleton
+	@Singleton
-    @Userspace
+	@TunnelShell
-    fun provideUserspaceBackend(@ApplicationContext context: Context): Backend {
+	fun provideTunnelRootShell(@ApplicationContext context: Context): RootShell {
-        return GoBackend(context)
+		return RootShell(context)
-    }
+	}
 
-    @Provides
+	@Provides
-    @Singleton
+	@Singleton
-    @Kernel
+	@AppShell
-    fun provideKernelBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
+	fun provideAppRootShell(@ApplicationContext context: Context): RootShell {
-        return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
+		return RootShell(context)
-    }
+	}
 
-    @Provides
+	@Provides
-    @Singleton
+	@Singleton
-    fun provideAmneziaBackend(@ApplicationContext context: Context): org.amnezia.awg.backend.Backend {
+	fun provideRootShellAm(@ApplicationContext context: Context): org.amnezia.awg.util.RootShell {
-        return org.amnezia.awg.backend.GoBackend(context)
+		return org.amnezia.awg.util.RootShell(context)
-    }
+	}
 
-    @Provides
+	@Provides
-    @Singleton
+	@Singleton
-    fun provideVpnService(
+	@Userspace
-        amneziaBackend: org.amnezia.awg.backend.Backend,
+	fun provideUserspaceBackend(@ApplicationContext context: Context, @TunnelShell rootShell: RootShell): Backend {
-        @Userspace userspaceBackend: Backend,
+		return GoBackend(context, RootTunnelActionHandler(rootShell))
-        @Kernel kernelBackend: Backend,
+	}
-        appDataRepository: AppDataRepository,
-        @ApplicationScope applicationScope: CoroutineScope,
-        @IoDispatcher ioDispatcher: CoroutineDispatcher
-    ): VpnService {
-        return WireGuardTunnel(
-            amneziaBackend,
-            userspaceBackend,
-            kernelBackend,
-            appDataRepository,
-            applicationScope,
-            ioDispatcher,
-        )
-    }
 
-    @Provides
+	@Provides
-    @Singleton
+	@Singleton
-    fun provideServiceManager(
+	@Kernel
-        appDataRepository: AppDataRepository,
+	fun provideKernelBackend(@ApplicationContext context: Context, @TunnelShell rootShell: RootShell): Backend {
-        @IoDispatcher ioDispatcher: CoroutineDispatcher
+		return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell), RootTunnelActionHandler(rootShell))
-    ): ServiceManager {
+	}
-        return ServiceManager(appDataRepository, ioDispatcher)
+
-    }
+	@Provides
+	@Singleton
+	fun provideAmneziaBackend(@ApplicationContext context: Context, rootShell: org.amnezia.awg.util.RootShell): org.amnezia.awg.backend.Backend {
+		return org.amnezia.awg.backend.GoBackend(context, org.amnezia.awg.backend.RootTunnelActionHandler(rootShell))
+	}
+
+	@Provides
+	@Singleton
+	fun provideVpnService(
+		amneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
+		@Kernel kernelBackend: Provider<Backend>,
+		appDataRepository: AppDataRepository,
+		tunnelConfigRepository: TunnelConfigRepository,
+		@ApplicationScope applicationScope: CoroutineScope,
+		@IoDispatcher ioDispatcher: CoroutineDispatcher,
+		serviceManager: ServiceManager,
+	): TunnelService {
+		return WireGuardTunnel(
+			amneziaBackend,
+			tunnelConfigRepository,
+			kernelBackend,
+			appDataRepository,
+			applicationScope,
+			ioDispatcher,
+			serviceManager,
+		)
+	}
+
+	@Singleton
+	@Provides
+	fun provideServiceManager(@ApplicationContext context: Context): ServiceManager {
+		return ServiceManager.getInstance(context)
+	}
 }

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

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

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

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

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

@@ -4,42 +4,49 @@ 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 com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 @AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
 
-    @Inject
+	@Inject
-    lateinit var appDataRepository: AppDataRepository
+	lateinit var tunnelService: Provider<TunnelService>
 
-    @Inject
+	@Inject
-    lateinit var serviceManager: ServiceManager
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
 
-    override fun onReceive(context: Context?, intent: Intent?) = goAsync {
+	@Inject
-        if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return@goAsync
+	lateinit var serviceManager: ServiceManager
-        context?.run {
+
-            val settings = appDataRepository.settings.getSettings()
+	override fun onReceive(context: Context, intent: Intent) {
-            if (settings.isAutoTunnelEnabled) {
+		if (Intent.ACTION_BOOT_COMPLETED != intent.action) return
-                Timber.i("Starting watcher service from boot")
+		applicationScope.launch {
-                serviceManager.startWatcherServiceForeground(context)
+			with(appDataRepository.settings.getSettings()) {
-            }
+				if (isRestoreOnBootEnabled) {
-            if (appDataRepository.appState.isTunnelRunningFromManualStart()) {
+					val activeTunnels = appDataRepository.tunnels.getActive()
-                appDataRepository.appState.getActiveTunnelId()?.let {
+					val tunState = tunnelService.get().vpnState.value.status
-                    Timber.i("Starting tunnel that was active before reboot")
+					if (activeTunnels.isNotEmpty() && tunState != TunnelState.UP) {
-                    serviceManager.startVpnServiceForeground(
+						Timber.i("Starting previously active tunnel")
-                        context,
+						tunnelService.get().startTunnel(activeTunnels.first(), true)
-                        appDataRepository.tunnels.getById(it)?.id,
+					}
-                    )
+					if (isAutoTunnelEnabled) {
-                }
+						Timber.i("Starting watcher service from boot")
-            }
+						serviceManager.startAutoTunnel(true)
-            if (settings.isAlwaysOnVpnEnabled) {
+					}
-                Timber.i("Starting vpn service from boot AOVPN")
+				}
-                serviceManager.startVpnServiceForeground(context)
+			}
-            }
+		}
-        }
+	}
-    }
 }

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

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

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

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

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

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

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

@@ -0,0 +1,556 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import android.content.Intent
+import android.net.NetworkCapabilities
+import android.os.IBinder
+import android.os.PowerManager
+import androidx.core.app.ServiceCompat
+import androidx.lifecycle.LifecycleService
+import androidx.lifecycle.lifecycleScope
+import com.wireguard.android.util.RootShell
+import com.zaneschepke.wireguardautotunnel.R
+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.AppShell
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
+import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
+import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
+import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
+import com.zaneschepke.wireguardautotunnel.service.network.NetworkStatus
+import com.zaneschepke.wireguardautotunnel.service.network.WifiService
+import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.extensions.cancelWithMessage
+import com.zaneschepke.wireguardautotunnel.util.extensions.getCurrentWifiName
+import com.zaneschepke.wireguardautotunnel.util.extensions.isReachable
+import com.zaneschepke.wireguardautotunnel.util.extensions.onNotRunning
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+import java.net.InetAddress
+import javax.inject.Inject
+import javax.inject.Provider
+
+@AndroidEntryPoint
+class AutoTunnelService : LifecycleService() {
+	private val foregroundId = 122
+
+	@Inject
+	@AppShell
+	lateinit var rootShell: Provider<RootShell>
+
+	@Inject
+	lateinit var wifiService: NetworkService<WifiService>
+
+	@Inject
+	lateinit var mobileDataService: NetworkService<MobileDataService>
+
+	@Inject
+	lateinit var ethernetService: NetworkService<EthernetService>
+
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
+
+	@Inject
+	lateinit var notificationService: NotificationService
+
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
+
+	@Inject
+	@IoDispatcher
+	lateinit var ioDispatcher: CoroutineDispatcher
+
+	@Inject
+	lateinit var serviceManager: ServiceManager
+
+	@Inject
+	@MainImmediateDispatcher
+	lateinit var mainImmediateDispatcher: CoroutineDispatcher
+
+	private val autoTunnelStateFlow = MutableStateFlow(AutoTunnelState())
+
+	private var wakeLock: PowerManager.WakeLock? = null
+
+	private var wifiJob: Job? = null
+	private var mobileDataJob: Job? = null
+	private var ethernetJob: Job? = null
+	private var pingJob: Job? = null
+	private var networkEventJob: Job? = null
+
+	override fun onCreate() {
+		super.onCreate()
+		lifecycleScope.launch(mainImmediateDispatcher) {
+			kotlin.runCatching {
+				launchWatcherNotification()
+			}.onFailure {
+				Timber.e(it)
+			}
+		}
+	}
+
+	override fun onBind(intent: Intent): IBinder? {
+		super.onBind(intent)
+		// We don't provide binding, so return null
+		return null
+	}
+
+	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+		Timber.d("onStartCommand executed with startId: $startId")
+		serviceManager.autoTunnelService.complete(this)
+		return super.onStartCommand(intent, flags, startId)
+	}
+
+	fun start() {
+		kotlin.runCatching {
+			lifecycleScope.launch(mainImmediateDispatcher) {
+				launchWatcherNotification()
+				initWakeLock()
+			}
+			startSettingsJob()
+			startVpnStateJob()
+		}.onFailure {
+			Timber.e(it)
+		}
+	}
+
+	fun stop() {
+		wakeLock?.let {
+			if (it.isHeld) {
+				it.release()
+			}
+		}
+		stopSelf()
+	}
+
+	override fun onDestroy() {
+		cancelAndResetNetworkJobs()
+		cancelAndResetPingJob()
+		serviceManager.autoTunnelService = CompletableDeferred()
+		super.onDestroy()
+	}
+
+	private fun launchWatcherNotification(description: String = getString(R.string.monitoring_state_changes)) {
+		val notification =
+			notificationService.createNotification(
+				channelId = getString(R.string.watcher_channel_id),
+				channelName = getString(R.string.watcher_channel_name),
+				title = getString(R.string.auto_tunnel_title),
+				description = description,
+			)
+		ServiceCompat.startForeground(
+			this,
+			foregroundId,
+			notification,
+			Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
+		)
+	}
+
+	private fun initWakeLock() {
+		wakeLock =
+			(getSystemService(POWER_SERVICE) as PowerManager).run {
+				val tag = this.javaClass.name
+				newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
+					try {
+						Timber.i("Initiating wakelock with 10 min timeout")
+						acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
+					} finally {
+						release()
+					}
+				}
+			}
+	}
+
+	private fun startSettingsJob() = lifecycleScope.launch {
+		watchForSettingsChanges()
+	}
+
+	private fun startVpnStateJob() = lifecycleScope.launch {
+		watchForVpnStateChanges()
+	}
+
+	private fun startWifiJob() = lifecycleScope.launch {
+		watchForWifiConnectivityChanges()
+	}
+
+	private fun startMobileDataJob() = lifecycleScope.launch {
+		watchForMobileDataConnectivityChanges()
+	}
+
+	private fun startEthernetJob() = lifecycleScope.launch {
+		watchForEthernetConnectivityChanges()
+	}
+
+	private fun startPingJob() = lifecycleScope.launch {
+		watchForPingFailure()
+	}
+
+	private fun startNetworkEventJob() = lifecycleScope.launch {
+		handleNetworkEventChanges()
+	}
+
+	private suspend fun watchForMobileDataConnectivityChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting mobile data watcher")
+			mobileDataService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Mobile data connection")
+						emitMobileDataConnected(true)
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						emitMobileDataConnected(true)
+						Timber.i("Mobile data capabilities changed")
+					}
+
+					is NetworkStatus.Unavailable -> {
+						emitMobileDataConnected(false)
+						Timber.i("Lost mobile data connection")
+					}
+				}
+			}
+		}
+	}
+
+	private suspend fun watchForPingFailure() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting ping watcher")
+			runCatching {
+				do {
+					val vpnState = tunnelService.get().vpnState.value
+					if (vpnState.status == TunnelState.UP) {
+						if (vpnState.tunnelConfig != null) {
+							val config = TunnelConfig.configFromWgQuick(vpnState.tunnelConfig.wgQuick)
+							val results = if (vpnState.tunnelConfig.pingIp != null) {
+								Timber.d("Pinging custom ip : ${vpnState.tunnelConfig.pingIp}")
+								listOf(InetAddress.getByName(vpnState.tunnelConfig.pingIp).isReachable(Constants.PING_TIMEOUT.toInt()))
+							} else {
+								Timber.d("Pinging all peers")
+								config.peers.map { peer ->
+									peer.isReachable()
+								}
+							}
+							Timber.i("Ping results reachable: $results")
+							if (results.contains(false)) {
+								Timber.i("Restarting VPN for ping failure")
+								val cooldown = vpnState.tunnelConfig.pingCooldown
+								tunnelService.get().bounceTunnel(vpnState.tunnelConfig)
+								delay(cooldown ?: Constants.PING_COOLDOWN)
+								continue
+							}
+						}
+					}
+					delay(vpnState.tunnelConfig?.pingInterval ?: Constants.PING_INTERVAL)
+				} while (true)
+			}.onFailure {
+				Timber.e(it)
+			}
+		}
+	}
+
+	private suspend fun watchForSettingsChanges() {
+		Timber.i("Starting settings watcher")
+		withContext(ioDispatcher) {
+			appDataRepository.settings.getSettingsFlow().combine(
+				// ignore isActive changes to allow manual tunnel overrides
+				appDataRepository.tunnels.getTunnelConfigsFlow().distinctUntilChanged { old, new ->
+					old.map { it.isActive } != new.map { it.isActive }
+				},
+			) { settings, tunnels ->
+				Timber.d("Tunnels or settings changed!")
+				autoTunnelStateFlow.value.copy(
+					settings = settings,
+					tunnels = tunnels,
+				)
+			}.collect {
+				Timber.d("got new settings: ${it.settings}")
+				manageJobsBySettings(it.settings)
+				autoTunnelStateFlow.emit(it)
+			}
+		}
+	}
+
+	private suspend fun watchForVpnStateChanges() {
+		Timber.i("Starting vpn state watcher")
+		withContext(ioDispatcher) {
+			tunnelService.get().vpnState.distinctUntilChanged { old, new ->
+				old.tunnelConfig?.id == new.tunnelConfig?.id
+			}.collect { state ->
+				autoTunnelStateFlow.update {
+					it.copy(vpnState = state)
+				}
+				state.tunnelConfig?.let {
+					val settings = appDataRepository.settings.getSettings()
+					if (it.isPingEnabled && !settings.isPingEnabled) {
+						pingJob.onNotRunning { pingJob = startPingJob() }
+					}
+					if (!it.isPingEnabled && !settings.isPingEnabled) {
+						cancelAndResetPingJob()
+					}
+				}
+			}
+		}
+	}
+
+	private fun manageJobsBySettings(settings: Settings) {
+		with(settings) {
+			if (isPingEnabled) {
+				pingJob.onNotRunning { pingJob = startPingJob() }
+			} else {
+				cancelAndResetPingJob()
+			}
+			if (isTunnelOnWifiEnabled || isTunnelOnEthernetEnabled || isTunnelOnMobileDataEnabled) {
+				startNetworkJobs()
+			} else {
+				cancelAndResetNetworkJobs()
+			}
+		}
+	}
+
+	private fun startNetworkJobs() {
+		wifiJob.onNotRunning {
+			Timber.i("Wifi job starting")
+			wifiJob = startWifiJob()
+		}
+		ethernetJob.onNotRunning {
+			ethernetJob = startEthernetJob()
+			Timber.i("Ethernet job starting")
+		}
+		mobileDataJob.onNotRunning {
+			mobileDataJob = startMobileDataJob()
+			Timber.i("Mobile data job starting")
+		}
+		networkEventJob.onNotRunning {
+			Timber.i("Network event job starting")
+			networkEventJob = startNetworkEventJob()
+		}
+	}
+
+	private fun cancelAndResetPingJob() {
+		pingJob?.cancelWithMessage("Ping job canceled")
+		pingJob = null
+	}
+
+	private fun cancelAndResetNetworkJobs() {
+		networkEventJob?.cancelWithMessage("Network event job canceled")
+		wifiJob?.cancelWithMessage("Wifi job canceled")
+		ethernetJob?.cancelWithMessage("Ethernet job canceled")
+		mobileDataJob?.cancelWithMessage("Mobile data job canceled")
+		networkEventJob = null
+		wifiJob = null
+		ethernetJob = null
+		mobileDataJob = null
+	}
+
+	private fun emitEthernetConnected(connected: Boolean) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				isEthernetConnected = connected,
+			)
+		}
+	}
+
+	private fun emitWifiConnected(connected: Boolean) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				isWifiConnected = connected,
+			)
+		}
+	}
+
+	private fun emitWifiSSID(ssid: String) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				currentNetworkSSID = ssid,
+			)
+		}
+	}
+
+	private fun emitMobileDataConnected(connected: Boolean) {
+		autoTunnelStateFlow.update {
+			it.copy(
+				isMobileDataConnected = connected,
+			)
+		}
+	}
+
+	private suspend fun watchForEthernetConnectivityChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting ethernet data watcher")
+			ethernetService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Ethernet connection")
+						emitEthernetConnected(true)
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						Timber.i("Ethernet capabilities changed")
+						emitEthernetConnected(true)
+					}
+
+					is NetworkStatus.Unavailable -> {
+						emitEthernetConnected(false)
+						Timber.i("Lost Ethernet connection")
+					}
+				}
+			}
+		}
+	}
+
+	private suspend fun watchForWifiConnectivityChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting wifi watcher")
+			wifiService.networkStatus.collect { status ->
+				when (status) {
+					is NetworkStatus.Available -> {
+						Timber.i("Gained Wi-Fi connection")
+						emitWifiConnected(true)
+					}
+
+					is NetworkStatus.CapabilitiesChanged -> {
+						Timber.i("Wifi capabilities changed")
+						emitWifiConnected(true)
+						val ssid = getWifiSSID(status.networkCapabilities)
+						ssid?.let { name ->
+							if (name.contains(Constants.UNREADABLE_SSID)) {
+								Timber.w("SSID unreadable: missing permissions")
+							} else {
+								Timber.i("Detected valid SSID")
+							}
+							appDataRepository.appState.setCurrentSsid(name)
+							emitWifiSSID(name)
+						} ?: Timber.w("Failed to read ssid")
+					}
+
+					is NetworkStatus.Unavailable -> {
+						emitWifiConnected(false)
+						Timber.i("Lost Wi-Fi connection")
+					}
+				}
+			}
+		}
+	}
+
+	private suspend fun getWifiSSID(networkCapabilities: NetworkCapabilities): String? {
+		return withContext(ioDispatcher) {
+			with(autoTunnelStateFlow.value.settings) {
+				if (isWifiNameByShellEnabled) return@withContext rootShell.get().getCurrentWifiName()
+				wifiService.getNetworkName(networkCapabilities)
+			}
+		}
+	}
+
+	private suspend fun getMobileDataTunnel(): TunnelConfig? {
+		return appDataRepository.tunnels.findByMobileDataTunnel().firstOrNull()
+	}
+
+	private suspend fun handleNetworkEventChanges() {
+		withContext(ioDispatcher) {
+			Timber.i("Starting network event watcher")
+			autoTunnelStateFlow.collect { watcherState ->
+				val autoTunnel = "Auto-tunnel watcher"
+				// delay for rapid network state changes and then collect latest
+				delay(Constants.WATCHER_COLLECTION_DELAY)
+				val activeTunnel = watcherState.vpnState.tunnelConfig
+				val defaultTunnel = appDataRepository.getPrimaryOrFirstTunnel()
+				val isTunnelDown = tunnelService.get().getState() == TunnelState.DOWN
+				when {
+					watcherState.isEthernetConditionMet() -> {
+						Timber.i("$autoTunnel - tunnel on on ethernet condition met")
+						if (isTunnelDown) {
+							defaultTunnel?.let {
+								tunnelService.get().startTunnel(it)
+							}
+						}
+					}
+
+					watcherState.isMobileDataConditionMet() -> {
+						Timber.i("$autoTunnel - tunnel on mobile data condition met")
+						val mobileDataTunnel = getMobileDataTunnel()
+						val tunnel =
+							mobileDataTunnel ?: defaultTunnel
+						if (isTunnelDown || activeTunnel?.isMobileDataTunnel == false) {
+							tunnel?.let {
+								tunnelService.get().startTunnel(it)
+							}
+						}
+					}
+
+					watcherState.isTunnelOffOnMobileDataConditionMet() -> {
+						Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
+						if (!isTunnelDown) {
+							activeTunnel?.let {
+								tunnelService.get().stopTunnel(it)
+							}
+						}
+					}
+
+					watcherState.isUntrustedWifiConditionMet() -> {
+						Timber.i("Untrusted wifi condition met")
+						if (activeTunnel == null || watcherState.isCurrentSSIDActiveTunnelNetwork() == false ||
+							isTunnelDown
+						) {
+							Timber.i(
+								"$autoTunnel - tunnel on ssid not associated with current tunnel condition met",
+							)
+							watcherState.getTunnelWithMatchingTunnelNetwork()?.let {
+								Timber.i("Found tunnel associated with this SSID, bringing tunnel up: ${it.name}")
+								if (isTunnelDown || activeTunnel?.id != it.id) {
+									tunnelService.get().startTunnel(it)
+								}
+							} ?: suspend {
+								Timber.i("No tunnel associated with this SSID, using defaults")
+								val default = appDataRepository.getPrimaryOrFirstTunnel()
+								if (default?.name != tunnelService.get().name || isTunnelDown) {
+									default?.let {
+										tunnelService.get().startTunnel(it)
+									}
+								}
+							}.invoke()
+						}
+					}
+
+					watcherState.isTrustedWifiConditionMet() -> {
+						Timber.i(
+							"$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off",
+						)
+						if (!isTunnelDown) activeTunnel?.let { tunnelService.get().stopTunnel(it) }
+					}
+
+					watcherState.isTunnelOffOnWifiConditionMet() -> {
+						Timber.i(
+							"$autoTunnel - tunnel off on wifi condition met, turning vpn off",
+						)
+						if (!isTunnelDown) activeTunnel?.let { tunnelService.get().stopTunnel(it) }
+					}
+// TODO disable for this now
+// 					watcherState.isTunnelOffOnNoConnectivityMet() -> {
+// 						Timber.i(
+// 							"$autoTunnel - tunnel off on no connectivity met, turning vpn off",
+// 						)
+// 						if (!isTunnelDown) activeTunnel?.let { tunnelService.get().stopTunnel(it) }
+// 					}
+
+					else -> {
+						Timber.i("$autoTunnel - no condition met")
+					}
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,107 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnState
+import com.zaneschepke.wireguardautotunnel.util.extensions.TunnelConfigs
+import com.zaneschepke.wireguardautotunnel.util.extensions.isMatchingToWildcardList
+
+data class AutoTunnelState(
+	val vpnState: VpnState = VpnState(),
+	val isWifiConnected: Boolean = false,
+	val isEthernetConnected: Boolean = false,
+	val isMobileDataConnected: Boolean = false,
+	val currentNetworkSSID: String = "",
+	val settings: Settings = Settings(),
+	val tunnels: TunnelConfigs = emptyList(),
+) {
+	fun isEthernetConditionMet(): Boolean {
+		return (
+			isEthernetConnected &&
+				settings.isTunnelOnEthernetEnabled
+			)
+	}
+
+	fun isMobileDataConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				settings.isTunnelOnMobileDataEnabled &&
+				!isWifiConnected &&
+				isMobileDataConnected
+			)
+	}
+
+	fun isTunnelOffOnMobileDataConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				!settings.isTunnelOnMobileDataEnabled &&
+				isMobileDataConnected &&
+				!isWifiConnected
+			)
+	}
+
+	fun isUntrustedWifiConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				isWifiConnected &&
+				!isCurrentSSIDTrusted() &&
+				settings.isTunnelOnWifiEnabled
+			)
+	}
+
+	fun isTrustedWifiConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				(
+					isWifiConnected &&
+						isCurrentSSIDTrusted()
+					)
+			)
+	}
+
+	fun isTunnelOffOnWifiConditionMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				(
+					isWifiConnected &&
+						!settings.isTunnelOnWifiEnabled
+					)
+			)
+	}
+
+	fun isTunnelOffOnNoConnectivityMet(): Boolean {
+		return (
+			!isEthernetConnected &&
+				!isWifiConnected &&
+				!isMobileDataConnected
+			)
+	}
+
+	fun isCurrentSSIDTrusted(): Boolean {
+		return if (settings.isWildcardsEnabled) {
+			settings.trustedNetworkSSIDs.isMatchingToWildcardList(currentNetworkSSID)
+		} else {
+			settings.trustedNetworkSSIDs.contains(currentNetworkSSID)
+		}
+	}
+	fun isCurrentSSIDActiveTunnelNetwork(): Boolean {
+		val currentTunnelNetworks = vpnState.tunnelConfig?.tunnelNetworks
+		return (
+			if (settings.isWildcardsEnabled) {
+				currentTunnelNetworks?.isMatchingToWildcardList(currentNetworkSSID)
+			} else {
+				currentTunnelNetworks?.contains(currentNetworkSSID)
+			}
+			) == true
+	}
+
+	fun getTunnelWithMatchingTunnelNetwork(): TunnelConfig? {
+		return tunnels.firstOrNull {
+			if (settings.isWildcardsEnabled) {
+				it.tunnelNetworks.isMatchingToWildcardList(currentNetworkSSID)
+			} else {
+				it.tunnelNetworks.contains(currentNetworkSSID)
+			}
+		}
+	}
+}

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

@@ -1,56 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import android.content.Intent
-import android.os.Bundle
-import android.os.IBinder
-import androidx.lifecycle.LifecycleService
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import timber.log.Timber
-
-open class ForegroundService : LifecycleService() {
-    private var isServiceStarted = false
-
-    override fun onBind(intent: Intent): IBinder? {
-        super.onBind(intent)
-        // We don't provide binding, so return null
-        return null
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        super.onStartCommand(intent, flags, startId)
-        Timber.d("onStartCommand executed with startId: $startId")
-        if (intent != null) {
-            val action = intent.action
-            when (action) {
-                Action.START.name,
-                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")
-                    startService(intent.extras)
-                }
-
-                else -> Timber.d("This should never happen. No action in the received intent")
-            }
-        } else {
-            Timber.d(
-                "with a null intent. It has been probably restarted by the system.",
-            )
-        }
-        return START_STICKY
-    }
-
-    protected open fun startService(extras: Bundle?) {
-        if (isServiceStarted) return
-        Timber.d("Starting ${this.javaClass.simpleName}")
-        isServiceStarted = true
-    }
-
-    protected open fun stopService() {
-        Timber.d("Stopping ${this.javaClass.simpleName}")
-        stopForeground(STOP_FOREGROUND_REMOVE)
-        stopSelf()
-        isServiceStarted = false
-    }
-}

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

@@ -3,130 +3,83 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 import android.app.Service
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.util.SingletonHolder
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
-import com.zaneschepke.wireguardautotunnel.util.Constants
+import jakarta.inject.Inject
-import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.withContext
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import timber.log.Timber
 
-class ServiceManager(
+@OptIn(ExperimentalCoroutinesApi::class)
-    private val appDataRepository: AppDataRepository,
+class ServiceManager
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+@Inject constructor(private val context: Context) {
-) {
 
-    private fun <T : Service> actionOnService(
+	private val _autoTunnelActive = MutableStateFlow(false)
-        action: Action,
-        context: Context,
-        cls: Class<T>,
-        extras: Map<String, Int>? = null
-    ) {
-        val intent =
-            Intent(context, cls).also {
-                it.action = action.name
-                extras?.forEach { (k, v) -> it.putExtra(k, v) }
-            }
-        intent.component?.javaClass
-        try {
-            when (action) {
-                Action.START_FOREGROUND, Action.STOP_FOREGROUND -> context.startForegroundService(
-                    intent,
-                )
 
-                Action.START, Action.STOP -> context.startService(intent)
+	val autoTunnelActive = _autoTunnelActive.asStateFlow()
-            }
-        } catch (e: Exception) {
-            Timber.e(e.message)
-        }
-    }
 
-    suspend fun startVpnService(
+	var autoTunnelService = CompletableDeferred<AutoTunnelService>()
-        context: Context,
+	var backgroundService = CompletableDeferred<TunnelBackgroundService>()
-        tunnelId: Int? = null,
-        isManualStart: Boolean = false
-    ) {
-        if (isManualStart) onManualStart(tunnelId)
-        actionOnService(
-            Action.START,
-            context,
-            WireGuardTunnelService::class.java,
-            tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
-        )
-    }
 
-    suspend fun stopVpnServiceForeground(context: Context, isManualStop: Boolean = false) {
+	companion object : SingletonHolder<ServiceManager, Context>(::ServiceManager)
-        withContext(ioDispatcher) {
-            if (isManualStop) onManualStop()
-            Timber.i("Stopping vpn service")
-            actionOnService(
-                Action.STOP_FOREGROUND,
-                context,
-                WireGuardTunnelService::class.java,
-            )
-        }
-    }
 
-    suspend fun stopVpnService(context: Context, isManualStop: Boolean = false) {
+	private fun <T : Service> startService(cls: Class<T>, background: Boolean) {
-        withContext(ioDispatcher) {
+		runCatching {
-            if (isManualStop) onManualStop()
+			val intent = Intent(context, cls)
-            Timber.i("Stopping vpn service")
+			if (background) {
-            actionOnService(
+				context.startForegroundService(intent)
-                Action.STOP,
+			} else {
-                context,
+				context.startService(intent)
-                WireGuardTunnelService::class.java,
+			}
-            )
+		}.onFailure { Timber.e(it) }
-        }
+	}
-    }
 
-    private suspend fun onManualStop() {
+	suspend fun startAutoTunnel(background: Boolean) {
-        appDataRepository.appState.setManualStop()
+		if (autoTunnelService.isCompleted) return _autoTunnelActive.update { true }
-    }
+		kotlin.runCatching {
+			startService(AutoTunnelService::class.java, background)
+			autoTunnelService.await()
+			autoTunnelService.getCompleted().start()
+			_autoTunnelActive.update { true }
+		}.onFailure {
+			Timber.e(it)
+		}
+	}
 
-    private suspend fun onManualStart(tunnelId: Int?) {
+	suspend fun startBackgroundService() {
-        tunnelId?.let {
+		if (backgroundService.isCompleted) return
-            appDataRepository.appState.setTunnelRunningFromManualStart(it)
+		kotlin.runCatching {
-        }
+			startService(TunnelBackgroundService::class.java, true)
-    }
+			backgroundService.await()
+			backgroundService.getCompleted().start()
+		}.onFailure {
+			Timber.e(it)
+		}
+	}
 
-    suspend fun startVpnServiceForeground(
+	fun stopBackgroundService() {
-        context: Context,
+		if (!backgroundService.isCompleted) return
-        tunnelId: Int? = null,
+		runCatching {
-        isManualStart: Boolean = false
+			backgroundService.getCompleted().stop()
-    ) {
+		}.onFailure {
-        withContext(ioDispatcher) {
+			Timber.e(it)
-            if (isManualStart) onManualStart(tunnelId)
+		}
-            actionOnService(
+	}
-                Action.START_FOREGROUND,
-                context,
-                WireGuardTunnelService::class.java,
-                tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
-            )
-        }
-    }
 
-    fun startWatcherServiceForeground(
+	fun stopAutoTunnel() {
-        context: Context,
+		if (!autoTunnelService.isCompleted) return
-    ) {
+		runCatching {
-        actionOnService(
+			autoTunnelService.getCompleted().stop()
-            Action.START_FOREGROUND,
+			_autoTunnelActive.update { false }
-            context,
+		}.onFailure {
-            WireGuardConnectivityWatcherService::class.java,
+			Timber.e(it)
-        )
+		}
-    }
+	}
 
-    fun startWatcherService(context: Context) {
+	fun requestTunnelTileUpdate() {
-        actionOnService(
+		context.requestTunnelTileServiceStateUpdate()
-            Action.START,
+	}
-            context,
-            WireGuardConnectivityWatcherService::class.java,
-        )
-    }
-
-    fun stopWatcherService(context: Context) {
-        actionOnService(
-            Action.STOP,
-            context,
-            WireGuardConnectivityWatcherService::class.java,
-        )
-    }
 }

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

@@ -0,0 +1,69 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import android.app.Notification
+import android.content.Intent
+import android.os.IBinder
+import androidx.core.app.ServiceCompat
+import androidx.lifecycle.LifecycleService
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CompletableDeferred
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class TunnelBackgroundService : LifecycleService() {
+
+	@Inject
+	lateinit var notificationService: NotificationService
+
+	@Inject
+	lateinit var serviceManager: ServiceManager
+
+	private val foregroundId = 123
+
+	override fun onCreate() {
+		super.onCreate()
+		start()
+	}
+
+	override fun onBind(intent: Intent): IBinder? {
+		super.onBind(intent)
+		// We don't provide binding, so return null
+		return null
+	}
+
+	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+		serviceManager.backgroundService.complete(this)
+		return super.onStartCommand(intent, flags, startId)
+	}
+
+	fun start() {
+		ServiceCompat.startForeground(
+			this,
+			foregroundId,
+			createNotification(),
+			Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
+		)
+	}
+
+	fun stop() {
+		stopForeground(STOP_FOREGROUND_REMOVE)
+		stopSelf()
+	}
+
+	override fun onDestroy() {
+		serviceManager.backgroundService = CompletableDeferred()
+		super.onDestroy()
+	}
+
+	private fun createNotification(): Notification {
+		return notificationService.createNotification(
+			getString(R.string.vpn_channel_id),
+			getString(R.string.vpn_channel_name),
+			getString(R.string.tunnel_running),
+			description = "",
+		)
+	}
+}

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

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

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

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

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

@@ -1,201 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import android.app.PendingIntent
-import android.content.Intent
-import android.os.Bundle
-import androidx.core.app.ServiceCompat
-import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
-import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
-import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class WireGuardTunnelService : ForegroundService() {
-    private val foregroundId = 123
-
-    @Inject
-    lateinit var vpnService: VpnService
-
-    @Inject
-    lateinit var appDataRepository: AppDataRepository
-
-    @Inject
-    lateinit var notificationService: NotificationService
-
-    @Inject
-    @MainImmediateDispatcher
-    lateinit var mainImmediateDispatcher: CoroutineDispatcher
-
-    @Inject
-    @IoDispatcher
-    lateinit var ioDispatcher: CoroutineDispatcher
-
-    private var job: Job? = null
-
-    private var didShowConnected = false
-
-    override fun onCreate() {
-        super.onCreate()
-        lifecycleScope.launch(mainImmediateDispatcher) {
-            //TODO fix this to not launch if AOVPN
-            if (appDataRepository.tunnels.count() != 0) {
-                launchVpnNotification()
-            }
-        }
-    }
-
-    override fun startService(extras: Bundle?) {
-        super.startService(extras)
-        cancelJob()
-        job =
-            lifecycleScope.launch {
-                launch {
-                    val tunnelId = extras?.getInt(Constants.TUNNEL_EXTRA_KEY)
-                    if (vpnService.getState() == TunnelState.UP) {
-                        vpnService.stopTunnel()
-                    }
-                    vpnService.startTunnel(
-                        tunnelId?.let {
-                            appDataRepository.tunnels.getById(it)
-                        },
-                    )
-                }
-                launch {
-                    handshakeNotifications()
-                }
-            }
-    }
-
-    //TODO improve tunnel notifications
-    private suspend fun handshakeNotifications() {
-        withContext(ioDispatcher) {
-            var tunnelName: String? = null
-            vpnService.vpnState.collect { state ->
-                state.statistics
-                    ?.mapPeerStats()
-                    ?.map { it.value?.handshakeStatus() }
-                    .let { statuses ->
-                        when {
-                            statuses?.all { it == HandshakeStatus.HEALTHY } == true -> {
-                                if (!didShowConnected) {
-                                    delay(Constants.VPN_CONNECTED_NOTIFICATION_DELAY)
-                                    tunnelName = state.tunnelConfig?.name
-                                    launchVpnNotification(
-                                        getString(R.string.tunnel_start_title),
-                                        "${getString(R.string.tunnel_start_text)} - $tunnelName",
-                                    )
-                                    didShowConnected = true
-                                }
-                            }
-
-                            statuses?.any { it == HandshakeStatus.STALE } == true -> {}
-                            statuses?.all { it == HandshakeStatus.NOT_STARTED } ==
-                                true -> {
-                            }
-
-                            else -> {}
-                        }
-                    }
-                if (state.status == TunnelState.UP && state.tunnelConfig?.name != tunnelName) {
-                    tunnelName = state.tunnelConfig?.name
-                    launchVpnNotification(
-                        getString(R.string.tunnel_start_title),
-                        "${getString(R.string.tunnel_start_text)} - $tunnelName",
-                    )
-                }
-            }
-        }
-    }
-
-    private fun launchAlwaysOnDisabledNotification() {
-        launchVpnNotification(
-            title = this.getString(R.string.vpn_connection_failed),
-            description = this.getString(R.string.always_on_disabled),
-        )
-    }
-
-    override fun stopService() {
-        super.stopService()
-        lifecycleScope.launch {
-            vpnService.stopTunnel()
-            didShowConnected = false
-        }
-        cancelJob()
-        stopSelf()
-    }
-
-    private fun launchVpnNotification(
-        title: String = getString(R.string.vpn_starting),
-        description: String = getString(R.string.attempt_connection)
-    ) {
-        val notification =
-            notificationService.createNotification(
-                channelId = getString(R.string.vpn_channel_id),
-                channelName = getString(R.string.vpn_channel_name),
-                title = title,
-                onGoing = false,
-                vibration = false,
-                showTimestamp = true,
-                description = description,
-            )
-        ServiceCompat.startForeground(
-            this,
-            foregroundId,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
-        )
-    }
-
-    private fun launchVpnConnectionFailedNotification(message: String) {
-        val notification =
-            notificationService.createNotification(
-                channelId = getString(R.string.vpn_channel_id),
-                channelName = getString(R.string.vpn_channel_name),
-                action =
-                PendingIntent.getBroadcast(
-                    this,
-                    0,
-                    Intent(this, NotificationActionReceiver::class.java),
-                    PendingIntent.FLAG_IMMUTABLE,
-                ),
-                actionText = getString(R.string.restart),
-                title = getString(R.string.vpn_connection_failed),
-                onGoing = false,
-                vibration = true,
-                showTimestamp = true,
-                description = message,
-            )
-        ServiceCompat.startForeground(
-            this,
-            foregroundId,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
-        )
-    }
-
-    private fun cancelJob() {
-        try {
-            job?.cancel()
-        } catch (e: CancellationException) {
-            Timber.i("Tunnel job cancelled")
-        }
-    }
-}

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

@@ -5,8 +5,6 @@ import android.net.ConnectivityManager
 import android.net.Network
 import android.net.NetworkCapabilities
 import android.net.NetworkRequest
-import android.net.wifi.SupplicantState
-import android.net.wifi.WifiInfo
 import android.net.wifi.WifiManager
 import android.os.Build
 import kotlinx.coroutines.channels.awaitClose
@@ -15,118 +13,89 @@ import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.map
 
 abstract class BaseNetworkService<T : BaseNetworkService<T>>(
-    val context: Context,
+	val context: Context,
-    networkCapability: Int
+	networkCapability: Int,
 ) : NetworkService<T> {
-    private val connectivityManager =
+	private val connectivityManager =
-        context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+		context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
 
-    private val wifiManager =
+	val wifiManager =
-        context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
+		context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
 
-    override val networkStatus = callbackFlow {
+	override val networkStatus =
-        val networkStatusCallback =
+		callbackFlow {
-            when (Build.VERSION.SDK_INT) {
+			val networkStatusCallback =
-                in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
+				when (Build.VERSION.SDK_INT) {
-                    object :
+					in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
-                        ConnectivityManager.NetworkCallback(
+						object :
-                            FLAG_INCLUDE_LOCATION_INFO,
+							ConnectivityManager.NetworkCallback(
-                        ) {
+								FLAG_INCLUDE_LOCATION_INFO,
-                        override fun onAvailable(network: Network) {
+							) {
-                            trySend(NetworkStatus.Available(network))
+							override fun onAvailable(network: Network) {
-                        }
+								trySend(NetworkStatus.Available(network))
+							}
 
-                        override fun onLost(network: Network) {
+							override fun onLost(network: Network) {
-                            trySend(NetworkStatus.Unavailable(network))
+								trySend(NetworkStatus.Unavailable(network))
-                        }
+							}
 
-                        override fun onCapabilitiesChanged(
+							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
-                            network: Network,
+								trySend(
-                            networkCapabilities: NetworkCapabilities
+									NetworkStatus.CapabilitiesChanged(
-                        ) {
+										network,
-                            trySend(
+										networkCapabilities,
-                                NetworkStatus.CapabilitiesChanged(
+									),
-                                    network,
+								)
-                                    networkCapabilities,
+							}
-                                ),
+						}
-                            )
+					}
-                        }
-                    }
-                }
 
-                else -> {
+					else -> {
-                    object : ConnectivityManager.NetworkCallback() {
+						object : ConnectivityManager.NetworkCallback() {
-                        override fun onAvailable(network: Network) {
+							override fun onAvailable(network: Network) {
-                            trySend(NetworkStatus.Available(network))
+								trySend(NetworkStatus.Available(network))
-                        }
+							}
 
-                        override fun onLost(network: Network) {
+							override fun onLost(network: Network) {
-                            trySend(NetworkStatus.Unavailable(network))
+								trySend(NetworkStatus.Unavailable(network))
-                        }
+							}
 
-                        override fun onCapabilitiesChanged(
+							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
-                            network: Network,
+								trySend(
-                            networkCapabilities: NetworkCapabilities
+									NetworkStatus.CapabilitiesChanged(
-                        ) {
+										network,
-                            trySend(
+										networkCapabilities,
-                                NetworkStatus.CapabilitiesChanged(
+									),
-                                    network,
+								)
-                                    networkCapabilities,
+							}
-                                ),
+						}
-                            )
+					}
-                        }
+				}
-                    }
+			val request =
-                }
+				NetworkRequest.Builder()
-            }
+					.addTransportType(networkCapability)
-        val request =
+					.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-            NetworkRequest.Builder()
+					.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-                .addTransportType(networkCapability)
+					.build()
-                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+			connectivityManager.registerNetworkCallback(request, networkStatusCallback)
-                .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-                .build()
-        connectivityManager.registerNetworkCallback(request, networkStatusCallback)
 
-        awaitClose { connectivityManager.unregisterNetworkCallback(networkStatusCallback) }
+			awaitClose { connectivityManager.unregisterNetworkCallback(networkStatusCallback) }
-    }
+		}
-
-    override fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
-        var ssid: String? = getWifiNameFromCapabilities(networkCapabilities)
-        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
-            val info = wifiManager.connectionInfo
-            if (info.supplicantState === SupplicantState.COMPLETED) {
-                ssid = info.ssid
-            }
-        }
-        return ssid?.trim('"')
-    }
-
-    companion object {
-        private fun getWifiNameFromCapabilities(networkCapabilities: NetworkCapabilities): String? {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                val info: WifiInfo
-                if (networkCapabilities.transportInfo is WifiInfo) {
-                    info = networkCapabilities.transportInfo as WifiInfo
-                    return info.ssid
-                }
-            }
-            return null
-        }
-    }
 }
 
 inline fun <Result> Flow<NetworkStatus>.map(
-    crossinline onUnavailable: suspend (network: Network) -> Result,
+	crossinline onUnavailable: suspend (network: Network) -> Result,
-    crossinline onAvailable: suspend (network: Network) -> Result,
+	crossinline onAvailable: suspend (network: Network) -> Result,
-    crossinline onCapabilitiesChanged:
+	crossinline onCapabilitiesChanged:
-    suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result
+	suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result,
 ): Flow<Result> = map { status ->
-    when (status) {
+	when (status) {
-        is NetworkStatus.Unavailable -> onUnavailable(status.network)
+		is NetworkStatus.Unavailable -> onUnavailable(status.network)
-        is NetworkStatus.Available -> onAvailable(status.network)
+		is NetworkStatus.Available -> onAvailable(status.network)
-        is NetworkStatus.CapabilitiesChanged ->
+		is NetworkStatus.CapabilitiesChanged ->
-            onCapabilitiesChanged(
+			onCapabilitiesChanged(
-                status.network,
+				status.network,
-                status.networkCapabilities,
+				status.networkCapabilities,
-            )
+			)
-    }
+	}
 }

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

@@ -5,5 +5,14 @@ import android.net.NetworkCapabilities
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class EthernetService @Inject constructor(@ApplicationContext context: Context) :
+class EthernetService
-    BaseNetworkService<EthernetService>(context, NetworkCapabilities.TRANSPORT_ETHERNET)
+@Inject
+constructor(
+	@ApplicationContext context: Context,
+) :
+	BaseNetworkService<EthernetService>(context, NetworkCapabilities.TRANSPORT_ETHERNET) {
+
+	override fun isNetworkSecure(): Boolean {
+		return true
+	}
+}

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

@@ -5,5 +5,13 @@ import android.net.NetworkCapabilities
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class MobileDataService @Inject constructor(@ApplicationContext context: Context) :
+class MobileDataService
-    BaseNetworkService<MobileDataService>(context, NetworkCapabilities.TRANSPORT_CELLULAR)
+@Inject
+constructor(
+	@ApplicationContext context: Context,
+) :
+	BaseNetworkService<MobileDataService>(context, NetworkCapabilities.TRANSPORT_CELLULAR) {
+	override fun isNetworkSecure(): Boolean {
+		return false
+	}
+}

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

@@ -0,0 +1,16 @@
+package com.zaneschepke.wireguardautotunnel.service.network
+
+import android.net.NetworkCapabilities
+import android.net.wifi.WifiInfo
+import android.os.Build
+
+fun NetworkCapabilities.getWifiName(): String? {
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+		val info: WifiInfo
+		if (transportInfo is WifiInfo) {
+			info = transportInfo as WifiInfo
+			return info.ssid
+		}
+	}
+	return null
+}

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

@@ -4,7 +4,11 @@ import android.net.NetworkCapabilities
 import kotlinx.coroutines.flow.Flow
 
 interface NetworkService<T> {
-    fun getNetworkName(networkCapabilities: NetworkCapabilities): String?
+	fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
+		return null
+	}
 
-    val networkStatus: Flow<NetworkStatus>
+	fun isNetworkSecure(): Boolean
+
+	val networkStatus: Flow<NetworkStatus>
 }

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

@@ -4,10 +4,10 @@ import android.net.Network
 import android.net.NetworkCapabilities
 
 sealed class NetworkStatus {
-    class Available(val network: Network) : NetworkStatus()
+	class Available(val network: Network) : NetworkStatus()
 
-    class Unavailable(val network: Network) : NetworkStatus()
+	class Unavailable(val network: Network) : NetworkStatus()
 
-    class CapabilitiesChanged(val network: Network, val networkCapabilities: NetworkCapabilities) :
+	class CapabilitiesChanged(val network: Network, val networkCapabilities: NetworkCapabilities) :
-        NetworkStatus()
+		NetworkStatus()
 }

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

@@ -2,8 +2,31 @@ package com.zaneschepke.wireguardautotunnel.service.network
 
 import android.content.Context
 import android.net.NetworkCapabilities
+import android.net.wifi.SupplicantState
+import android.os.Build
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WifiService @Inject constructor(@ApplicationContext context: Context) :
+class WifiService
-    BaseNetworkService<WifiService>(context, NetworkCapabilities.TRANSPORT_WIFI)
+@Inject
+constructor(
+	@ApplicationContext context: Context,
+) :
+	BaseNetworkService<WifiService>(context, NetworkCapabilities.TRANSPORT_WIFI) {
+
+	override fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
+		var ssid = networkCapabilities.getWifiName()
+		if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.S) {
+			val info = wifiManager.connectionInfo
+			if (info.supplicantState === SupplicantState.COMPLETED) {
+				ssid = info.ssid
+			}
+		}
+		return ssid?.trim('"')
+	}
+
+	override fun isNetworkSecure(): Boolean {
+		// TODO
+		return false
+	}
+}

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

@@ -5,18 +5,18 @@ import android.app.NotificationManager
 import android.app.PendingIntent
 
 interface NotificationService {
-    fun createNotification(
+	fun createNotification(
-        channelId: String,
+		channelId: String,
-        channelName: String,
+		channelName: String,
-        title: String = "",
+		title: String = "",
-        action: PendingIntent? = null,
+		action: PendingIntent? = null,
-        actionText: String? = null,
+		actionText: String? = null,
-        description: String,
+		description: String,
-        showTimestamp: Boolean = false,
+		showTimestamp: Boolean = false,
-        importance: Int = NotificationManager.IMPORTANCE_HIGH,
+		importance: Int = NotificationManager.IMPORTANCE_HIGH,
-        vibration: Boolean = false,
+		vibration: Boolean = false,
-        onGoing: Boolean = true,
+		onGoing: Boolean = true,
-        lights: Boolean = true,
+		lights: Boolean = true,
-        onlyAlertOnce: Boolean = true,
+		onlyAlertOnce: Boolean = true,
-    ): Notification
+	): Notification
 }

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

@@ -13,89 +13,93 @@ import com.zaneschepke.wireguardautotunnel.ui.MainActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WireGuardNotification @Inject constructor(@ApplicationContext private val context: Context) :
+class WireGuardNotification
-    NotificationService {
+@Inject
-    private val notificationManager =
+constructor(
-        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+	@ApplicationContext private val context: Context,
+) :
+	NotificationService {
+	private val notificationManager =
+		context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-    private val watcherBuilder: NotificationCompat.Builder =
+	private val watcherBuilder: NotificationCompat.Builder =
-        NotificationCompat.Builder(
+		NotificationCompat.Builder(
-            context,
+			context,
-            context.getString(R.string.watcher_channel_id),
+			context.getString(R.string.watcher_channel_id),
-        )
+		)
-    private val tunnelBuilder: NotificationCompat.Builder =
+	private val tunnelBuilder: NotificationCompat.Builder =
-        NotificationCompat.Builder(
+		NotificationCompat.Builder(
-            context,
+			context,
-            context.getString(R.string.vpn_channel_id),
+			context.getString(R.string.vpn_channel_id),
-        )
+		)
 
-    override fun createNotification(
+	override fun createNotification(
-        channelId: String,
+		channelId: String,
-        channelName: String,
+		channelName: String,
-        title: String,
+		title: String,
-        action: PendingIntent?,
+		action: PendingIntent?,
-        actionText: String?,
+		actionText: String?,
-        description: String,
+		description: String,
-        showTimestamp: Boolean,
+		showTimestamp: Boolean,
-        importance: Int,
+		importance: Int,
-        vibration: Boolean,
+		vibration: Boolean,
-        onGoing: Boolean,
+		onGoing: Boolean,
-        lights: Boolean,
+		lights: Boolean,
-        onlyAlertOnce: Boolean,
+		onlyAlertOnce: Boolean,
-    ): Notification {
+	): Notification {
-        val channel =
+		val channel =
-            NotificationChannel(
+			NotificationChannel(
-                channelId,
+				channelId,
-                channelName,
+				channelName,
-                importance,
+				importance,
-            )
+			)
-                .let {
+				.let {
-                    it.description = title
+					it.description = title
-                    it.enableLights(lights)
+					it.enableLights(lights)
-                    it.lightColor = Color.RED
+					it.lightColor = Color.RED
-                    it.enableVibration(vibration)
+					it.enableVibration(vibration)
-                    it.vibrationPattern = longArrayOf(100, 200, 300)
+					it.vibrationPattern = longArrayOf(100, 200, 300)
-                    it
+					it
-                }
+				}
-        notificationManager.createNotificationChannel(channel)
+		notificationManager.createNotificationChannel(channel)
-        val pendingIntent: PendingIntent =
+		val pendingIntent: PendingIntent =
-            Intent(context, MainActivity::class.java).let { notificationIntent ->
+			Intent(context, MainActivity::class.java).let { notificationIntent ->
-                PendingIntent.getActivity(
+				PendingIntent.getActivity(
-                    context,
+					context,
-                    0,
+					0,
-                    notificationIntent,
+					notificationIntent,
-                    PendingIntent.FLAG_IMMUTABLE,
+					PendingIntent.FLAG_IMMUTABLE,
-                )
+				)
-            }
+			}
 
-        val builder =
+		val builder =
-            when (channelId) {
+			when (channelId) {
-                context.getString(R.string.watcher_channel_id) -> watcherBuilder
+				context.getString(R.string.watcher_channel_id) -> watcherBuilder
-                context.getString(R.string.vpn_channel_id) -> tunnelBuilder
+				context.getString(R.string.vpn_channel_id) -> tunnelBuilder
-                else -> {
+				else -> {
-                    NotificationCompat.Builder(
+					NotificationCompat.Builder(
-                        context,
+						context,
-                        channelId,
+						channelId,
-                    )
+					)
-                }
+				}
-            }
+			}
 
-        return builder.let {
+		return builder.let {
-            if (action != null && actionText != null) {
+			if (action != null && actionText != null) {
-                it.addAction(
+				it.addAction(
-                    NotificationCompat.Action.Builder(0, actionText, action).build(),
+					NotificationCompat.Action.Builder(0, actionText, action).build(),
-                )
+				)
-                it.setAutoCancel(true)
+				it.setAutoCancel(true)
-            }
+			}
-            it.setContentTitle(title)
+			it.setContentTitle(title)
-                .setContentText(description)
+				.setContentText(description)
-                .setOnlyAlertOnce(onlyAlertOnce)
+				.setOnlyAlertOnce(onlyAlertOnce)
-                .setContentIntent(pendingIntent)
+				.setContentIntent(pendingIntent)
-                .setOngoing(onGoing)
+				.setOngoing(onGoing)
-                .setPriority(NotificationCompat.PRIORITY_HIGH)
+				.setPriority(NotificationCompat.PRIORITY_HIGH)
-                .setShowWhen(showTimestamp)
+				.setShowWhen(showTimestamp)
-                .setSmallIcon(R.drawable.ic_launcher)
+				.setSmallIcon(R.drawable.ic_launcher)
-                .build()
+				.build()
-        }
+		}
-    }
+	}
 }

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

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

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

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

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

@@ -1,122 +1,142 @@
 package com.zaneschepke.wireguardautotunnel.service.tile
 
+import android.content.Intent
 import android.os.Build
+import android.os.IBinder
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
-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.Job
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 @AndroidEntryPoint
-class TunnelControlTile : TileService() {
+class TunnelControlTile : TileService(), LifecycleOwner {
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
 
-    @Inject
+	@Inject
-    lateinit var appDataRepository: AppDataRepository
+	lateinit var tunnelService: Provider<TunnelService>
 
-    @Inject
+	@Inject
-    lateinit var vpnService: VpnService
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
 
-    @Inject
+	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
-    lateinit var serviceManager: ServiceManager
 
-    @Inject
+	override fun onCreate() {
-    @ApplicationScope
+		super.onCreate()
-    lateinit var applicationScope: CoroutineScope
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+	}
 
-    private var manualStartConfig: TunnelConfig? = null
+	override fun onStopListening() {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
+	}
 
-    private var job: Job? = null;
+	override fun onDestroy() {
+		super.onDestroy()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+	}
 
-    override fun onStartListening() {
+	override fun onStartListening() {
-        super.onStartListening()
+		super.onStartListening()
-        Timber.d("On start listening called")
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
-        //TODO Fix this
+		Timber.d("Updating tile!")
-        if (job == null || job?.isCancelled == true) job = applicationScope.launch {
+		lifecycleScope.launch {
-            vpnService.vpnState.collect { it ->
+			if (appDataRepository.tunnels.getAll().isEmpty()) return@launch setUnavailable()
-                when (it.status) {
+			updateTileState()
-                    TunnelState.UP -> {
+		}
-                        setActive()
+	}
-                        it.tunnelConfig?.name?.let { name -> setTileDescription(name) }
-                    }
 
-                    TunnelState.DOWN -> {
+	private suspend fun updateTileState() {
-                        setInactive()
+		val lastActive = appDataRepository.getStartTunnelConfig()
-                        val config = appDataRepository.getStartTunnelConfig()?.also { config ->
+		lastActive?.let {
-                            manualStartConfig = config
+			updateTile(it)
-                        } ?: appDataRepository.getPrimaryOrFirstTunnel()
+		}
-                        config?.let {
+	}
-                            setTileDescription(it.name)
-                        } ?: setUnavailable()
-                    }
 
-                    else -> setInactive()
+	override fun onClick() {
-                }
+		super.onClick()
-            }
+		unlockAndRun {
-        }
+			lifecycleScope.launch {
-    }
+				val lastActive = appDataRepository.getStartTunnelConfig()
+				lastActive?.let { tunnel ->
+					if (tunnel.isActive) {
+						tunnelService.get().stopTunnel(tunnel)
+					} else {
+						tunnelService.get().startTunnel(tunnel, true)
+					}
+					updateTileState()
+				}
+			}
+		}
+	}
 
-    override fun onTileAdded() {
+	private fun setActive() {
-        super.onTileAdded()
+		kotlin.runCatching {
-        onStartListening()
+			qsTile.state = Tile.STATE_ACTIVE
-    }
+			qsTile.updateTile()
+		}
+	}
 
-    override fun onClick() {
+	private fun setInactive() {
-        super.onClick()
+		kotlin.runCatching {
-        unlockAndRun {
+			qsTile.state = Tile.STATE_INACTIVE
-            applicationScope.launch {
+			qsTile.updateTile()
-                try {
+		}
-                    if (vpnService.getState() == TunnelState.UP) {
+	}
-                        serviceManager.stopVpnServiceForeground(
-                            this@TunnelControlTile,
-                            isManualStop = true,
-                        )
-                    } else {
-                        serviceManager.startVpnServiceForeground(
-                            this@TunnelControlTile, manualStartConfig?.id, isManualStart = true,
-                        )
-                    }
-                } catch (e: Exception) {
-                    Timber.e(e.message)
-                } finally {
-                    cancel()
-                }
-            }
-        }
-    }
 
-    private fun setActive() {
+	private fun setUnavailable() {
-        qsTile.state = Tile.STATE_ACTIVE
+		kotlin.runCatching {
-        qsTile.updateTile()
+			qsTile.state = Tile.STATE_UNAVAILABLE
-    }
+			setTileDescription("")
+			qsTile.updateTile()
+		}
+	}
 
-    private fun setInactive() {
+	private fun setTileDescription(description: String) {
-        qsTile.state = Tile.STATE_INACTIVE
+		kotlin.runCatching {
-        qsTile.updateTile()
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-    }
+				qsTile.subtitle = description
+			}
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+				qsTile.stateDescription = description
+			}
+			qsTile.updateTile()
+		}
+	}
 
-    private fun setUnavailable() {
+	private fun updateTile(tunnelConfig: TunnelConfig?) {
-        manualStartConfig = null
+		kotlin.runCatching {
-        qsTile.state = Tile.STATE_UNAVAILABLE
+			tunnelConfig?.let {
-        qsTile.updateTile()
+				setTileDescription(it.name)
-    }
+				if (it.isActive) return setActive()
+				setInactive()
+			}
+		}
+	}
 
-    private fun setTileDescription(description: String) {
+	/* This works around an annoying unsolved frameworks bug some people are hitting. */
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+	override fun onBind(intent: Intent): IBinder? {
-            qsTile.subtitle = description
+		var ret: IBinder? = null
-        }
+		try {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+			ret = super.onBind(intent)
-            qsTile.stateDescription = description
+		} catch (_: Throwable) {
-        }
+			Timber.e("Failed to bind to TunnelControlTile")
-        qsTile.updateTile()
+		}
-    }
+		return ret
+	}
+
+	override val lifecycle: Lifecycle
+		get() = lifecycleRegistry
 }

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

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

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

@@ -1,16 +1,17 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel
 
 enum class HandshakeStatus {
-    HEALTHY,
+	HEALTHY,
-    STALE,
+	STALE,
-    UNKNOWN,
+	UNKNOWN,
-    NOT_STARTED;
+	NOT_STARTED,
+	;
 
-    companion object {
+	companion object {
-        private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 180
+		private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 180
-        const val STATUS_CHANGE_TIME_BUFFER = 30
+		const val STATUS_CHANGE_TIME_BUFFER = 30
-        const val STALE_TIME_LIMIT_SEC =
+		const val STALE_TIME_LIMIT_SEC =
-            WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + STATUS_CHANGE_TIME_BUFFER
+			WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + STATUS_CHANGE_TIME_BUFFER
-        const val NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC = 30
+		const val NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC = 30
-    }
+	}
 }

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

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

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

@@ -3,41 +3,42 @@ package com.zaneschepke.wireguardautotunnel.service.tunnel
 import com.wireguard.android.backend.Tunnel
 
 enum class TunnelState {
-    UP,
+	UP,
-    DOWN,
+	DOWN,
-    TOGGLE;
+	TOGGLE,
+	;
 
-    fun toWgState(): Tunnel.State {
+	fun toWgState(): Tunnel.State {
-        return when (this) {
+		return when (this) {
-            UP -> Tunnel.State.UP
+			UP -> Tunnel.State.UP
-            DOWN -> Tunnel.State.DOWN
+			DOWN -> Tunnel.State.DOWN
-            TOGGLE -> Tunnel.State.TOGGLE
+			TOGGLE -> Tunnel.State.TOGGLE
-        }
+		}
-    }
+	}
 
-    fun toAmState(): org.amnezia.awg.backend.Tunnel.State {
+	fun toAmState(): org.amnezia.awg.backend.Tunnel.State {
-        return when (this) {
+		return when (this) {
-            UP -> org.amnezia.awg.backend.Tunnel.State.UP
+			UP -> org.amnezia.awg.backend.Tunnel.State.UP
-            DOWN -> org.amnezia.awg.backend.Tunnel.State.DOWN
+			DOWN -> org.amnezia.awg.backend.Tunnel.State.DOWN
-            TOGGLE -> org.amnezia.awg.backend.Tunnel.State.TOGGLE
+			TOGGLE -> org.amnezia.awg.backend.Tunnel.State.TOGGLE
-        }
+		}
-    }
+	}
 
-    companion object {
+	companion object {
-        fun from(state: Tunnel.State): TunnelState {
+		fun from(state: Tunnel.State): TunnelState {
-            return when (state) {
+			return when (state) {
-                Tunnel.State.DOWN -> DOWN
+				Tunnel.State.DOWN -> DOWN
-                Tunnel.State.TOGGLE -> TOGGLE
+				Tunnel.State.TOGGLE -> TOGGLE
-                Tunnel.State.UP -> UP
+				Tunnel.State.UP -> UP
-            }
+			}
-        }
+		}
 
-        fun from(state: org.amnezia.awg.backend.Tunnel.State): TunnelState {
+		fun from(state: org.amnezia.awg.backend.Tunnel.State): TunnelState {
-            return when (state) {
+			return when (state) {
-                org.amnezia.awg.backend.Tunnel.State.DOWN -> DOWN
+				org.amnezia.awg.backend.Tunnel.State.DOWN -> DOWN
-                org.amnezia.awg.backend.Tunnel.State.TOGGLE -> TOGGLE
+				org.amnezia.awg.backend.Tunnel.State.TOGGLE -> TOGGLE
-                org.amnezia.awg.backend.Tunnel.State.UP -> UP
+				org.amnezia.awg.backend.Tunnel.State.UP -> UP
-            }
+			}
-        }
+		}
-    }
+	}
 }

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

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

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

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

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

@@ -1,201 +1,279 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel
 
 import com.wireguard.android.backend.Backend
-import com.wireguard.android.backend.BackendException
 import com.wireguard.android.backend.Tunnel.State
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
 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.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.AmneziaStatistics
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.WireGuardStatistics
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
+import java.util.concurrent.atomic.AtomicBoolean
 import javax.inject.Inject
+import javax.inject.Provider
 
 class WireGuardTunnel
 @Inject
 constructor(
-    private val userspaceAmneziaBackend: org.amnezia.awg.backend.Backend,
+	private val amneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
-    @Userspace private val userspaceBackend: Backend,
+	tunnelConfigRepository: TunnelConfigRepository,
-    @Kernel private val kernelBackend: Backend,
+	@Kernel private val kernelBackend: Provider<Backend>,
-    private val appDataRepository: AppDataRepository,
+	private val appDataRepository: AppDataRepository,
-    @ApplicationScope private val applicationScope: CoroutineScope,
+	@ApplicationScope private val applicationScope: CoroutineScope,
-    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-) : VpnService {
+	private val serviceManager: ServiceManager,
-    private val _vpnState = MutableStateFlow(VpnState())
+) : TunnelService {
-    override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()
 
+	private val _vpnState = MutableStateFlow(VpnState())
+	override val vpnState: StateFlow<VpnState> = _vpnState.combine(
+		tunnelConfigRepository.getTunnelConfigsFlow(),
+	) {
+			vpnState, tunnels ->
+		vpnState.copy(
+			tunnelConfig = tunnels.firstOrNull { it.id == vpnState.tunnelConfig?.id },
+		)
+	}.stateIn(applicationScope, SharingStarted.Lazily, VpnState())
 
-    private var statsJob: Job? = null
+	private var statsJob: Job? = null
 
-    private var backend: Backend = userspaceBackend
+	private val runningHandle = AtomicBoolean(false)
 
-    private var backendIsWgUserspace = true
+	private suspend fun backend(): Any {
+		val settings = appDataRepository.settings.getSettings()
+		if (settings.isKernelEnabled) return kernelBackend.get()
+		return amneziaBackend.get()
+	}
 
-    private var backendIsAmneziaUserspace = false
+	override suspend fun runningTunnelNames(): Set<String> {
+		return when (val backend = backend()) {
+			is Backend -> backend.runningTunnelNames
+			is org.amnezia.awg.backend.Backend -> backend.runningTunnelNames
+			else -> emptySet()
+		}
+	}
 
-    init {
+	private suspend fun setState(tunnelConfig: TunnelConfig, tunnelState: TunnelState): Result<TunnelState> {
-        applicationScope.launch(ioDispatcher) {
+		return runCatching {
-            appDataRepository.settings.getSettingsFlow().collect {
+			when (val backend = backend()) {
-                if (it.isKernelEnabled && (backendIsWgUserspace || backendIsAmneziaUserspace)) {
+				is Backend -> backend.setState(this, tunnelState.toWgState(), TunnelConfig.configFromWgQuick(tunnelConfig.wgQuick)).let { TunnelState.from(it) }
-                    Timber.i("Setting kernel backend")
+				is org.amnezia.awg.backend.Backend -> {
-                    backend = kernelBackend
+					val config = if (tunnelConfig.amQuick.isBlank()) {
-                    backendIsWgUserspace = false
+						TunnelConfig.configFromAmQuick(
-                    backendIsAmneziaUserspace = false
+							tunnelConfig.wgQuick,
-                } else if (!it.isKernelEnabled && !it.isAmneziaEnabled && !backendIsWgUserspace) {
+						)
-                    Timber.i("Setting WireGuard userspace backend")
+					} else {
-                    backend = userspaceBackend
+						TunnelConfig.configFromAmQuick(tunnelConfig.amQuick)
-                    backendIsWgUserspace = true
+					}
-                    backendIsAmneziaUserspace = false
+					backend.setState(this, tunnelState.toAmState(), config).let {
-                } else if (it.isAmneziaEnabled && !backendIsAmneziaUserspace) {
+						TunnelState.from(it)
-                    Timber.i("Setting Amnezia userspace backend")
+					}
-                    backendIsAmneziaUserspace = true
+				}
-                    backendIsWgUserspace = false
+				else -> throw NotImplementedError()
-                }
+			}
-            }
+		}.onFailure {
-        }
+			Timber.e(it)
-    }
+		}
+	}
 
-    private fun setState(tunnelConfig: TunnelConfig?, tunnelState: TunnelState): TunnelState {
+	override suspend fun startTunnel(tunnelConfig: TunnelConfig, background: Boolean): Result<TunnelState> {
-        return if (backendIsAmneziaUserspace) {
+		return withContext(ioDispatcher) {
-            Timber.i("Using Amnezia backend")
+			if (runningHandle.get() == true && tunnelConfig == vpnState.value.tunnelConfig) {
-            val config = tunnelConfig?.let {
+				Timber.w("Tunnel already running")
-                if (it.amQuick != "") TunnelConfig.configFromAmQuick(it.amQuick) else {
+				return@withContext Result.success(vpnState.value.status)
-                    Timber.w("Using backwards compatible wg config, amnezia specific config not found.")
+			}
-                    TunnelConfig.configFromAmQuick(it.wgQuick)
+			runningHandle.set(true)
-                }
+			onBeforeStart(tunnelConfig)
-            }
+			val settings = appDataRepository.settings.getSettings()
-            val state = userspaceAmneziaBackend.setState(this, tunnelState.toAmState(), config)
+			if (background || settings.isKernelEnabled) startBackgroundService()
-            TunnelState.from(state)
+			setState(tunnelConfig, TunnelState.UP).onSuccess {
-        } else {
+				emitTunnelState(it)
-            Timber.i("Using Wg backend")
+			}.onFailure {
-            val wgConfig = tunnelConfig?.let { TunnelConfig.configFromWgQuick(it.wgQuick) }
+				Timber.e(it)
-            val state = backend.setState(
+				onStartFailed()
-                this,
+			}
-                tunnelState.toWgState(),
+		}
-                wgConfig,
+	}
-            )
-            TunnelState.from(state)
-        }
-    }
 
-    override suspend fun startTunnel(tunnelConfig: TunnelConfig?): TunnelState {
+	override suspend fun stopTunnel(tunnelConfig: TunnelConfig): Result<TunnelState> {
-        return withContext(ioDispatcher) {
+		return withContext(ioDispatcher) {
-            try {
+			onBeforeStop(tunnelConfig)
-                //TODO we need better error handling here
+			setState(tunnelConfig, TunnelState.DOWN).onSuccess {
-                val config = tunnelConfig ?: appDataRepository.getPrimaryOrFirstTunnel()
+				emitTunnelState(it)
-                if (config != null) {
+			}.onFailure {
-                    emitTunnelConfig(config)
+				Timber.e(it)
-                    setState(config, TunnelState.UP)
+				onStopFailed()
-                } else throw Exception("No tunnels")
+			}.also {
-            } catch (e: BackendException) {
+				stopBackgroundService()
-                Timber.e("Failed to start tunnel with error: ${e.message}")
+				runningHandle.set(false)
-                TunnelState.from(State.DOWN)
+			}
-            }
+		}
-        }
+	}
-    }
 
-    private fun emitTunnelState(state: TunnelState) {
+	// use this when we just want to bounce tunnel and not change tunnelConfig active state
-        _vpnState.tryEmit(
+	override suspend fun bounceTunnel(tunnelConfig: TunnelConfig): Result<TunnelState> {
-            _vpnState.value.copy(
+		toggleTunnel(tunnelConfig)
-                status = state,
+		delay(VPN_RESTART_DELAY)
-            ),
+		return toggleTunnel(tunnelConfig)
-        )
+	}
-    }
 
-    private fun emitBackendStatistics(statistics: TunnelStatistics) {
+	private suspend fun toggleTunnel(tunnelConfig: TunnelConfig): Result<TunnelState> {
-        _vpnState.tryEmit(
+		return withContext(ioDispatcher) {
-            _vpnState.value.copy(
+			setState(tunnelConfig, TunnelState.TOGGLE).onSuccess {
-                statistics = statistics,
+				emitTunnelState(it)
-            ),
+				resetBackendStatistics()
-        )
+			}.onFailure {
-    }
+				Timber.e(it)
+			}
+		}
+	}
 
-    private suspend fun emitTunnelConfig(tunnelConfig: TunnelConfig?) {
+	private suspend fun onStopFailed() {
-        _vpnState.emit(
+		_vpnState.value.tunnelConfig?.let {
-            _vpnState.value.copy(
+			appDataRepository.tunnels.save(it.copy(isActive = true))
-                tunnelConfig = tunnelConfig,
+		}
-            ),
+	}
-        )
-    }
 
-    private fun resetVpnState() {
+	private suspend fun onStartFailed() {
-        _vpnState.tryEmit(VpnState())
+		_vpnState.value.tunnelConfig?.let {
-    }
+			appDataRepository.tunnels.save(it.copy(isActive = false))
+		}
+		cancelStatsJob()
+		resetBackendStatistics()
+		runningHandle.set(false)
+	}
 
-    override suspend fun stopTunnel() {
+	private suspend fun shutDownActiveTunnel(config: TunnelConfig) {
-        withContext(ioDispatcher) {
+		with(_vpnState.value) {
-            try {
+			if (status == TunnelState.UP && tunnelConfig != config) {
-                if (getState() == TunnelState.UP) {
+				tunnelConfig?.let { stopTunnel(it) }
-                    val state = setState(null, TunnelState.DOWN)
+			}
-                    resetVpnState()
+		}
-                    emitTunnelState(state)
+	}
-                }
-            } catch (e: BackendException) {
-                Timber.e("Failed to stop wireguard tunnel with error: ${e.message}")
-            } catch (e: org.amnezia.awg.backend.BackendException) {
-                Timber.e("Failed to stop amnezia tunnel with error: ${e.message}")
-            }
-        }
-    }
 
-    override fun getState(): TunnelState {
+	private suspend fun startBackgroundService() {
-        return if (backendIsAmneziaUserspace) TunnelState.from(userspaceAmneziaBackend.getState(this))
+		serviceManager.startBackgroundService()
-        else TunnelState.from(backend.getState(this))
+		serviceManager.requestTunnelTileUpdate()
-    }
+	}
 
-    override fun getName(): String {
+	private fun stopBackgroundService() {
-        return _vpnState.value.tunnelConfig?.name ?: ""
+		serviceManager.stopBackgroundService()
-    }
+		serviceManager.requestTunnelTileUpdate()
+	}
 
+	private suspend fun onBeforeStart(tunnelConfig: TunnelConfig) {
+		shutDownActiveTunnel(tunnelConfig)
+		appDataRepository.tunnels.save(tunnelConfig.copy(isActive = true))
+		emitVpnStateConfig(tunnelConfig)
+		resetBackendStatistics()
+		startStatsJob()
+	}
 
-    override fun onStateChange(newState: Tunnel.State) {
+	private suspend fun onBeforeStop(tunnelConfig: TunnelConfig) {
-        handleStateChange(TunnelState.from(newState))
+		appDataRepository.tunnels.save(tunnelConfig.copy(isActive = false))
-    }
+		cancelStatsJob()
+		resetBackendStatistics()
+	}
 
-    private fun handleStateChange(state: TunnelState) {
+	private fun emitTunnelState(state: TunnelState) {
-        emitTunnelState(state)
+		_vpnState.tryEmit(
-        WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+			_vpnState.value.copy(
-        if (state == TunnelState.UP) {
+				status = state,
-            statsJob = startTunnelStatisticsJob()
+			),
-        }
+		)
-        if (state == TunnelState.DOWN) {
+	}
-            try {
-                statsJob?.cancel()
-            } catch (e: CancellationException) {
-                Timber.i("Stats job cancelled")
-            }
-        }
-    }
 
-    private fun startTunnelStatisticsJob() = applicationScope.launch(ioDispatcher) {
+	private fun emitBackendStatistics(statistics: TunnelStatistics) {
-        while (true) {
+		_vpnState.tryEmit(
-            if (backendIsAmneziaUserspace) {
+			_vpnState.value.copy(
-                emitBackendStatistics(AmneziaStatistics(userspaceAmneziaBackend.getStatistics(this@WireGuardTunnel)))
+				statistics = statistics,
-            } else {
+			),
-                emitBackendStatistics(WireGuardStatistics(backend.getStatistics(this@WireGuardTunnel)))
+		)
-            }
+	}
-            delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
-        }
-    }
 
-    override fun onStateChange(state: State) {
+	private fun emitVpnStateConfig(tunnelConfig: TunnelConfig) {
-        handleStateChange(TunnelState.from(state))
+		_vpnState.tryEmit(
-    }
+			_vpnState.value.copy(
+				tunnelConfig = tunnelConfig,
+			),
+		)
+	}
+
+	private fun resetBackendStatistics() {
+		_vpnState.tryEmit(
+			_vpnState.value.copy(
+				statistics = null,
+			),
+		)
+	}
+
+	override suspend fun getState(): TunnelState {
+		return when (val backend = backend()) {
+			is Backend -> backend.getState(this).let { TunnelState.from(it) }
+			is org.amnezia.awg.backend.Backend -> backend.getState(this).let { TunnelState.from(it) }
+			else -> TunnelState.DOWN
+		}
+	}
+
+	override fun cancelStatsJob() {
+		statsJob?.cancel()
+	}
+
+	override fun startStatsJob() {
+		statsJob = startTunnelStatisticsJob()
+	}
+
+	override fun getName(): String {
+		return _vpnState.value.tunnelConfig?.name ?: ""
+	}
+
+	private fun startTunnelStatisticsJob() = applicationScope.launch(ioDispatcher) {
+		val backend = backend()
+		delay(STATS_START_DELAY)
+		while (true) {
+			when (backend) {
+				is Backend -> emitBackendStatistics(
+					WireGuardStatistics(backend.getStatistics(this@WireGuardTunnel)),
+				)
+				is org.amnezia.awg.backend.Backend -> {
+					emitBackendStatistics(
+						AmneziaStatistics(
+							backend.getStatistics(this@WireGuardTunnel),
+						),
+					)
+				}
+			}
+			delay(VPN_STATISTIC_CHECK_INTERVAL)
+		}
+	}
+
+	override fun onStateChange(newState: Tunnel.State) {
+		emitTunnelState(TunnelState.from(newState))
+	}
+
+	override fun onStateChange(state: State) {
+		emitTunnelState(TunnelState.from(state))
+	}
+
+	companion object {
+		const val STATS_START_DELAY = 5_000L
+		const val VPN_STATISTIC_CHECK_INTERVAL = 1_000L
+		const val VPN_RESTART_DELAY = 1_000L
+	}
 }

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

@@ -4,31 +4,31 @@ import org.amnezia.awg.backend.Statistics
 import org.amnezia.awg.crypto.Key
 
 class AmneziaStatistics(private val statistics: Statistics) : TunnelStatistics() {
-    override fun peerStats(peer: Key): PeerStats? {
+	override fun peerStats(peer: Key): PeerStats? {
-        val key = Key.fromBase64(peer.toBase64())
+		val key = Key.fromBase64(peer.toBase64())
-        val stats = statistics.peer(key)
+		val stats = statistics.peer(key)
-        return stats?.let {
+		return stats?.let {
-            PeerStats(
+			PeerStats(
-                rxBytes = stats.rxBytes,
+				rxBytes = stats.rxBytes,
-                txBytes = stats.txBytes,
+				txBytes = stats.txBytes,
-                latestHandshakeEpochMillis = stats.latestHandshakeEpochMillis,
+				latestHandshakeEpochMillis = stats.latestHandshakeEpochMillis,
-            )
+			)
-        }
+		}
-    }
+	}
 
-    override fun isTunnelStale(): Boolean {
+	override fun isTunnelStale(): Boolean {
-        return statistics.isStale
+		return statistics.isStale
-    }
+	}
 
-    override fun getPeers(): Array<Key> {
+	override fun getPeers(): Array<Key> {
-        return statistics.peers()
+		return statistics.peers()
-    }
+	}
 
-    override fun rx(): Long {
+	override fun rx(): Long {
-        return statistics.totalRx()
+		return statistics.totalRx()
-    }
+	}
 
-    override fun tx(): Long {
+	override fun tx(): Long {
-        return statistics.totalTx()
+		return statistics.totalTx()
-    }
+	}
 }

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

@@ -3,16 +3,16 @@ package com.zaneschepke.wireguardautotunnel.service.tunnel.statistics
 import org.amnezia.awg.crypto.Key
 
 abstract class TunnelStatistics {
-    @JvmRecord
+	@JvmRecord
-    data class PeerStats(val rxBytes: Long, val txBytes: Long, val latestHandshakeEpochMillis: Long)
+	data class PeerStats(val rxBytes: Long, val txBytes: Long, val latestHandshakeEpochMillis: Long)
 
-    abstract fun peerStats(peer: Key): PeerStats?
+	abstract fun peerStats(peer: Key): PeerStats?
 
-    abstract fun isTunnelStale(): Boolean
+	abstract fun isTunnelStale(): Boolean
 
-    abstract fun getPeers(): Array<Key>
+	abstract fun getPeers(): Array<Key>
 
-    abstract fun rx(): Long
+	abstract fun rx(): Long
 
-    abstract fun tx(): Long
+	abstract fun tx(): Long
 }

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

@@ -4,33 +4,33 @@ import com.wireguard.android.backend.Statistics
 import org.amnezia.awg.crypto.Key
 
 class WireGuardStatistics(private val statistics: Statistics) : TunnelStatistics() {
-    override fun peerStats(peer: Key): PeerStats? {
+	override fun peerStats(peer: Key): PeerStats? {
-        val key = com.wireguard.crypto.Key.fromBase64(peer.toBase64())
+		val key = com.wireguard.crypto.Key.fromBase64(peer.toBase64())
-        val peerStats = statistics.peer(key)
+		val peerStats = statistics.peer(key)
-        return peerStats?.let {
+		return peerStats?.let {
-            PeerStats(
+			PeerStats(
-                txBytes = peerStats.txBytes,
+				txBytes = peerStats.txBytes,
-                rxBytes = peerStats.rxBytes,
+				rxBytes = peerStats.rxBytes,
-                latestHandshakeEpochMillis = peerStats.latestHandshakeEpochMillis,
+				latestHandshakeEpochMillis = peerStats.latestHandshakeEpochMillis,
-            )
+			)
-        }
+		}
-    }
+	}
 
-    override fun isTunnelStale(): Boolean {
+	override fun isTunnelStale(): Boolean {
-        return statistics.isStale
+		return statistics.isStale
-    }
+	}
 
-    override fun getPeers(): Array<Key> {
+	override fun getPeers(): Array<Key> {
-        return statistics.peers().map {
+		return statistics.peers().map {
-            Key.fromBase64(it.toBase64())
+			Key.fromBase64(it.toBase64())
-        }.toTypedArray()
+		}.toTypedArray()
-    }
+	}
 
-    override fun rx(): Long {
+	override fun rx(): Long {
-        return statistics.totalRx()
+		return statistics.totalRx()
-    }
+	}
 
-    override fun tx(): Long {
+	override fun tx(): Long {
-        return statistics.totalTx()
+		return statistics.totalTx()
-    }
+	}
 }

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

@@ -1,9 +1,14 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
+import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnState
+
 data class AppUiState(
-    val snackbarMessage: String = "",
+	val settings: Settings = Settings(),
-    val snackbarMessageConsumed: Boolean = true,
+	val tunnels: List<TunnelConfig> = emptyList(),
-    val vpnPermissionAccepted: Boolean = false,
+	val vpnState: VpnState = VpnState(),
-    val notificationPermissionAccepted: Boolean = false,
+	val generalState: GeneralState = GeneralState(),
-    val requestPermissions: Boolean = false
+	val autoTunnelActive: Boolean = false,
 )

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

@@ -1,123 +1,110 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
-import android.content.ActivityNotFoundException
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
 import androidx.lifecycle.ViewModel
-import com.wireguard.android.backend.GoBackend
+import androidx.lifecycle.viewModelScope
-import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+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.TunnelService
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.util.Constants
 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.update
+import kotlinx.coroutines.flow.collect
-import timber.log.Timber
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.takeWhile
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.plus
+import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
+import javax.inject.Provider
 
 @HiltViewModel
 class AppViewModel
 @Inject
-constructor() : ViewModel() {
+constructor(
+	private val appDataRepository: AppDataRepository,
+	private val tunnelService: Provider<TunnelService>,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+	private val serviceManager: ServiceManager,
+) : ViewModel() {
 
-    val vpnIntent: Intent? = GoBackend.VpnService.prepare(WireGuardAutoTunnel.instance)
+	val uiState =
+		combine(
+			appDataRepository.settings.getSettingsFlow(),
+			appDataRepository.tunnels.getTunnelConfigsFlow(),
+			tunnelService.get().vpnState,
+			appDataRepository.appState.generalStateFlow,
+			serviceManager.autoTunnelActive,
+		) { settings, tunnels, tunnelState, generalState, autoTunnel ->
+			AppUiState(
+				settings,
+				tunnels,
+				tunnelState,
+				generalState,
+				autoTunnel,
+			)
+		}.stateIn(
+			viewModelScope + ioDispatcher,
+			SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
+			AppUiState(),
+		)
 
-    private val _appUiState = MutableStateFlow(
+	private val _isAppReady = MutableStateFlow<Boolean>(false)
-        AppUiState(
+	val isAppReady = _isAppReady.asStateFlow()
-            vpnPermissionAccepted = vpnIntent == null,
-        ),
-    )
-    val appUiState = _appUiState.asStateFlow()
 
+	init {
+		viewModelScope.launch {
+			initPin()
+			initAutoTunnel()
+			initTunnel()
+			appReadyCheck()
+		}
+	}
 
-    fun isRequiredPermissionGranted(): Boolean {
+	private suspend fun appReadyCheck() {
-        val allAccepted =
+		val tunnelCount = appDataRepository.tunnels.count()
-            (_appUiState.value.vpnPermissionAccepted && _appUiState.value.vpnPermissionAccepted)
+		uiState.takeWhile { it.tunnels.size != tunnelCount }.onCompletion {
-        if (!allAccepted) requestPermissions()
+			_isAppReady.emit(true)
-        return allAccepted
+		}.collect()
-    }
+	}
 
-    private fun requestPermissions() {
+	private suspend fun initTunnel() {
-        _appUiState.update {
+		if (tunnelService.get().getState() == TunnelState.UP) tunnelService.get().startStatsJob()
-            it.copy(
+		val activeTunnels = appDataRepository.tunnels.getActive()
-                requestPermissions = true,
+		if (activeTunnels.isNotEmpty() &&
-            )
+			tunnelService.get().getState() == TunnelState.DOWN
-        }
+		) {
-    }
+			tunnelService.get().startTunnel(activeTunnels.first())
+		}
+	}
 
-    fun permissionsRequested() {
+	private suspend fun initPin() {
-        _appUiState.update {
+		val isPinEnabled = appDataRepository.appState.isPinLockEnabled()
-            it.copy(
+		if (isPinEnabled) PinManager.initialize(WireGuardAutoTunnel.instance)
-                requestPermissions = false,
+	}
-            )
-        }
-    }
 
-    fun openWebPage(url: String, context: Context) {
+	private suspend fun initAutoTunnel() {
-        try {
+		val settings = appDataRepository.settings.getSettings()
-            val webpage: Uri = Uri.parse(url)
+		if (settings.isAutoTunnelEnabled) serviceManager.startAutoTunnel(false)
-            val intent = Intent(Intent.ACTION_VIEW, webpage).apply {
+	}
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            }
-            context.startActivity(intent)
-        } catch (e: ActivityNotFoundException) {
-            Timber.e(e)
-            showSnackbarMessage(context.getString(R.string.no_browser_detected))
-        }
-    }
 
-    fun onVpnPermissionAccepted() {
+	fun onPinLockDisabled() = viewModelScope.launch(ioDispatcher) {
-        _appUiState.update {
+		PinManager.clearPin()
-            it.copy(
+		appDataRepository.appState.setPinLockEnabled(false)
-                vpnPermissionAccepted = true,
+	}
-            )
-        }
-    }
 
-    fun launchEmail(context: Context) {
+	fun onPinLockEnabled() = viewModelScope.launch {
-        try {
+		appDataRepository.appState.setPinLockEnabled(true)
-            val intent =
+	}
-                Intent(Intent.ACTION_SENDTO).apply {
-                    type = Constants.EMAIL_MIME_TYPE
-                    putExtra(Intent.EXTRA_EMAIL, arrayOf(context.getString(R.string.my_email)))
-                    putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.email_subject))
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                }
-            context.startActivity(
-                Intent.createChooser(intent, context.getString(R.string.email_chooser)).apply {
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                },
-            )
-        } catch (e: ActivityNotFoundException) {
-            Timber.e(e)
-            showSnackbarMessage(context.getString(R.string.no_email_detected))
-        }
-    }
 
-    fun showSnackbarMessage(message: String) {
+	fun setLocationDisclosureShown() = viewModelScope.launch {
-        _appUiState.update {
+		appDataRepository.appState.setLocationDisclosureShown(true)
-            it.copy(
+	}
-                snackbarMessage = message,
-                snackbarMessageConsumed = false,
-            )
-        }
-    }
-
-    fun snackbarMessageConsumed() {
-        _appUiState.update {
-            it.copy(
-                snackbarMessage = "",
-                snackbarMessageConsumed = true,
-            )
-        }
-    }
-
-    fun setNotificationPermissionAccepted(accepted: Boolean) {
-        _appUiState.update {
-            it.copy(
-                notificationPermissionAccepted = accepted,
-            )
-        }
-    }
 }

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

@@ -1,291 +1,249 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
-import android.Manifest
+import android.content.Context
-import android.os.Build
 import android.os.Bundle
-import androidx.activity.SystemBarStyle
-import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
+import androidx.activity.viewModels
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.foundation.focusable
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Home
+import androidx.compose.material.icons.rounded.QuestionMark
+import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarData
-import androidx.compose.material3.SnackbarDuration
 import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.SnackbarResult
 import androidx.compose.material3.surfaceColorAtElevation
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.lifecycleScope
-import androidx.navigation.NavType
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
-import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
-import androidx.navigation.navArgument
+import androidx.navigation.toRoute
-import com.google.accompanist.permissions.ExperimentalPermissionsApi
-import com.google.accompanist.permissions.isGranted
-import com.google.accompanist.permissions.rememberPermissionState
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.datastore.LocaleStorage
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
-import com.zaneschepke.wireguardautotunnel.ui.common.prompt.CustomSnackBar
+import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavItem
+import com.zaneschepke.wireguardautotunnel.ui.common.navigation.LocalFocusRequester
+import com.zaneschepke.wireguardautotunnel.ui.common.navigation.LocalNavController
+import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.CustomSnackBar
+import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.SnackbarControllerProvider
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.ConfigScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.options.OptionsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.pinlock.PinLockScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.scanner.ScannerScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.AppearanceScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.display.DisplayScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.appearance.language.LanguageScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.autotunnel.AutoTunnelScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.disclosure.LocationDisclosureScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.logs.LogsScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
-import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestAutoTunnelTileServiceUpdate
+import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.Dispatchers
+import timber.log.Timber
-import kotlinx.coroutines.launch
-import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
 
-    @Inject
+	private val localeStorage: LocaleStorage by lazy {
-    lateinit var dataStoreManager: DataStoreManager
+		(application as WireGuardAutoTunnel).localeStorage
+	}
 
-    @Inject
+	private lateinit var oldPrefLocaleCode: String
-    lateinit var settingsRepository: SettingsRepository
 
-    @Inject
+	@Inject
-    lateinit var serviceManager: ServiceManager
+	lateinit var appStateRepository: AppStateRepository
 
-    @OptIn(
+	@Inject
-        ExperimentalPermissionsApi::class,
+	lateinit var tunnelService: TunnelService
-    )
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
 
-        enableEdgeToEdge(navigationBarStyle = SystemBarStyle.dark(Color.Transparent.toArgb()))
+	private val viewModel by viewModels<AppViewModel>()
 
-        // load preferences into memory and init data
+	override fun onCreate(savedInstanceState: Bundle?) {
-        lifecycleScope.launch {
+		super.onCreate(savedInstanceState)
-            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()
 
-            val notificationPermissionState =
+		installSplashScreen().apply {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
+			setKeepOnScreenCondition {
-                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS) else null
+				!viewModel.isAppReady.value
+			}
+		}
 
-            val snackbarHostState = remember { SnackbarHostState() }
+		setContent {
+			val appUiState by viewModel.uiState.collectAsStateWithLifecycle(lifecycle = this.lifecycle)
+			val navController = rememberNavController()
+			val rootItemFocusRequester = remember { FocusRequester() }
 
-            val vpnActivityResultState =
+			LaunchedEffect(appUiState.tunnels) {
-                rememberLauncherForActivityResult(
+				Timber.d("Updating launched")
-                    ActivityResultContracts.StartActivityForResult(),
+				requestTunnelTileServiceStateUpdate()
-                    onResult = {
+			}
-                        val accepted = (it.resultCode == RESULT_OK)
-                        if (accepted) {
-                            appViewModel.onVpnPermissionAccepted()
-                        }
-                    },
-                )
 
-            fun showSnackBarMessage(message: StringValue) {
+			LaunchedEffect(appUiState.autoTunnelActive) {
-                lifecycleScope.launch(Dispatchers.Main) {
+				requestAutoTunnelTileServiceUpdate()
-                    val result =
+			}
-                        snackbarHostState.showSnackbar(
-                            message = message.asString(this@MainActivity),
-                            duration = SnackbarDuration.Short,
-                        )
-                    when (result) {
-                        SnackbarResult.ActionPerformed,
-                        SnackbarResult.Dismissed -> {
-                            snackbarHostState.currentSnackbarData?.dismiss()
-                        }
-                    }
-                }
-            }
 
-            LaunchedEffect(appUiState.requestPermissions) {
+			with(appUiState.settings) {
-                if (appUiState.requestPermissions) {
+				LaunchedEffect(isAutoTunnelEnabled) {
-                    appViewModel.permissionsRequested()
+					this@MainActivity.requestAutoTunnelTileServiceUpdate()
-                    if (notificationPermissionState != null && !notificationPermissionState.status.isGranted
+				}
-                    ) {
+			}
-                        showSnackBarMessage(StringValue.StringResource(R.string.notification_permission_required))
-                        return@LaunchedEffect notificationPermissionState.launchPermissionRequest()
-                    }
-                    if (!appUiState.vpnPermissionAccepted) {
-                        return@LaunchedEffect appViewModel.vpnIntent?.let {
-                            vpnActivityResultState.launch(
-                                it,
-                            )
-                        }!!
-                    }
-                }
-            }
 
-            WireguardAutoTunnelTheme {
+			CompositionLocalProvider(LocalFocusRequester provides rootItemFocusRequester) {
-                LaunchedEffect(Unit) {
+				CompositionLocalProvider(LocalNavController provides navController) {
-                    appViewModel.setNotificationPermissionAccepted(
+					SnackbarControllerProvider { host ->
-                        notificationPermissionState?.status?.isGranted ?: true,
+						WireguardAutoTunnelTheme(theme = appUiState.generalState.theme) {
-                    )
+							Scaffold(
-                }
+								contentWindowInsets = WindowInsets(0.dp),
+								snackbarHost = {
+									SnackbarHost(host) { snackbarData: SnackbarData ->
+										CustomSnackBar(
+											snackbarData.visuals.message,
+											isRtl = false,
+											containerColor =
+											MaterialTheme.colorScheme.surfaceColorAtElevation(
+												2.dp,
+											),
+										)
+									}
+								},
+								bottomBar = {
+									BottomNavBar(
+										navController,
+										listOf(
+											BottomNavItem(
+												name = stringResource(R.string.tunnels),
+												route = Route.Main,
+												icon = Icons.Rounded.Home,
+											),
+											BottomNavItem(
+												name = stringResource(R.string.settings),
+												route = Route.Settings,
+												icon = Icons.Rounded.Settings,
+											),
+											BottomNavItem(
+												name = stringResource(R.string.support),
+												route = Route.Support,
+												icon = Icons.Rounded.QuestionMark,
+											),
+										),
+									)
+								},
+							) {
+								Box(modifier = Modifier.fillMaxSize().padding(it)) {
+									NavHost(
+										navController,
+										enterTransition = { fadeIn(tween(Constants.TRANSITION_ANIMATION_TIME)) },
+										exitTransition = { fadeOut(tween(Constants.TRANSITION_ANIMATION_TIME)) },
+										startDestination = (if (appUiState.generalState.isPinLockEnabled == true) Route.Lock else Route.Main),
+									) {
+										composable<Route.Main> {
+											MainScreen(
+												uiState = appUiState,
+											)
+										}
+										composable<Route.Settings> {
+											SettingsScreen(
+												appViewModel = viewModel,
+												uiState = appUiState,
+											)
+										}
+										composable<Route.LocationDisclosure> {
+											LocationDisclosureScreen(viewModel, appUiState)
+										}
+										composable<Route.AutoTunnel> {
+											AutoTunnelScreen(
+												appUiState,
+											)
+										}
+										composable<Route.Appearance> {
+											AppearanceScreen()
+										}
+										composable<Route.Language> {
+											LanguageScreen(localeStorage)
+										}
+										composable<Route.Display> {
+											DisplayScreen(appUiState)
+										}
+										composable<Route.Support> {
+											SupportScreen()
+										}
+										composable<Route.Logs> {
+											LogsScreen()
+										}
+										composable<Route.Config> {
+											val args = it.toRoute<Route.Config>()
+											ConfigScreen(
+												tunnelId = args.id,
+											)
+										}
+										composable<Route.Option> {
+											val args = it.toRoute<Route.Option>()
+											OptionsScreen(
+												tunnelId = args.id,
+												appUiState = appUiState,
+											)
+										}
+										composable<Route.Lock> {
+											PinLockScreen(
+												appViewModel = viewModel,
+											)
+										}
+										composable<Route.Scanner> {
+											ScannerScreen()
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
 
-                LaunchedEffect(appUiState.snackbarMessageConsumed) {
+	override fun attachBaseContext(newBase: Context) {
-                    if (!appUiState.snackbarMessageConsumed) {
+		oldPrefLocaleCode = LocaleStorage(newBase).getPreferredLocale()
-                        showSnackBarMessage(StringValue.DynamicString(appUiState.snackbarMessage))
+		applyOverrideConfiguration(LocaleUtil.getLocalizedConfiguration(oldPrefLocaleCode))
-                        appViewModel.snackbarMessageConsumed()
+		super.attachBaseContext(newBase)
-                    }
+	}
-                }
 
-                val focusRequester = remember { FocusRequester() }
+	override fun onResume() {
+		val currentLocaleCode = LocaleStorage(this).getPreferredLocale()
+		if (oldPrefLocaleCode != currentLocaleCode) {
+			recreate() // locale is changed, restart the activity to update
+			oldPrefLocaleCode = currentLocaleCode
+		}
+		super.onResume()
+	}
 
-                Scaffold(
+	override fun onDestroy() {
-                    snackbarHost = {
+		super.onDestroy()
-                        SnackbarHost(snackbarHostState) { snackbarData: SnackbarData ->
+		tunnelService.cancelStatsJob()
-                            CustomSnackBar(
+	}
-                                snackbarData.visuals.message,
-                                isRtl = false,
-                                containerColor =
-                                MaterialTheme.colorScheme.surfaceColorAtElevation(
-                                    2.dp,
-                                ),
-                            )
-                        }
-                    },
-                    //TODO refactor
-                    modifier = Modifier
-                        .focusable()
-                        .focusProperties {
-                            when (navBackStackEntry?.destination?.route) {
-                                Screen.Lock.route -> Unit
-                                else -> up = focusRequester
-                            }
-                        },
-                    bottomBar = {
-                        BottomNavBar(
-                            navController,
-                            listOf(
-                                Screen.Main.navItem,
-                                Screen.Settings.navItem,
-                                Screen.Support.navItem,
-                            ),
-                        )
-                    },
-                ) { padding ->
-                    NavHost(
-                        navController,
-                        startDestination =
-                        (if (PinManager.pinExists()) Screen.Lock.route else Screen.Main.route),
-                        modifier =
-                        Modifier
-                            .padding(padding)
-                            .fillMaxSize(),
-                    ) {
-                        composable(
-                            Screen.Main.route,
-                        ) {
-                            MainScreen(
-                                focusRequester = focusRequester,
-                                appViewModel = appViewModel,
-                                navController = navController,
-                            )
-                        }
-                        composable(
-                            Screen.Settings.route,
-                        ) {
-                            SettingsScreen(
-                                appViewModel = appViewModel,
-                                navController = navController,
-                                focusRequester = focusRequester,
-                            )
-                        }
-                        composable(
-                            Screen.Support.route,
-                        ) {
-                            SupportScreen(
-                                focusRequester = focusRequester,
-                                appViewModel = appViewModel,
-                                navController = navController,
-                            )
-                        }
-                        composable(Screen.Support.Logs.route) {
-                            LogsScreen()
-                        }
-                        composable(
-                            "${Screen.Config.route}/{id}?configType={configType}",
-                            arguments =
-                            listOf(
-                                navArgument("id") {
-                                    type = NavType.StringType
-                                    defaultValue = "0"
-                                },
-                                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,
-                            )
-                            if (!id.isNullOrBlank()) {
-                                ConfigScreen(
-                                    navController = navController,
-                                    tunnelId = id,
-                                    appViewModel = appViewModel,
-                                    focusRequester = focusRequester,
-                                    configType = configType,
-                                )
-                            }
-                        }
-                        composable("${Screen.Option.route}/{id}") {
-                            val id = it.arguments?.getString("id")
-                            if (!id.isNullOrBlank()) {
-                                OptionsScreen(
-                                    navController = navController,
-                                    tunnelId = id,
-                                    appViewModel = appViewModel,
-                                    focusRequester = focusRequester,
-                                )
-                            }
-                        }
-                        composable(Screen.Lock.route) {
-                            PinLockScreen(
-                                navController = navController,
-                                appViewModel = appViewModel,
-                            )
-                        }
-                    }
-                }
-            }
-        }
-    }
 }

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

@@ -0,0 +1,48 @@
+package com.zaneschepke.wireguardautotunnel.ui
+
+import kotlinx.serialization.Serializable
+
+sealed class Route {
+	@Serializable
+	data object Support : Route()
+
+	@Serializable
+	data object Settings : Route()
+
+	@Serializable
+	data object AutoTunnel : Route()
+
+	@Serializable
+	data object LocationDisclosure : Route()
+
+	@Serializable
+	data object Appearance : Route()
+
+	@Serializable
+	data object Display : Route()
+
+	@Serializable
+	data object Language : Route()
+
+	@Serializable
+	data object Main : Route()
+
+	@Serializable
+	data class Option(
+		val id: Int,
+	) : Route()
+
+	@Serializable
+	data object Lock : Route()
+
+	@Serializable
+	data object Scanner : Route()
+
+	@Serializable
+	data class Config(
+		val id: Int,
+	) : Route()
+
+	@Serializable
+	data object Logs : Route()
+}

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

@@ -1,45 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.rounded.Home
-import androidx.compose.material.icons.rounded.QuestionMark
-import androidx.compose.material.icons.rounded.Settings
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavItem
-
-sealed class Screen(val route: String) {
-    data object Main : Screen("main") {
-        val navItem =
-            BottomNavItem(
-                name = WireGuardAutoTunnel.instance.getString(R.string.tunnels),
-                route = route,
-                icon = Icons.Rounded.Home,
-            )
-    }
-
-    data object Settings : Screen("settings") {
-        val navItem =
-            BottomNavItem(
-                name = WireGuardAutoTunnel.instance.getString(R.string.settings),
-                route = route,
-                icon = Icons.Rounded.Settings,
-            )
-    }
-
-    data object Support : Screen("support") {
-        val navItem =
-            BottomNavItem(
-                name = WireGuardAutoTunnel.instance.getString(R.string.support),
-                route = route,
-                icon = Icons.Rounded.QuestionMark,
-            )
-
-        data object Logs : Screen("support/logs")
-    }
-
-    data object Config : Screen("config")
-    data object Lock : Screen("lock")
-
-    data object Option : Screen("option")
-}

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

@@ -5,6 +5,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.size
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
@@ -12,31 +13,25 @@ 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 = true) {
-    onClick: () -> Unit,
+	TextButton(
-    onIconClick: () -> Unit,
+		onClick = onClick,
-    text: String,
+		enabled = enabled,
-    icon: ImageVector,
+	) {
-    enabled: Boolean
+		Text(text, Modifier.weight(1f, false), style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.primary)
-) {
+		Spacer(modifier = Modifier.size(ButtonDefaults.IconSpacing))
-    TextButton(
+		Icon(
-        onClick = onClick,
+			imageVector = icon,
-        enabled = enabled,
+			contentDescription = icon.name,
-    ) {
+			modifier =
-        Text(text, Modifier.weight(1f, false))
+			Modifier
-        Spacer(modifier = Modifier.size(ButtonDefaults.IconSpacing))
+				.size(ButtonDefaults.IconSize)
-        Icon(
+				.weight(1f, false)
-            imageVector = icon,
+				.clickable {
-            contentDescription = icon.name,
+					if (enabled) {
-            modifier =
+						onIconClick()
-            Modifier
+					}
-                .size(ButtonDefaults.IconSize)
+				},
-                .weight(1f, false)
+		)
-                .clickable {
+	}
-                    if (enabled) {
-                        onIconClick()
-                    }
-                },
-        )
-    }
 }

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

@@ -0,0 +1,65 @@
+package com.zaneschepke.wireguardautotunnel.ui.common
+
+import androidx.compose.animation.animateContentSize
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun ExpandingRowListItem(
+	leading: @Composable () -> Unit,
+	text: String,
+	onHold: () -> Unit = {},
+	onClick: () -> Unit,
+	trailing: @Composable () -> Unit,
+	isExpanded: Boolean,
+	expanded: @Composable () -> Unit = {},
+) {
+	Box(
+		modifier =
+		Modifier
+			.animateContentSize()
+			.clip(RoundedCornerShape(30.dp))
+			.combinedClickable(
+				onClick = { onClick() },
+				onLongClick = { onHold() },
+			),
+	) {
+		Column {
+			Row(
+				modifier =
+				Modifier
+					.fillMaxWidth()
+					.padding(horizontal = 15.dp),
+				verticalAlignment = Alignment.CenterVertically,
+				horizontalArrangement = Arrangement.SpaceBetween,
+			) {
+				Row(
+					verticalAlignment = Alignment.CenterVertically,
+					horizontalArrangement = Arrangement.spacedBy(15.dp),
+					modifier = Modifier.fillMaxWidth(13 / 20f),
+				) {
+					leading()
+					Text(text, maxLines = 1, overflow = TextOverflow.Ellipsis, style = MaterialTheme.typography.labelLarge)
+				}
+				trailing()
+			}
+			if (isExpanded) expanded()
+		}
+	}
+}

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

@@ -0,0 +1,13 @@
+package com.zaneschepke.wireguardautotunnel.ui.common
+
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource
+
+class NestedScrollListener(val onUp: () -> Unit, val onDown: () -> Unit) : NestedScrollConnection {
+	override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
+		if (available.y < -1) onDown()
+		if (available.y > 1) onUp()
+		return Offset.Zero
+	}
+}

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

@@ -1,94 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common
-
-import androidx.compose.animation.animateContentSize
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
-import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import com.zaneschepke.wireguardautotunnel.util.toThreeDecimalPlaceString
-
-@OptIn(ExperimentalFoundationApi::class)
-@Composable
-fun RowListItem(
-    icon: @Composable () -> Unit,
-    text: String,
-    onHold: () -> Unit,
-    onClick: () -> Unit,
-    rowButton: @Composable () -> Unit,
-    expanded: Boolean,
-    statistics: TunnelStatistics?
-) {
-    Box(
-        modifier =
-        Modifier
-            .animateContentSize()
-            .clip(RoundedCornerShape(30.dp))
-            .combinedClickable(
-                onClick = { onClick() },
-                onLongClick = { onHold() },
-            ),
-    ) {
-        Column {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 15.dp, vertical = 5.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth(13 / 20f),
-                ) {
-                    icon()
-                    Text(text, maxLines = 1, overflow = TextOverflow.Ellipsis)
-                }
-                rowButton()
-            }
-            if (expanded) {
-                statistics?.getPeers()?.forEach {
-                    Row(
-                        modifier =
-                        Modifier
-                            .fillMaxWidth()
-                            .padding(end = 10.dp, bottom = 10.dp, start = 10.dp),
-                        verticalAlignment = Alignment.CenterVertically,
-                        horizontalArrangement = Arrangement.SpaceEvenly,
-                    ) {
-                        //TODO change these to string resources
-                        val handshakeEpoch = statistics.peerStats(it)!!.latestHandshakeEpochMillis
-                        val peerTx = statistics.peerStats(it)!!.txBytes
-                        val peerRx = statistics.peerStats(it)!!.rxBytes
-                        val peerId = it.toBase64().subSequence(0, 3).toString() + "***"
-                        val handshakeSec =
-                            NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch)
-                        val handshake =
-                            if (handshakeSec == null) "never" else "$handshakeSec secs ago"
-                        val peerTxMB = NumberUtils.bytesToMB(peerTx).toThreeDecimalPlaceString()
-                        val peerRxMB = NumberUtils.bytesToMB(peerRx).toThreeDecimalPlaceString()
-                        val fontSize = 9.sp
-                        Text("peer: $peerId", fontSize = fontSize)
-                        Text("handshake: $handshake", fontSize = fontSize)
-                        Text("tx: $peerTxMB MB", fontSize = fontSize)
-                        Text("rx: $peerRxMB MB", fontSize = fontSize)
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -26,57 +26,57 @@ import com.zaneschepke.wireguardautotunnel.R
 
 @Composable
 fun SearchBar(onQuery: (queryString: String) -> Unit) {
-    // Immediately update and keep track of query from text field changes.
+	// Immediately update and keep track of query from text field changes.
-    var query: String by rememberSaveable { mutableStateOf("") }
+	var query: String by rememberSaveable { mutableStateOf("") }
-    var showClearIcon by rememberSaveable { mutableStateOf(false) }
+	var showClearIcon by rememberSaveable { mutableStateOf(false) }
 
-    if (query.isEmpty()) {
+	if (query.isEmpty()) {
-        showClearIcon = false
+		showClearIcon = false
-    } else if (query.isNotEmpty()) {
+	} else if (query.isNotEmpty()) {
-        showClearIcon = true
+		showClearIcon = true
-    }
+	}
 
-    TextField(
+	TextField(
-        value = query,
+		value = query,
-        onValueChange = { onQueryChanged ->
+		onValueChange = { onQueryChanged ->
-            // If user makes changes to text, immediately updated it.
+			// If user makes changes to text, immediately updated it.
-            query = onQueryChanged
+			query = onQueryChanged
-            onQuery(onQueryChanged)
+			onQuery(onQueryChanged)
-        },
+		},
-        leadingIcon = {
+		leadingIcon = {
-            val icon = Icons.Rounded.Search
+			val icon = Icons.Rounded.Search
-            Icon(
+			Icon(
-                imageVector = icon,
+				imageVector = icon,
-                tint = MaterialTheme.colorScheme.onBackground,
+				tint = MaterialTheme.colorScheme.onBackground,
-                contentDescription = icon.name,
+				contentDescription = icon.name,
-            )
+			)
-        },
+		},
-        trailingIcon = {
+		trailingIcon = {
-            if (showClearIcon) {
+			if (showClearIcon) {
-                IconButton(onClick = { query = "" }) {
+				IconButton(onClick = { query = "" }) {
-                    val icon = Icons.Rounded.Clear
+					val icon = Icons.Rounded.Clear
-                    Icon(
+					Icon(
-                        imageVector = icon,
+						imageVector = icon,
-                        tint = MaterialTheme.colorScheme.onBackground,
+						tint = MaterialTheme.colorScheme.onBackground,
-                        contentDescription = icon.name,
+						contentDescription = icon.name,
-                    )
+					)
-                }
+				}
-            }
+			}
-        },
+		},
-        maxLines = 1,
+		maxLines = 1,
-        colors =
+		colors =
-        TextFieldDefaults.colors(
+		TextFieldDefaults.colors(
-            focusedContainerColor = Color.Transparent,
+			focusedContainerColor = Color.Transparent,
-            unfocusedContainerColor = Color.Transparent,
+			unfocusedContainerColor = Color.Transparent,
-            disabledContainerColor = Color.Transparent,
+			disabledContainerColor = Color.Transparent,
-        ),
+		),
-        placeholder = { Text(text = stringResource(R.string.hint_search_packages)) },
+		placeholder = { Text(text = stringResource(R.string.hint_search_packages)) },
-        textStyle = MaterialTheme.typography.bodySmall,
+		textStyle = MaterialTheme.typography.bodySmall,
-        singleLine = true,
+		singleLine = true,
-        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Text),
+		keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Text),
-        modifier =
+		modifier =
-        Modifier
+		Modifier
-            .fillMaxWidth()
+			.fillMaxWidth()
-            .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape),
+			.background(color = MaterialTheme.colorScheme.background, shape = RectangleShape),
-    )
+	)
 }

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

@@ -0,0 +1,37 @@
+package com.zaneschepke.wireguardautotunnel.ui.common
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledWidth
+
+@Composable
+fun SelectedLabel() {
+	Row(
+		modifier = Modifier.fillMaxWidth(),
+		horizontalArrangement = Arrangement.End,
+		verticalAlignment = Alignment.CenterVertically,
+	) {
+		Text(
+			stringResource(id = R.string.selected),
+			modifier =
+			Modifier.padding(
+				horizontal = 24.dp.scaledWidth(),
+				vertical = 16.dp.scaledHeight(),
+			),
+			color =
+			MaterialTheme.colorScheme.onSurfaceVariant,
+			style = MaterialTheme.typography.labelSmall,
+		)
+	}
+}

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

@@ -0,0 +1,100 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.button
+
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.IntrinsicSize
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledWidth
+import kotlin.let
+
+@androidx.compose.runtime.Composable
+fun IconSurfaceButton(title: String, onClick: () -> Unit, selected: Boolean, leadingIcon: ImageVector? = null, description: String? = null) {
+	val border: BorderStroke? =
+		if (selected) {
+			BorderStroke(
+				1.dp,
+				MaterialTheme.colorScheme.primary,
+			)
+		} else {
+			null
+		}
+	Card(
+		modifier =
+		Modifier
+			.fillMaxWidth()
+			.height(IntrinsicSize.Min),
+		shape = RoundedCornerShape(8.dp),
+		border = border,
+		colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+	) {
+		Box(
+			modifier = Modifier.clickable { onClick() }
+				.fillMaxWidth(),
+		) {
+			Column(
+				modifier =
+				Modifier
+					.padding(horizontal = 8.dp.scaledWidth(), vertical = 10.dp.scaledHeight())
+					.padding(end = 16.dp.scaledWidth()).padding(start = 8.dp.scaledWidth())
+					.fillMaxSize(),
+				verticalArrangement = Arrangement.Center,
+				horizontalAlignment = Alignment.Start,
+			) {
+				Row(
+					verticalAlignment = Alignment.Companion.CenterVertically,
+					horizontalArrangement = Arrangement.spacedBy(16.dp.scaledWidth()),
+				) {
+					Row(
+						horizontalArrangement = Arrangement.spacedBy(
+							16.dp.scaledWidth(),
+						),
+						verticalAlignment = Alignment.Companion.CenterVertically,
+						modifier = Modifier.padding(vertical = if (description == null) 10.dp.scaledHeight() else 0.dp),
+					) {
+						leadingIcon?.let {
+							Icon(
+								leadingIcon,
+								leadingIcon.name,
+								Modifier.size(iconSize),
+								if (selected) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurface,
+							)
+						}
+						Column {
+							Text(
+								title,
+								style = MaterialTheme.typography.titleMedium,
+							)
+							description?.let {
+								Text(
+									description,
+									color = MaterialTheme.colorScheme.onSurfaceVariant,
+									style = MaterialTheme.typography.bodyMedium,
+								)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,18 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.button
+
+import androidx.compose.material3.Switch
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
+
+@Composable
+fun ScaledSwitch(checked: Boolean, onClick: (checked: Boolean) -> Unit, enabled: Boolean = true, modifier: Modifier = Modifier) {
+	Switch(
+		checked,
+		{ onClick(it) },
+		modifier.scale((52.dp.scaledHeight() / 52.dp)),
+		enabled = enabled,
+	)
+}

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

@@ -0,0 +1,63 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.button
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.ripple
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
+
+@Composable
+fun SelectionItemButton(
+	leading: (@Composable () -> Unit)? = null,
+	buttonText: String,
+	trailing: (@Composable () -> Unit)? = null,
+	onClick: () -> Unit,
+	ripple: Boolean = true,
+) {
+	Card(
+		modifier =
+		Modifier.clip(RoundedCornerShape(8.dp))
+			.clickable(
+				indication = if (ripple) ripple() else null,
+				interactionSource = remember { MutableInteractionSource() },
+				onClick = { onClick() },
+			)
+			.height(56.dp.scaledHeight()),
+		colors =
+		CardDefaults.cardColors(
+			containerColor = MaterialTheme.colorScheme.background,
+		),
+	) {
+		Row(
+			verticalAlignment = Alignment.CenterVertically,
+			horizontalArrangement = Arrangement.Start,
+			modifier = Modifier.fillMaxSize(),
+		) {
+			leading?.let {
+				it()
+			}
+			Text(
+				buttonText,
+				style = MaterialTheme.typography.bodyLarge,
+				color = MaterialTheme.colorScheme.onSurface,
+			)
+			trailing?.let {
+				it()
+			}
+		}
+	}
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/button/surface/SelectionItem.kt

@@ -0,0 +1,13 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.button.surface
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.vector.ImageVector
+
+data class SelectionItem(
+	val leadingIcon: ImageVector? = null,
+	val trailing: (@Composable () -> Unit)? = null,
+	val title: (@Composable () -> Unit),
+	val description: (@Composable () -> Unit)? = null,
+	val onClick: (() -> Unit)? = null,
+	val height: Int = 64,
+)

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/common/button/surface/SurfaceSelectionGroupButton.kt

@@ -0,0 +1,86 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.button.surface
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import com.zaneschepke.wireguardautotunnel.ui.theme.iconSize
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledHeight
+import com.zaneschepke.wireguardautotunnel.util.extensions.scaledWidth
+
+@Composable
+fun SurfaceSelectionGroupButton(items: List<SelectionItem>) {
+	Card(
+		modifier = Modifier.fillMaxWidth(),
+		shape = RoundedCornerShape(8.dp),
+		colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+	) {
+		items.mapIndexed { index, item ->
+			Box(
+				contentAlignment = Alignment.Center,
+				modifier = Modifier
+					.then(item.onClick?.let { Modifier.clickable { it() } } ?: Modifier)
+					.fillMaxWidth(),
+			) {
+				Row(
+					verticalAlignment = Alignment.CenterVertically,
+					modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp.scaledHeight()),
+				) {
+					Row(
+						verticalAlignment = Alignment.CenterVertically,
+						modifier = Modifier
+							.padding(start = 16.dp.scaledWidth())
+							.weight(4f, false)
+							.fillMaxWidth(),
+					) {
+						item.leadingIcon?.let { icon ->
+							Icon(
+								icon,
+								icon.name,
+								modifier = Modifier.size(iconSize),
+							)
+						}
+						Column(
+							horizontalAlignment = Alignment.Start,
+							verticalArrangement = Arrangement.spacedBy(2.dp, Alignment.CenterVertically),
+							modifier = Modifier
+								.fillMaxWidth()
+								.padding(start = if (item.leadingIcon != null) 16.dp.scaledWidth() else 0.dp)
+								.padding(vertical = if (item.description == null) 16.dp.scaledHeight() else 6.dp.scaledHeight()),
+						) {
+							item.title()
+							item.description?.let {
+								it()
+							}
+						}
+					}
+					item.trailing?.let {
+						Box(
+							contentAlignment = Alignment.CenterEnd,
+							modifier = Modifier
+								.padding(end = 24.dp.scaledWidth(), start = 16.dp.scaledWidth())
+								.weight(1f),
+						) {
+							it()
+						}
+					}
+				}
+			}
+			if (index + 1 != items.size) HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
+		}
+	}
+}

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

@@ -1,5 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.common.config
 
+import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material3.OutlinedTextField
@@ -11,26 +12,32 @@ import androidx.compose.ui.text.input.KeyboardCapitalization
 
 @Composable
 fun ConfigurationTextBox(
-    value: String,
+	value: String,
-    hint: String,
+	hint: String,
-    onValueChange: (String) -> Unit,
+	onValueChange: (String) -> Unit,
-    keyboardActions: KeyboardActions,
+	keyboardActions: KeyboardActions = KeyboardActions(),
-    label: String,
+	label: String,
-    modifier: Modifier
+	modifier: Modifier,
+	isError: Boolean = false,
+	keyboardOptions: KeyboardOptions = KeyboardOptions(
+		capitalization = KeyboardCapitalization.None,
+		imeAction = ImeAction.Done,
+	),
+	trailing: @Composable () -> Unit = {},
+	interactionSource: MutableInteractionSource? = null,
 ) {
-    OutlinedTextField(
+	OutlinedTextField(
-        modifier = modifier,
+		isError = isError,
-        value = value,
+		modifier = modifier,
-        singleLine = true,
+		value = value,
-        onValueChange = { onValueChange(it) },
+		singleLine = true,
-        label = { Text(label) },
+		interactionSource = interactionSource,
-        maxLines = 1,
+		onValueChange = { onValueChange(it) },
-        placeholder = { Text(hint) },
+		label = { Text(label) },
-        keyboardOptions =
+		maxLines = 1,
-        KeyboardOptions(
+		placeholder = { Text(hint) },
-            capitalization = KeyboardCapitalization.None,
+		keyboardOptions = keyboardOptions,
-            imeAction = ImeAction.Done,
+		keyboardActions = keyboardActions,
-        ),
+		trailingIcon = trailing,
-        keyboardActions = keyboardActions,
+	)
-    )
 }

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

@@ -3,45 +3,46 @@ package com.zaneschepke.wireguardautotunnel.ui.common.config
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Switch
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.Dp
 
 @Composable
 fun ConfigurationToggle(
-    label: String,
+	label: String,
-    enabled: Boolean,
+	enabled: Boolean = true,
-    checked: Boolean,
+	checked: Boolean,
-    padding: Dp,
+	onCheckChanged: (checked: Boolean) -> Unit,
-    onCheckChanged: () -> Unit,
+	modifier: Modifier = Modifier,
-    modifier: Modifier = Modifier
 ) {
-    Row(
+	Row(
-        modifier = Modifier
+		modifier =
-            .fillMaxWidth()
+		Modifier
-            .padding(padding),
+			.fillMaxWidth(),
-        verticalAlignment = Alignment.CenterVertically,
+		verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.SpaceBetween,
+		horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
+	) {
-        Text(
+		Text(
-            label, textAlign = TextAlign.Start,
+			label,
-            modifier = Modifier
+			textAlign = TextAlign.Start,
-                .weight(
+			style = MaterialTheme.typography.labelLarge,
-                    weight = 1.0f,
+			modifier =
-                    fill = false,
+			Modifier
-                ),
+				.weight(
-            softWrap = true,
+					weight = 1.0f,
-        )
+					fill = false,
-        Switch(
+				),
-            modifier = modifier,
+			softWrap = true,
-            enabled = enabled,
+		)
-            checked = checked,
+		Switch(
-            onCheckedChange = { onCheckChanged() },
+			modifier = modifier,
-        )
+			enabled = enabled,
-    }
+			checked = checked,
+			onCheckedChange = { onCheckChanged(it) },
+		)
+	}
 }

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

@@ -0,0 +1,81 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.config
+
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Save
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import com.zaneschepke.wireguardautotunnel.R
+
+@Composable
+fun SubmitConfigurationTextBox(
+	value: String?,
+	label: String,
+	hint: String,
+	isErrorValue: (value: String?) -> Boolean,
+	onSubmit: (value: String) -> Unit,
+	keyboardOptions: KeyboardOptions = KeyboardOptions(
+		capitalization = KeyboardCapitalization.None,
+		imeAction = ImeAction.Done,
+	),
+) {
+	val focusManager = LocalFocusManager.current
+	val interactionSource = remember { MutableInteractionSource() }
+	val isFocused by interactionSource.collectIsFocusedAsState()
+	val keyboardController = LocalSoftwareKeyboardController.current
+
+	var stateValue by remember { mutableStateOf(value ?: "") }
+
+	OutlinedTextField(
+		isError = isErrorValue(stateValue),
+		modifier = Modifier
+			.fillMaxWidth(),
+		value = stateValue,
+		singleLine = true,
+		interactionSource = interactionSource,
+		onValueChange = { stateValue = it },
+		label = { Text(label) },
+		maxLines = 1,
+		placeholder = { Text(hint) },
+		keyboardOptions = keyboardOptions,
+		keyboardActions = KeyboardActions(
+			onDone = {
+				onSubmit(stateValue)
+				keyboardController?.hide()
+			},
+		),
+		trailingIcon = {
+			if (!isErrorValue(stateValue) && isFocused) {
+				IconButton(onClick = {
+					onSubmit(stateValue)
+					keyboardController?.hide()
+					focusManager.clearFocus()
+				}) {
+					Icon(
+						imageVector = Icons.Outlined.Save,
+						contentDescription = stringResource(R.string.save_changes),
+						tint = MaterialTheme.colorScheme.primary,
+					)
+				}
+			}
+		},
+	)
+}

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() },
+	)
+}