fmt

Minor changes to Auto-tunnel ui to make starting auto tunnel more intuitive.

Better monitoring of location services and location permission changes to be immediately reflected in network monitor, with warnings displayed on auto tunnel screen if necessary depending on wifi detection method.

Improved detection of when app is backgrounded so we notify user of tunnel errors in notifications vs ui.

Fixes bug where prominent location screen was not showing properly.

.editorconfig

@@ -1,97 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-indent_size = 4
-indent_style = tab
-max_line_length = 150
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[{*.kt,*.kts}]
-ij_continuation_indent_size = 4
-ij_java_names_count_to_use_import_on_demand = 9999
-ij_kotlin_align_in_columns_case_branch = false
-ij_kotlin_align_multiline_binary_operation = false
-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_assignment_wrap = normal
-ij_kotlin_blank_lines_after_class_header = 0
-ij_kotlin_blank_lines_around_block_when_branches = 0
-ij_kotlin_blank_lines_before_declaration_with_comment_or_annotation_on_separate_line = 1
-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_catch_on_new_line = false
-ij_kotlin_continuation_indent_for_chained_calls = true
-ij_kotlin_continuation_indent_for_expression_bodies = true
-ij_kotlin_continuation_indent_in_argument_lists = true
-ij_kotlin_continuation_indent_in_elvis = false
-ij_kotlin_continuation_indent_in_if_conditions = false
-ij_kotlin_continuation_indent_in_parameter_lists = false
-ij_kotlin_continuation_indent_in_supertype_lists = false
-ij_kotlin_else_on_new_line = false
-ij_kotlin_enum_constants_wrap = off
-ij_kotlin_extends_list_wrap = normal
-ij_kotlin_field_annotation_wrap = split_into_lines
-ij_kotlin_finally_on_new_line = false
-ij_kotlin_if_rparen_on_new_line = false
-ij_kotlin_import_nested_classes = false
-ij_kotlin_insert_whitespaces_in_simple_one_line_method = true
-ij_kotlin_keep_blank_lines_before_right_brace = 2
-ij_kotlin_keep_blank_lines_in_code = 2
-ij_kotlin_keep_blank_lines_in_declarations = 2
-ij_kotlin_keep_first_column_comment = true
-ij_kotlin_keep_indents_on_empty_lines = false
-ij_kotlin_keep_line_breaks = true
-ij_kotlin_lbrace_on_next_line = false
-ij_kotlin_line_comment_add_space = false
-ij_kotlin_line_comment_at_first_column = true
-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_name_count_to_use_star_import = 9999
-ij_kotlin_name_count_to_use_star_import_for_members = 9999
-ij_kotlin_parameter_annotation_wrap = off
-ij_kotlin_space_after_comma = true
-ij_kotlin_space_after_extend_colon = true
-ij_kotlin_space_after_type_colon = true
-ij_kotlin_space_before_catch_parentheses = true
-ij_kotlin_space_before_comma = false
-ij_kotlin_space_before_extend_colon = true
-ij_kotlin_space_before_for_parentheses = true
-ij_kotlin_space_before_if_parentheses = true
-ij_kotlin_space_before_lambda_arrow = true
-ij_kotlin_space_before_type_colon = false
-ij_kotlin_space_before_when_parentheses = true
-ij_kotlin_space_before_while_parentheses = true
-ij_kotlin_spaces_around_additive_operators = true
-ij_kotlin_spaces_around_assignment_operators = true
-ij_kotlin_spaces_around_equality_operators = true
-ij_kotlin_spaces_around_function_type_arrow = true
-ij_kotlin_spaces_around_logical_operators = true
-ij_kotlin_spaces_around_multiplicative_operators = true
-ij_kotlin_spaces_around_range = false
-ij_kotlin_spaces_around_relational_operators = true
-ij_kotlin_spaces_around_unary_operator = false
-ij_kotlin_spaces_around_when_arrow = true
-ij_kotlin_variable_annotation_wrap = off
-ij_kotlin_while_on_new_line = false
-ij_kotlin_wrap_elvis_expressions = 1
-ij_kotlin_wrap_expression_body_functions = 1
-ij_kotlin_wrap_first_method_in_call_chain = false
-#compose
-ktlint_standard_filename = disabled
-ktlint_standard_no-wildcard-imports = disabled
-ktlint_standard_function-naming = disabled
-ktlint_standard_property-naming = disabled
-ktlint_standard_package-naming = disabled
-ktlint_function_naming_ignore_when_annotated_with = Composable
-ktlint_code_style = android_studio
-ktlint_standard_import-ordering = disabled
-ktlint_standard_package-naming = disabled
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true

.github/workflows/build.yml

@@ -1,4 +1,7 @@
 name: build
+permissions:
+  contents: read
+
 on:
   workflow_dispatch:
     inputs:
@@ -9,9 +12,16 @@ on:
         default: debug
         options:
           - debug
-          - prerelease
           - nightly
           - release
+      flavor:
+        type: choice
+        description: "Product flavor"
+        required: true
+        default: fdroid
+        options:
+          - fdroid
+          - standalone
     secrets:
       SIGNING_KEY_ALIAS:
         required: false
@@ -30,6 +40,11 @@ on:
         description: "Build type"
         required: true
         default: debug
+      flavor:
+        type: string
+        description: "Product flavor"
+        required: false
+        default: fdroid
     secrets:
       SIGNING_KEY_ALIAS:
         required: false
@@ -41,6 +56,7 @@ on:
         required: false
       KEYSTORE:
         required: false
+
 env:
   UPLOAD_DIR_ANDROID: android_artifacts
 
@@ -57,6 +73,8 @@ jobs:
       UPLOAD_DIR_ANDROID: ${{ env.UPLOAD_DIR_ANDROID }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - name: Set up JDK 17
         uses: actions/setup-java@v4
         with:
@@ -65,9 +83,6 @@ jobs:
           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
@@ -75,51 +90,34 @@ jobs:
           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
         if: ${{ inputs.build_type != 'debug' }}
         run: |
           store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
           echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
 
-      - name: Create service_account.json
-        if: ${{ inputs.build_type != 'debug' }}
-        id: createServiceAccount
-        run: echo '${{ secrets.ANDROID_SERVICE_ACCOUNT_JSON }}' > service_account.json
-
-      - name: Build Fdroid Release APK
-        if: ${{ inputs.build_type == 'release' }}
-        run: ./gradlew :app:assembleFdroidRelease --info
-
-      - name: Build Fdroid Prerelease APK
-        if: ${{ inputs.build_type == 'prerelease' }}
-        run: ./gradlew :app:assembleFdroidPrerelease --info
-
-      - name: Build Fdroid Nightly APK
-        if: ${{ inputs.build_type == 'nightly' }}
-        run: ./gradlew :app:assembleFdroidNightly --info
-
-      - name: Build Debug APK
-        if: ${{ inputs.build_type == 'debug' }}
-        run: ./gradlew :app:assembleFdroidDebug --stacktrace
-
-      # bump versionCode for nightly and prerelease builds
-      - name: Commit and push versionCode changes
-        if: ${{ inputs.build_type == 'nightly' || inputs.build_type == 'prerelease' }}
+      - name: Build APK
         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"
-
+          flavor=${{ inputs.flavor }}
+          build_type=${{ inputs.build_type }}
+          case $build_type in
+            "release")
+              ./gradlew :app:assemble${flavor^}Release --info
+              ;;
+            "nightly")
+              ./gradlew :app:assemble${flavor^}Nightly --info
+              ;;
+            "debug")
+              ./gradlew :app:assemble${flavor^}Debug --stacktrace
+              ;;
+          esac
       - name: Get release apk path
         id: apk-path
-        run: echo "path=$(find . -regex '^.*/build/outputs/apk/fdroid/${{ inputs.build_type }}/.*\.apk$' -type f | head -1 | tail -c+2)" >> $GITHUB_OUTPUT
-
-      - name: Upload release apk
+        run: echo "path=$(find . -regex '^.*/build/outputs/apk/${{ inputs.flavor }}/${{ inputs.build_type }}/.*\.apk$' -type f | head -1 | tail -c+2)" >> $GITHUB_OUTPUT
+      - name: Upload APK
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ env.UPLOAD_DIR_ANDROID }}
-          path: ${{github.workspace}}/${{ steps.apk-path.outputs.path }}
+          name: android_artifacts_${{ inputs.flavor }}
+          path: app/build/outputs/apk/${{ inputs.flavor }}/${{ inputs.build_type  }}/wgtunnel-${{ inputs.flavor }}${{ inputs.flavor == 'fdroid' && '-release' || '' }}-*.apk
           retention-days: 1
+          if-no-files-found: warn

.github/workflows/nightly.yml

@@ -0,0 +1,127 @@
+name: nightly
+permissions:
+  contents: write
+  packages: write
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "4 3 * * *"
+
+jobs:
+  check_commits:
+    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@v4
+      - name: Check for new commits
+        id: check
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          NEW_COMMITS=$(git rev-list --count --after="$(date -Iseconds -d '23 hours ago')" ${{ github.sha }})
+          echo "new_commits=$NEW_COMMITS" >> $GITHUB_OUTPUT
+
+  build-standalone-nightly:
+    uses: ./.github/workflows/build.yml
+    secrets: inherit
+    with:
+      build_type: "nightly"
+      flavor: standalone
+
+  publish:
+    needs:
+      - check_commits
+      - build-standalone-nightly
+    if: ${{ needs.check_commits.outputs.has_new_commits > 0 && inputs.release_type != 'none' }}
+    name: publish-nightly
+    runs-on: ubuntu-latest
+    steps:
+
+      - uses: actions/checkout@v4
+
+      - name: Install system dependencies
+        run: |
+          sudo apt update && sudo apt install -y gh apksigner
+      - name: Set latest tag
+        uses: rickstaa/action-create-tag@v1
+        id: tag_creation
+        with:
+          tag: "latest"
+          message: "Automated tag for HEAD commit"
+          force_push_tag: true
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          tag_exists_error: false
+
+      - name: Generate Changelog
+        id: changelog
+        uses: requarks/changelog-action@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          toTag: "nightly"
+          fromTag: "latest"
+          writeToFile: false
+
+      - name: Make download dir
+        run: mkdir ${{ github.workspace }}/temp
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: android_artifacts_*
+          path: ${{ github.workspace }}/temp
+
+      - name: Set release notes
+        run: |
+          echo "RELEASE_NOTES=Nightly build for the latest development version of the app." >> $GITHUB_ENV
+
+      - name: Delete previous nightly version
+        uses: ClementTsang/delete-tag-and-release@v0.4.0
+        with:
+          tag_name: "nightly"
+          delete_release: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Get checksum
+        id: checksum
+        run: |
+          file_path=$(find ${{ github.workspace }}/temp -type f -iname "*.apk" | head -n 1)
+          if [ -z "$file_path" ]; then
+            echo "No APK file found"
+            exit 1
+          fi
+          checksum=$(apksigner verify --print-certs "$file_path" | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")
+          echo "checksum=$checksum" >> $GITHUB_OUTPUT
+
+      - name: Create nightly release
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        with:
+          body: |
+            ${{ env.RELEASE_NOTES }}
+
+            SHA-256 fingerprints for the 4096-bit signing certificate:
+            ```sh
+            ${{ steps.checksum.outputs.checksum }}
+            ```
+
+            To verify fingerprint:
+            ```sh
+            apksigner verify --print-certs [path to APK file] | grep SHA-256
+            ```
+
+            ### Changelog
+            ${{ steps.changelog.outputs.changes }}
+          tag_name: nightly
+          name: nightly
+          draft: false
+          prerelease: true
+          make_latest: false
+          files: |
+            ${{ github.workspace }}/temp/**/*.apk
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/on-issue.yml

@@ -1,20 +0,0 @@
-name: on-issue
-
-on:
-  issues:
-    types: [ opened, closed, reopened ]
-
-
-jobs:
-
-  on-issue:
-    name: On new issue
-    runs-on: ubuntu-latest
-    steps:
-      - name: Send Telegram Message
-        run: |
-          msg_text='${{ github.actor }} updated an issue:
-            status: ${{ github.event.issue.state }} - #${{ github.event.issue.number }} ${{ github.event.issue.title }}
-            https://github.com/zaneschepke/wgtunnel/issues/${{ github.event.issue.number }}'
-          curl -s -X POST 'https://api.telegram.org/bot${{ secrets.TELEGRAM_TOKEN }}/sendMessage' \
-          -d "chat_id=${{ secrets.TELEGRAM_TO }}&text=${msg_text}&message_thread_id=${{ secrets.TELEGRAM_TOPIC }}"

.github/workflows/on-publish.yml

@@ -1,21 +0,0 @@
-name: on-publish
-
-on:
-  release:
-    types: [ published ]
-
-
-jobs:
-
-  on-publish:
-    name: On publish
-    runs-on: ubuntu-latest
-    steps:
-      - name: Send Telegram Message
-        run: |
-          msg_text='${{ github.actor }} published a new release:
-            Release: ${{ github.event.release.tag_name }}
-            ${{ github.event.release.body }}
-            https://github.com/zaneschepke/wgtunnel/releases/tag/${{ github.event.release.tag_name }}'
-          curl -s -X POST 'https://api.telegram.org/bot${{ secrets.TELEGRAM_TOKEN }}/sendMessage' \
-          -d "chat_id=${{ secrets.TELEGRAM_TO }}&text=${msg_text}&message_thread_id=${{ secrets.TELEGRAM_TOPIC }}"

.github/workflows/pr.yml

@@ -1,4 +1,6 @@
 name: on-pr
+permissions:
+  contents: read
 
 on:
     workflow_dispatch:
@@ -19,5 +21,5 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 
-      - name: Run ktlint
-        run: ./gradlew ktlintCheck
+      - name: Run ktfmt
+        run: ./gradlew ktfmtCheck

.github/workflows/publish.yml

@@ -1,13 +1,17 @@
 name: publish
+permissions:
+  contents: write
+  packages: write
 
 on:
-  schedule:
-  - cron: "4 3 * * *"
+  push:
+    tags:
+      - '[0-9]*.[0-9]*.[0-9]*'
   workflow_dispatch:
     inputs:
       track:
         type: choice
-        description: "Google play release track"
+        description: "Google Play release track"
         options:
           - none
           - internal
@@ -21,77 +25,69 @@ on:
         description: "GitHub release type"
         options:
           - none
-          - prerelease
-          - nightly
           - release
         default: release
         required: true
       tag_name:
         description: "Tag name for release"
         required: false
-        default: nightly
+        default: 1.1.1
+      flavor:
+        type: choice
+        description: "Product flavor"
+        required: true
+        default: standalone
+        options:
+          - fdroid
+          - standalone
   workflow_call:
-env:
-  UPLOAD_DIR_ANDROID: android_artifacts
+    inputs:
+      flavor:
+        type: string
+        description: "Product flavor"
+        required: false
+        default: standalone
 
 jobs:
-  check_commits:
-    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:
-    if: ${{ inputs.release_type != 'none' }}
+  build-fdroid:
+    if: ${{ github.event_name == 'push' || inputs.release_type == 'release' || inputs.flavor == 'fdroid' }}
     uses: ./.github/workflows/build.yml
     secrets: inherit
     with:
-      build_type: ${{ inputs.release_type == '' && 'nightly' || inputs.release_type }}
+      build_type: ${{ github.event_name == 'push' && 'release' || inputs.release_type }}
+      flavor: fdroid
+
+  build-standalone:
+    if: ${{ github.event_name == 'push' || inputs.release_type == 'release' || inputs.release_type == 'debug' || inputs.flavor == 'standalone' }}
+    uses: ./.github/workflows/build.yml
+    secrets: inherit
+    with:
+      build_type: ${{ github.event_name == 'push' && 'release' || inputs.release_type }}
+      flavor: standalone
 
   publish:
     needs:
-      - check_commits
-      - build
-    if: ${{ needs.check_commits.outputs.has_new_commits > 0 && inputs.release_type != 'none' }}
+      - build-standalone
     name: publish-github
     runs-on: ubuntu-latest
-    env:
-      GH_USER: ${{ secrets.GH_USER }}
-      # GH needed for gh cli
-      GH_TOKEN: ${{ secrets.GH_TOKEN }}
-      GH_REPO: ${{ github.repository }}
-
     steps:
       - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event_name == 'push' && github.ref || 'main' }}
       - name: Install system dependencies
         run: |
           sudo apt update && sudo apt install -y gh apksigner
 
-      # update latest tag
       - name: Set latest tag
         uses: rickstaa/action-create-tag@v1
         id: tag_creation
         with:
-          tag: "latest"  # or any tag name you wish to use
+          tag: "latest"
           message: "Automated tag for HEAD commit"
           force_push_tag: true
+          github_token: ${{ secrets.GITHUB_TOKEN }}
           tag_exists_error: false
-
       - name: Get latest release
         id: latest_release
         uses: kaliber5/action-get-release@v1
@@ -104,22 +100,9 @@ jobs:
         uses: requarks/changelog-action@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
-          toTag: ${{ github.event_name == 'schedule' && 'nightly' || steps.latest_release.outputs.tag_name }}
+          toTag: ${{ steps.latest_release.outputs.tag_name }}
           fromTag: "latest"
-          writeToFile: false  # we won't write to file, just output
-
-      - 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: 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 }}
+          writeToFile: false
 
       - name: Make download dir
         run: mkdir ${{ github.workspace }}/temp
@@ -127,53 +110,38 @@ jobs:
       - name: Download artifacts
         uses: actions/download-artifact@v4
         with:
-          name: ${{ env.UPLOAD_DIR_ANDROID }}
+          pattern: android_artifacts_*
           path: ${{ github.workspace }}/temp
-
-      # 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
+          merge-multiple: true
 
       - name: Set version release notes
-        if: ${{ inputs.release_type == 'release' }}
+        if: ${{ github.event_name == 'push' || inputs.release_type == 'release' }}
         run: |
-          RELEASE_NOTES="$(cat ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt)"
+          VERSION_NAME=$(grep "const val VERSION_NAME" buildSrc/src/main/kotlin/Constants.kt | awk -F'"' '{print $2}')
+          RELEASE_NOTES="$(cat ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${VERSION_NAME}.txt || echo "No changelog found for ${VERSION_NAME}")"
           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: |
-          file_path=$(find ${{ github.workspace }}/temp -type f -iname "*.apk" | tail -n1)
-          echo "checksum=$(apksigner verify -print-certs $file_path | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
+          file_path=$(find ${{ github.workspace }}/temp -type f -iname "*.apk" | head -n 1)
+          if [ -z "$file_path" ]; then
+            echo "No APK file found"
+            exit 1
+          fi
+          checksum=$(apksigner verify --print-certs "$file_path" | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")
+          echo "checksum=$checksum" >> $GITHUB_OUTPUT
 
-
-      - name: Create Release with Fastlane changelog notes
+      - name: Create Release
         id: create_release
         uses: softprops/action-gh-release@v2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           body: |
             ${{ env.RELEASE_NOTES }}
 
-            SHA-256 fingerprint for the 4096-bit signing certificate:
+            SHA-256 fingerprints for the 4096-bit signing certificate:
             ```sh
             ${{ steps.checksum.outputs.checksum }}
             ```
@@ -185,29 +153,31 @@ jobs:
 
             ### Changelog
             ${{ steps.changelog.outputs.changes }}
-          tag_name: ${{ env.TAG_NAME }}
-          name: ${{ env.TAG_NAME }}
+          tag_name: ${{ github.event_name == 'push' && github.ref_name || github.event.inputs.tag_name }}
+          name: ${{ github.event_name == 'push' && github.ref_name || github.event.inputs.tag_name }}
           draft: false
-          prerelease: ${{ inputs.release_type == 'prerelease' || inputs.release_type == '' || inputs.release_type == 'nightly' }}
-          make_latest: ${{ inputs.release_type == 'release' }}
+          prerelease: false
+          make_latest: true
           files: |
-            ${{ github.workspace }}/temp/*
+            ${{ github.workspace }}/temp/**/*.apk
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-  publish-fdroid:
+  publish-fdroid-public:
     runs-on: ubuntu-latest
     needs:
-      - build
-    if: inputs.release_type == 'release'
+      - build-fdroid
+    if: ${{ github.event_name == 'push' || inputs.release_type == 'release' }}
     steps:
       - name: Dispatch update for fdroid repo
         uses: peter-evans/repository-dispatch@v3
         with:
-          token: ${{ secrets.PAT }}
-          repository: zaneschepke/fdroid
+          token: ${{ secrets.GITHUB_TOKEN }}
+          repository: wgtunnel/fdroid
           event-type: fdroid-update
 
   publish-play:
-    if: ${{ inputs.track != 'none' && inputs.track != '' }}
+    if: ${{ github.event_name == 'push' || inputs.track != 'none' }}
     name: Publish to Google Play
     runs-on: ubuntu-latest
 
@@ -217,8 +187,6 @@ jobs:
       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
@@ -259,5 +227,6 @@ jobs:
           bundler-cache: true
 
       - name: Distribute app to Prod track 🚀
-        run: (cd ${{ github.workspace }} && bundle install && bundle exec fastlane ${{ inputs.track }})
-
+        run: |
+          track=${{ github.event_name == 'push' && 'production' || inputs.track }}
+          (cd ${{ github.workspace }} && bundle install && bundle exec fastlane $track)

.gitignore

@@ -70,5 +70,5 @@ lint/tmp/
 app/release/output.json
 .idea/codeStyles/
 # where we keep our signing secrets locally
-app/signing.properties
 /.kotlin/
+/app/keystore/

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 WG Auto Tunnel
+Copyright ©  2023-2025 Zane Schepke
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

app/.gitignore

@@ -1,2 +1,3 @@
 /build
-/release
+/release
+/src/main/assets/licenses.json

app/build.gradle.kts

@@ -1,255 +1,246 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
-	alias(libs.plugins.android.application)
-	alias(libs.plugins.kotlin.android)
-	alias(libs.plugins.hilt.android)
-	alias(libs.plugins.kotlinxSerialization)
-	alias(libs.plugins.ksp)
-	alias(libs.plugins.compose.compiler)
-	alias(libs.plugins.grgit)
-}
-
-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().trim().toInt() + 1
-			} else {
-				1
-			}
-		}
-		else -> 0
-	}
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.hilt.android)
+    alias(libs.plugins.kotlinxSerialization)
+    alias(libs.plugins.ksp)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.grgit)
+    alias(libs.plugins.licensee)
 }
 
 android {
-	namespace = Constants.APP_ID
-	compileSdk = Constants.TARGET_SDK
+    namespace = Constants.APP_ID
+    compileSdk = Constants.TARGET_SDK
 
-	androidResources {
-		generateLocaleConfig = true
-	}
+    androidResources { generateLocaleConfig = true }
 
-	// reproducibility
-	dependenciesInfo {
-		// Disables dependency metadata when building APKs.
-		includeInApk = false
-		// Disables dependency metadata when building Android App Bundles.
-		includeInBundle = false
-	}
+    dependenciesInfo {
+        includeInApk = false
+        includeInBundle = false
+    }
 
-	defaultConfig {
-		applicationId = Constants.APP_ID
-		minSdk = Constants.MIN_SDK
-		targetSdk = Constants.TARGET_SDK
-		versionCode = Constants.VERSION_CODE + versionCodeIncrement
-		versionName = determineVersionName()
+    ksp { arg("room.schemaLocation", "$projectDir/schemas") }
 
-		ksp { arg("room.schemaLocation", "$projectDir/schemas") }
+    defaultConfig {
+        applicationId = Constants.APP_ID
+        minSdk = Constants.MIN_SDK
+        targetSdk = Constants.TARGET_SDK
+        versionCode = computeVersionCode()
+        versionName = computeVersionName()
 
-		sourceSets {
-			getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
-		}
+        sourceSets { getByName("debug").assets.srcDirs(files("$projectDir/schemas")) }
 
-		buildConfigField("String[]", "LANGUAGES", "new String[]{ ${languageList().joinToString(separator = ", ") { "\"$it\"" }} }")
+        val languagesArray = buildLanguagesArray(languageList())
+        buildConfigField("String[]", "LANGUAGES", "new String[]{ $languagesArray }")
 
-		testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-		vectorDrawables { useSupportLibrary = true }
-	}
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        vectorDrawables { useSupportLibrary = true }
+    }
 
-	signingConfigs {
-		create(Constants.RELEASE) {
-			storeFile = getStoreFile()
-			storePassword = getSigningProperty(Constants.STORE_PASS_VAR)
-			keyAlias = getSigningProperty(Constants.KEY_ALIAS_VAR)
-			keyPassword = getSigningProperty(Constants.KEY_PASS_VAR)
-		}
-	}
+    signingConfigs {
+        create(Constants.RELEASE) {
+            storeFile = file(System.getenv("KEY_STORE_PATH") ?: "keystore/android_keystore.jks")
+            storePassword =
+                LocalProperties.get("SIGNING_STORE_PASSWORD")
+                    ?: System.getenv("SIGNING_STORE_PASSWORD")
+            keyAlias =
+                LocalProperties.get("SIGNING_KEY_ALIAS") ?: System.getenv("SIGNING_KEY_ALIAS")
+            keyPassword =
+                LocalProperties.get("SIGNING_KEY_PASSWORD") ?: System.getenv("SIGNING_KEY_PASSWORD")
+        }
+    }
 
-	buildTypes {
-		// don't strip
-		packaging.jniLibs.keepDebugSymbols.addAll(
-			listOf("libwg-go.so", "libwg-quick.so", "libwg.so"),
-		)
+    buildTypes {
+        packaging.jniLibs.keepDebugSymbols.addAll(
+            listOf("libwg-go.so", "libwg-quick.so", "libwg.so")
+        )
 
-		release {
-			isDebuggable = false
-			isMinifyEnabled = true
-			isShrinkResources = true
-			proguardFiles(
-				getDefaultProguardFile("proguard-android-optimize.txt"),
-				"proguard-rules.pro",
-			)
-			signingConfig = signingConfigs.getByName(Constants.RELEASE)
-			resValue("string", "provider", "\"${Constants.APP_NAME}.provider\"")
-		}
-		debug {
-			applicationIdSuffix = ".debug"
-			versionNameSuffix = "-debug"
-			resValue("string", "app_name", "WG Tunnel - Debug")
-			isDebuggable = true
-			resValue("string", "provider", "\"${Constants.APP_NAME}.provider.debug\"")
-		}
+        release {
+            isDebuggable = false
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
+            signingConfig = signingConfigs.getByName(Constants.RELEASE)
+            resValue("string", "provider", "\"${Constants.APP_NAME}.provider\"")
+        }
 
-		create(Constants.PRERELEASE) {
-			initWith(buildTypes.getByName(Constants.RELEASE))
-			applicationIdSuffix = ".prerelease"
-			versionNameSuffix = "-pre"
-			resValue("string", "app_name", "WG Tunnel - Pre")
-			resValue("string", "provider", "\"${Constants.APP_NAME}.provider.pre\"")
-		}
+        debug {
+            applicationIdSuffix = ".debug"
+            resValue("string", "app_name", "WG Tunnel Debug")
+            isDebuggable = true
+            resValue("string", "provider", "\"${Constants.APP_NAME}.provider.debug\"")
+        }
 
-		create(Constants.NIGHTLY) {
-			initWith(buildTypes.getByName(Constants.RELEASE))
-			applicationIdSuffix = ".nightly"
-			versionNameSuffix = "-nightly"
-			resValue("string", "app_name", "WG Tunnel - Nightly")
-			resValue("string", "provider", "\"${Constants.APP_NAME}.provider.nightly\"")
-		}
+        create(Constants.NIGHTLY) {
+            initWith(buildTypes.getByName(Constants.RELEASE))
+            applicationIdSuffix = ".nightly"
+            resValue("string", "app_name", "WG Tunnel Nightly")
+            resValue("string", "provider", "\"${Constants.APP_NAME}.provider.nightly\"")
+        }
+    }
 
-		applicationVariants.all {
-			val variant = this
-			variant.outputs
-				.map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
-				.forEach { output ->
-					val outputFileName =
-						"${Constants.APP_NAME}-${variant.flavorName}-" +
-							"${variant.buildType.name}-${variant.versionName}.apk"
-					output.outputFileName = outputFileName
-				}
-		}
-	}
-	flavorDimensions.add(Constants.TYPE)
-	productFlavors {
-		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}" } }
+    flavorDimensions.add("type")
+    productFlavors {
+        create("fdroid") {
+            dimension = "type"
+            buildConfigField("String", "FLAVOR", "\"fdroid\"")
+        }
+        create("google") {
+            dimension = "type"
+            buildConfigField("String", "FLAVOR", "\"google\"")
+        }
+        create("standalone") {
+            dimension = "type"
+            buildConfigField("String", "FLAVOR", "\"standalone\"")
+        }
+    }
+
+    compileOptions {
+        isCoreLibraryDesugaringEnabled = true
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlin {
+        compilerOptions {
+            jvmTarget = JvmTarget.JVM_17
+            freeCompilerArgs = listOf("-XXLanguage:+PropertyParamAnnotationDefaultTargetMode")
+        }
+    }
+
+    buildFeatures {
+        compose = true
+        buildConfig = true
+    }
+    packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
+
+    licensee {
+        Constants.allowedLicenses.forEach { allow(it) }
+        Constants.allowedLicenseUrls.forEach { allowUrl(it) }
+    }
+
+    applicationVariants.all {
+        val variant = this
+        variant.outputs
+            .map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
+            .forEach { output ->
+                val outputFileName =
+                    if (variant.flavorName == "fdroid" && variant.buildType.name == "release") {
+                        "${Constants.APP_NAME}-fdroid-release-${variant.versionName}.apk"
+                    } else {
+                        "${Constants.APP_NAME}-${variant.flavorName}-v${variant.versionName}.apk"
+                    }
+                output.outputFileName = outputFileName
+            }
+    }
 }
 
 dependencies {
-	implementation(project(":logcatter"))
-	implementation(project(":networkmonitor"))
+    implementation(project(":logcatter"))
+    implementation(project(":networkmonitor"))
 
-	implementation(libs.androidx.core.ktx)
-	implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.lifecycle.service)
+    implementation(libs.androidx.activity.compose)
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.compose.ui)
+    implementation(libs.androidx.compose.ui.graphics)
+    implementation(libs.androidx.compose.ui.tooling.preview)
+    implementation(libs.androidx.material3)
+    implementation(libs.androidx.appcompat)
+    implementation(libs.material)
+    implementation(libs.androidx.storage)
 
-	// helpers for implementing LifecycleOwner in a Service
-	implementation(libs.androidx.lifecycle.service)
-	implementation(libs.androidx.activity.compose)
-	implementation(platform(libs.androidx.compose.bom))
-	implementation(libs.androidx.compose.ui)
-	implementation(libs.androidx.compose.ui.graphics)
-	implementation(libs.androidx.compose.ui.tooling.preview)
-	implementation(libs.androidx.material3)
-	implementation(libs.androidx.appcompat)
-	implementation(libs.material)
+    testImplementation(libs.junit)
+    testImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    androidTestImplementation(platform(libs.androidx.compose.bom))
+    androidTestImplementation(libs.androidx.compose.ui.test)
+    androidTestImplementation(libs.androidx.room.testing)
+    debugImplementation(libs.androidx.compose.ui.tooling)
+    debugImplementation(libs.androidx.compose.manifest)
 
-	// test
-	testImplementation(libs.junit)
-	testImplementation(libs.androidx.junit)
-	androidTestImplementation(libs.androidx.junit)
-	androidTestImplementation(libs.androidx.espresso.core)
-	androidTestImplementation(platform(libs.androidx.compose.bom))
-	androidTestImplementation(libs.androidx.compose.ui.test)
-	androidTestImplementation(libs.androidx.room.testing)
-	debugImplementation(libs.androidx.compose.ui.tooling)
-	debugImplementation(libs.androidx.compose.manifest)
+    implementation(libs.tunnel)
+    implementation(libs.amneziawg.android)
+    coreLibraryDesugaring(libs.desugar.jdk.libs)
 
-	// tunnel
-	implementation(libs.tunnel)
-	implementation(libs.amneziawg.android)
-	coreLibraryDesugaring(libs.desugar.jdk.libs)
+    implementation(libs.timber)
 
-	// logging
-	implementation(libs.timber)
+    implementation(libs.androidx.navigation.compose)
+    implementation(libs.androidx.hilt.navigation.compose)
 
-	// compose navigation
-	implementation(libs.androidx.navigation.compose)
-	implementation(libs.androidx.hilt.navigation.compose)
+    implementation(libs.hilt.android)
+    ksp(libs.hilt.android.compiler)
+    ksp(libs.androidx.hilt.compiler)
 
-	// hilt
-	implementation(libs.hilt.android)
-	ksp(libs.hilt.android.compiler)
-	ksp(libs.androidx.hilt.compiler)
+    implementation(libs.accompanist.permissions)
+    implementation(libs.accompanist.drawablepainter)
 
-	// accompanist
-	implementation(libs.accompanist.permissions)
-	implementation(libs.accompanist.drawablepainter)
+    implementation(libs.androidx.room.runtime)
+    ksp(libs.androidx.room.compiler)
+    implementation(libs.androidx.room.ktx)
+    implementation(libs.androidx.datastore.preferences)
 
-	// storage
-	implementation(libs.androidx.room.runtime)
-	ksp(libs.androidx.room.compiler)
-	implementation(libs.androidx.room.ktx)
-	implementation(libs.androidx.datastore.preferences)
+    implementation(libs.lifecycle.runtime.compose)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.lifecycle.process)
 
-	// lifecycle
-	implementation(libs.lifecycle.runtime.compose)
-	implementation(libs.androidx.lifecycle.runtime.ktx)
-	implementation(libs.androidx.lifecycle.process)
+    implementation(libs.kotlinx.serialization.json)
 
-	// icons
-	implementation(libs.material.icons.extended)
-	// serialization
-	implementation(libs.kotlinx.serialization.json)
+    implementation(libs.zxing.android.embedded)
 
-	// barcode scanning
-	implementation(libs.zxing.android.embedded)
+    implementation(libs.material.icons.extended)
 
-	// bio
-	implementation(libs.androidx.biometric.ktx)
-	implementation(libs.pin.lock.compose)
+    implementation(libs.androidx.biometric.ktx)
+    implementation(libs.pin.lock.compose)
 
-	// shortcuts
-	implementation(libs.androidx.core)
+    implementation(libs.androidx.core)
 
-	// splash
-	implementation(libs.androidx.core.splashscreen)
+    implementation(libs.androidx.core.splashscreen)
 
-	// worker
-	implementation(libs.androidx.work.runtime)
-	implementation(libs.androidx.hilt.work)
+    implementation(libs.androidx.work.runtime)
+    implementation(libs.androidx.hilt.work)
+
+    implementation(libs.qrose)
+    implementation(libs.semver4j)
+
+    implementation(libs.ktor.client.core)
+    implementation(libs.ktor.client.okhttp)
+    implementation(libs.ktor.client.cio)
+    implementation(libs.ktor.client.content.negotiation)
+    implementation(libs.ktor.serialization.kotlinx.json)
+    implementation(libs.slf4j.android)
+    implementation(libs.icmp4a)
+
+    // shizuku
+    implementation(libs.shizuku.api)
+    implementation(libs.shizuku.provider)
+
+    implementation(libs.reorderable)
 }
 
-fun determineVersionName(): String {
-	return with(getBuildTaskName().lowercase()) {
-		when {
-			contains(Constants.NIGHTLY) || contains(Constants.PRERELEASE) ->
-				Constants.VERSION_NAME +
-					"-${grgitService.service.get().grgit.head().abbreviatedId}"
-			else -> Constants.VERSION_NAME
-		}
-	}
+tasks.register<Copy>("copyLicenseeJsonToAssets") {
+    dependsOn("licensee")
+    val outputAssets = layout.projectDirectory.dir("src/main/assets")
+    from(layout.buildDirectory.file("reports/licensee/androidFdroidRelease/artifacts.json")) {
+        rename("artifacts.json", "licenses.json")
+    }
+    into(outputAssets)
 }
 
-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.named("preBuild") { dependsOn("copyLicenseeJsonToAssets") }
 
+// https://gist.github.com/obfusk/61046e09cee352ae6dd109911534b12e#fix-proposed-by-linsui-disable-baseline-profiles
 tasks.whenTaskAdded {
-	if (name.startsWith("assemble") && !name.lowercase().contains("debug")) {
-		dependsOn(incrementVersionCode)
-	}
+    if (name.contains("ArtProfile")) {
+        enabled = false
+    }
 }

app/fdroid-rules.pro

@@ -1,42 +0,0 @@
--dontwarn com.google.errorprone.annotations.**
-
--keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
-    <fields>;
-}
-
-# Keep all classes in the org.xbill.DNS package and subpackages
--keep class org.xbill.DNS.** { *; }
--dontwarn org.xbill.DNS.**
-
-# Preserve JNA classes if used (e.g., for IPHlpAPI on Windows)
--keep class com.sun.jna.** { *; }
--dontwarn com.sun.jna.**
-
-# Keep DNS resolver configuration classes that might be loaded dynamically
--keep class org.xbill.DNS.config.** { *; }
--dontwarn org.xbill.DNS.config.**
-
--keep class org.xbill.DNS.** { *; }
-
-# Prevent optimization issues with native or reflection-based calls
--dontoptimize
--dontshrink
-# Uncomment the above if errors persist, but use sparingly as they’re broad
-
-# Suppress warnings about missing classes if not all features are used
--dontwarn java.lang.management.**
--dontwarn sun.nio.ch.**
-
--dontwarn com.google.api.client.http.GenericUrl
--dontwarn com.google.api.client.http.HttpHeaders
--dontwarn com.google.api.client.http.HttpRequest
--dontwarn com.google.api.client.http.HttpRequestFactory
--dontwarn com.google.api.client.http.HttpResponse
--dontwarn com.google.api.client.http.HttpTransport
--dontwarn com.google.api.client.http.javanet.NetHttpTransport$Builder
--dontwarn com.google.api.client.http.javanet.NetHttpTransport
--dontwarn javax.lang.model.element.Modifier
--dontwarn org.joda.time.Instant
--dontwarn org.slf4j.impl.StaticLoggerBinder
--dontwarn org.slf4j.impl.StaticMDCBinder
--dontwarn org.slf4j.impl.StaticMarkerBinder

app/proguard-rules.pro

@@ -1,61 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
--keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
-    <fields>;
-}
-
-# Keep all classes in the org.xbill.DNS package and subpackages
--keep class org.xbill.DNS.** { *; }
--dontwarn org.xbill.DNS.**
-
-# Preserve JNA classes if used (e.g., for IPHlpAPI on Windows)
--keep class com.sun.jna.** { *; }
--dontwarn com.sun.jna.**
-
-# Keep DNS resolver configuration classes that might be loaded dynamically
--keep class org.xbill.DNS.config.** { *; }
--dontwarn org.xbill.DNS.config.**
-
--keep class org.xbill.DNS.** { *; }
-
-# Prevent optimization issues with native or reflection-based calls
--dontoptimize
--dontshrink
-# Uncomment the above if errors persist, but use sparingly as they’re broad
-
-# Suppress warnings about missing classes if not all features are used
--dontwarn java.lang.management.**
--dontwarn sun.nio.ch.**
-
--dontwarn com.google.api.client.http.GenericUrl
--dontwarn com.google.api.client.http.HttpHeaders
--dontwarn com.google.api.client.http.HttpRequest
--dontwarn com.google.api.client.http.HttpRequestFactory
--dontwarn com.google.api.client.http.HttpResponse
--dontwarn com.google.api.client.http.HttpTransport
--dontwarn com.google.api.client.http.javanet.NetHttpTransport$Builder
--dontwarn com.google.api.client.http.javanet.NetHttpTransport
--dontwarn javax.lang.model.element.Modifier
--dontwarn org.joda.time.Instant
--dontwarn org.slf4j.impl.StaticLoggerBinder
--dontwarn org.slf4j.impl.StaticMDCBinder
--dontwarn org.slf4j.impl.StaticMarkerBinder

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

@@ -155,9 +155,7 @@
           "columnNames": [
             "id"
           ]
-        },
-        "indices": [],
-        "foreignKeys": []
+        }
       },
       {
         "tableName": "TunnelConfig",
@@ -227,21 +225,18 @@
             "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"
           },
           {
@@ -275,11 +270,9 @@
             "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, 'ae51793c4d09ea3194ecd26f0606f35c')"

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

@@ -0,0 +1,295 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 17,
+    "identityHash": "380d82359c99933cc9ce783347c4ec31",
+    "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_stop_on_no_internet_enabled` INTEGER NOT NULL DEFAULT false, `is_vpn_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_lan_on_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `debounce_delay_seconds` INTEGER NOT NULL DEFAULT 3, `is_disable_kill_switch_on_trusted_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_unsecure_enabled` INTEGER NOT NULL DEFAULT false, `split_tunnel_apps` TEXT NOT NULL DEFAULT '', `wifi_detection_method` INTEGER NOT NULL DEFAULT 0)",
+        "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": "isStopOnNoInternetEnabled",
+            "columnName": "is_stop_on_no_internet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isVpnKillSwitchEnabled",
+            "columnName": "is_vpn_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelKillSwitchEnabled",
+            "columnName": "is_kernel_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isLanOnKillSwitchEnabled",
+            "columnName": "is_lan_on_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "debounceDelaySeconds",
+            "columnName": "debounce_delay_seconds",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "isDisableKillSwitchOnTrustedEnabled",
+            "columnName": "is_disable_kill_switch_on_trusted_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnUnsecureEnabled",
+            "columnName": "is_tunnel_on_unsecure_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "splitTunnelApps",
+            "columnName": "split_tunnel_apps",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "wifiDetectionMethod",
+            "columnName": "wifi_detection_method",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "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, `is_ethernet_tunnel` INTEGER NOT NULL DEFAULT false, `is_ipv4_preferred` INTEGER NOT NULL DEFAULT true)",
+        "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",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingCooldown",
+            "columnName": "ping_cooldown",
+            "affinity": "INTEGER",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingIp",
+            "columnName": "ping_ip",
+            "affinity": "TEXT",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "isEthernetTunnel",
+            "columnName": "is_ethernet_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isIpv4Preferred",
+            "columnName": "is_ipv4_preferred",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ]
+      }
+    ],
+    "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, '380d82359c99933cc9ce783347c4ec31')"
+    ]
+  }
+}

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

@@ -0,0 +1,302 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 18,
+    "identityHash": "505728bad740c12bab998a066b569333",
+    "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_stop_on_no_internet_enabled` INTEGER NOT NULL DEFAULT false, `is_vpn_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_lan_on_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `debounce_delay_seconds` INTEGER NOT NULL DEFAULT 3, `is_disable_kill_switch_on_trusted_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_unsecure_enabled` INTEGER NOT NULL DEFAULT false, `split_tunnel_apps` TEXT NOT NULL DEFAULT '', `wifi_detection_method` INTEGER NOT NULL DEFAULT 0)",
+        "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": "isStopOnNoInternetEnabled",
+            "columnName": "is_stop_on_no_internet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isVpnKillSwitchEnabled",
+            "columnName": "is_vpn_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelKillSwitchEnabled",
+            "columnName": "is_kernel_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isLanOnKillSwitchEnabled",
+            "columnName": "is_lan_on_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "debounceDelaySeconds",
+            "columnName": "debounce_delay_seconds",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "isDisableKillSwitchOnTrustedEnabled",
+            "columnName": "is_disable_kill_switch_on_trusted_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnUnsecureEnabled",
+            "columnName": "is_tunnel_on_unsecure_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "splitTunnelApps",
+            "columnName": "split_tunnel_apps",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "''"
+          },
+          {
+            "fieldPath": "wifiDetectionMethod",
+            "columnName": "wifi_detection_method",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "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, `is_ethernet_tunnel` INTEGER NOT NULL DEFAULT false, `is_ipv4_preferred` INTEGER NOT NULL DEFAULT true, `position` INTEGER NOT NULL DEFAULT 0)",
+        "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",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingCooldown",
+            "columnName": "ping_cooldown",
+            "affinity": "INTEGER",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "pingIp",
+            "columnName": "ping_ip",
+            "affinity": "TEXT",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "isEthernetTunnel",
+            "columnName": "is_ethernet_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isIpv4Preferred",
+            "columnName": "is_ipv4_preferred",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          },
+          {
+            "fieldPath": "position",
+            "columnName": "position",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "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`)"
+          }
+        ]
+      }
+    ],
+    "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, '505728bad740c12bab998a066b569333')"
+    ]
+  }
+}

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

@@ -0,0 +1,316 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 19,
+    "identityHash": "82bdb96b7a9f8695a34ad1ec21d9aea8",
+    "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_stop_on_no_internet_enabled` INTEGER NOT NULL DEFAULT false, `is_vpn_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `is_lan_on_kill_switch_enabled` INTEGER NOT NULL DEFAULT false, `debounce_delay_seconds` INTEGER NOT NULL DEFAULT 3, `is_disable_kill_switch_on_trusted_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_unsecure_enabled` INTEGER NOT NULL DEFAULT false, `wifi_detection_method` INTEGER NOT NULL DEFAULT 0, `is_ping_monitoring_enabled` INTEGER NOT NULL DEFAULT true, `tunnel_ping_interval_sec` INTEGER NOT NULL DEFAULT 30, `tunnel_ping_attempts` INTEGER NOT NULL DEFAULT 3, `tunnel_ping_timeout_sec` INTEGER)",
+        "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": "isStopOnNoInternetEnabled",
+            "columnName": "is_stop_on_no_internet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isVpnKillSwitchEnabled",
+            "columnName": "is_vpn_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelKillSwitchEnabled",
+            "columnName": "is_kernel_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isLanOnKillSwitchEnabled",
+            "columnName": "is_lan_on_kill_switch_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "debounceDelaySeconds",
+            "columnName": "debounce_delay_seconds",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "isDisableKillSwitchOnTrustedEnabled",
+            "columnName": "is_disable_kill_switch_on_trusted_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnUnsecureEnabled",
+            "columnName": "is_tunnel_on_unsecure_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "wifiDetectionMethod",
+            "columnName": "wifi_detection_method",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          },
+          {
+            "fieldPath": "isPingMonitoringEnabled",
+            "columnName": "is_ping_monitoring_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          },
+          {
+            "fieldPath": "tunnelPingIntervalSeconds",
+            "columnName": "tunnel_ping_interval_sec",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "30"
+          },
+          {
+            "fieldPath": "tunnelPingAttempts",
+            "columnName": "tunnel_ping_attempts",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "3"
+          },
+          {
+            "fieldPath": "tunnelPingTimeoutSeconds",
+            "columnName": "tunnel_ping_timeout_sec",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "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, `restart_on_ping_failure` INTEGER NOT NULL DEFAULT false, `ping_target` TEXT DEFAULT null, `is_ethernet_tunnel` INTEGER NOT NULL DEFAULT false, `is_ipv4_preferred` INTEGER NOT NULL DEFAULT true, `position` INTEGER NOT NULL DEFAULT 0, `auto_tunnel_apps` TEXT NOT NULL DEFAULT '[]')",
+        "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": "restartOnPingFailure",
+            "columnName": "restart_on_ping_failure",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "pingTarget",
+            "columnName": "ping_target",
+            "affinity": "TEXT",
+            "defaultValue": "null"
+          },
+          {
+            "fieldPath": "isEthernetTunnel",
+            "columnName": "is_ethernet_tunnel",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isIpv4Preferred",
+            "columnName": "is_ipv4_preferred",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "true"
+          },
+          {
+            "fieldPath": "position",
+            "columnName": "position",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          },
+          {
+            "fieldPath": "autoTunnelApps",
+            "columnName": "auto_tunnel_apps",
+            "affinity": "TEXT",
+            "notNull": true,
+            "defaultValue": "'[]'"
+          }
+        ],
+        "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`)"
+          }
+        ]
+      }
+    ],
+    "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, '82bdb96b7a9f8695a34ad1ec21d9aea8')"
+    ]
+  }
+}

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

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

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

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

app/src/debug/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#648DB3</color>
+</resources>

app/src/main/AndroidManifest.xml

@@ -2,7 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
-    <uses-permission android:name="android.permission.INTERNET" />
+	<uses-permission android:name="android.permission.INTERNET" />
 	<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <!--foreground service exempt android 14-->
@@ -12,14 +12,14 @@
 
     <!--foreground service permissions-->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
     <!--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:label="@string/app_permission_title"
+		android:description="@string/app_permission_description"
 		android:icon="@mipmap/ic_launcher"
 		android:protectionLevel="dangerous" />
 
@@ -45,12 +45,13 @@
     <queries>
         <intent>
             <action android:name="android.intent.action.MAIN" />
+			<category android:name="android.intent.category.LAUNCHER" />
         </intent>
     </queries>
     <application
         android:name=".WireGuardAutoTunnel"
         android:allowBackup="false"
-        android:banner="@drawable/ic_banner"
+        android:banner="@mipmap/ic_banner"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:enableOnBackInvokedCallback="true"
         android:fullBackupContent="@xml/backup_rules"
@@ -60,10 +61,14 @@
         android:supportsRtl="true"
         android:theme="@style/Theme.App.Start"
         tools:targetApi="tiramisu">
+		<activity
+			android:name="com.journeyapps.barcodescanner.CaptureActivity"
+			android:screenOrientation="portrait"
+			tools:replace="screenOrientation" />
         <activity
             android:name=".MainActivity"
             android:exported="true"
-			android:windowSoftInputMode="adjustResize"
+			android:windowSoftInputMode="adjustNothing"
             android:theme="@style/Theme.WireguardAutoTunnel"
 			android:configChanges="orientation|screenSize|keyboardHidden"
 			>
@@ -76,15 +81,11 @@
                 <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
             </intent-filter>
         </activity>
-        <activity
-            android:name="com.journeyapps.barcodescanner.CaptureActivity"
-            android:screenOrientation="portrait"
-            tools:replace="screenOrientation" />
 
         <activity
             android:name=".core.shortcut.ShortcutsActivity"
             android:enabled="true"
-            android:exported="true"
+            android:exported="false"
 			android:noHistory="true"
 			android:excludeFromRecents="true"
 			android:finishOnTaskLaunch="true"
@@ -111,7 +112,7 @@
         <service
             android:name=".core.service.tile.TunnelControlTile"
             android:exported="true"
-            android:icon="@drawable/ic_launcher"
+            android:icon="@drawable/ic_notification"
             android:label="@string/tunnel_control"
             android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
             <meta-data
@@ -128,7 +129,7 @@
         <service
             android:name=".core.service.tile.AutoTunnelControlTile"
             android:exported="true"
-            android:icon="@drawable/ic_launcher"
+            android:icon="@drawable/ic_notification"
             android:label="@string/auto_tunnel"
             android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
             <meta-data
@@ -161,13 +162,11 @@
 				<action android:name="android.net.VpnService" />
 			</intent-filter>
 		</service>
-
         <receiver
             android:name=".core.broadcast.RestartReceiver"
             android:enabled="true"
-            android:exported="true">
+            android:exported="false">
             <intent-filter>
-                <category android:name="android.intent.category.DEFAULT" />
                 <action android:name="android.intent.action.BOOT_COMPLETED" />
                 <action android:name="android.intent.action.QUICKBOOT_POWERON" />
                 <action android:name="com.htc.intent.action.QUICKBOOT_POWERON" />
@@ -182,6 +181,20 @@
 				<action android:name="com.wireguard.android.action.REFRESH_TUNNEL_STATES" />
 			</intent-filter>
 		</receiver>
+		<!--custom security solution for easier user integration-->
+		<receiver
+			android:name=".core.broadcast.RemoteControlReceiver"
+			android:enabled="true"
+			android:exported="true" tools:ignore="ExportedReceiver">
+			<intent-filter>
+				<action android:name="com.zaneschepke.wireguardautotunnel.START_TUNNEL" />
+				<action android:name="com.zaneschepke.wireguardautotunnel.STOP_TUNNEL" />
+				<action android:name="com.zaneschepke.wireguardautotunnel.START_AUTO_TUNNEL" />
+				<action android:name="com.zaneschepke.wireguardautotunnel.STOP_AUTO_TUNNEL" />
+				<action android:name="com.zaneschepke.wireguardautotunnel.START_KILL_SWITCH" />
+				<action android:name="com.zaneschepke.wireguardautotunnel.STOP_KILL_SWITCH" />
+			</intent-filter>
+		</receiver>
 		<receiver
 			android:name=".core.broadcast.NotificationActionReceiver"
 			android:exported="false"

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

@@ -1,277 +1,341 @@
 package com.zaneschepke.wireguardautotunnel
 
-import android.Manifest
+import android.annotation.SuppressLint
 import android.content.Intent
-import android.content.pm.PackageManager
 import android.graphics.Color
 import android.os.Build
 import android.os.Bundle
+import android.provider.Settings
 import androidx.activity.SystemBarStyle
-import androidx.activity.compose.BackHandler
+import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.activity.result.ActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
-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.SnackbarHost
-import androidx.compose.material3.surfaceColorAtElevation
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.unit.dp
-import androidx.core.content.ContextCompat
+import androidx.core.net.toUri
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
+import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.toRoute
 import com.zaneschepke.networkmonitor.NetworkMonitor
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
 import com.zaneschepke.wireguardautotunnel.ui.Route
-import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
-import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavItem
-import com.zaneschepke.wireguardautotunnel.ui.common.navigation.LocalNavController
+import com.zaneschepke.wireguardautotunnel.ui.common.dialog.VpnDeniedDialog
 import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.CustomSnackBar
-import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.SnackbarController
-import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.SnackbarControllerProvider
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalIsAndroidTV
+import com.zaneschepke.wireguardautotunnel.ui.navigation.LocalNavController
+import com.zaneschepke.wireguardautotunnel.ui.navigation.components.BottomNavbar
+import com.zaneschepke.wireguardautotunnel.ui.navigation.components.DynamicTopAppBar
+import com.zaneschepke.wireguardautotunnel.ui.navigation.components.currentNavBackStackEntryAsNavBarState
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.AutoTunnelScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.advanced.AutoTunnelAdvancedScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.detection.WifiDetectionMethodScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.autotunnel.disclosure.LocationDisclosureScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.OptionsScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.PinLockScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.ScannerScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.TunnelAutoTunnelScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.autotunnel.TunnelAutoTunnelScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.config.ConfigScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.sort.SortScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.splittunnel.SplitTunnelScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.AppearanceScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.DisplayScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.KillSwitchScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.LanguageScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.LocationDisclosureScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.tunneloptions.TunnelOptionsScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.pin.PinLockScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.autotunnel.AutoTunnelScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.autotunnel.advanced.AdvancedScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.advanced.SettingsAdvancedScreen
+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.killswitch.KillSwitchScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.logs.LogsScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.settings.monitoring.TunnelMonitoringScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.support.logs.LogsScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.license.LicenseScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import com.zaneschepke.wireguardautotunnel.viewmodel.AppViewModel
 import com.zaneschepke.wireguardautotunnel.viewmodel.event.AppEvent
 import dagger.hilt.android.AndroidEntryPoint
-import timber.log.Timber
 import javax.inject.Inject
 import kotlin.system.exitProcess
+import org.amnezia.awg.backend.GoBackend.VpnService
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
 
-	@Inject
-	lateinit var appStateRepository: AppStateRepository
+    @Inject lateinit var appStateRepository: AppStateRepository
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	@Inject
-	lateinit var networkMonitor: NetworkMonitor
+    @Inject lateinit var networkMonitor: NetworkMonitor
 
-	private var lastLocationPermissionState: Boolean? = null
+    private var lastLocationPermissionState: Boolean? = null
 
-	override fun onCreate(savedInstanceState: Bundle?) {
-		enableEdgeToEdge(
-			statusBarStyle = SystemBarStyle.Companion.auto(Color.TRANSPARENT, Color.TRANSPARENT),
-			navigationBarStyle = SystemBarStyle.Companion.auto(Color.TRANSPARENT, Color.TRANSPARENT),
-		)
-		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-			window.isNavigationBarContrastEnforced = false
-		}
-		super.onCreate(savedInstanceState)
+    val REQUEST_CODE = 123
 
-		val viewModel by viewModels<AppViewModel>()
+    @SuppressLint("BatteryLife")
+    override fun onCreate(savedInstanceState: Bundle?) {
+        enableEdgeToEdge(
+            statusBarStyle = SystemBarStyle.Companion.auto(Color.TRANSPARENT, Color.TRANSPARENT),
+            navigationBarStyle = SystemBarStyle.Companion.auto(Color.TRANSPARENT, Color.TRANSPARENT),
+        )
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            window.isNavigationBarContrastEnforced = false
+        }
+        super.onCreate(savedInstanceState)
 
-		installSplashScreen().apply {
-			setKeepOnScreenCondition {
-				!viewModel.appState.value.isAppReady
-			}
-		}
+        val viewModel by viewModels<AppViewModel>()
 
-		setContent {
-			val appUiState by viewModel.uiState.collectAsStateWithLifecycle()
-			val appState by viewModel.appState.collectAsStateWithLifecycle()
+        installSplashScreen().apply {
+            setKeepOnScreenCondition { !viewModel.appViewState.value.isAppReady }
+        }
 
-			if (!appState.isAppReady) {
-				Box(modifier = Modifier.fillMaxSize())
-				return@setContent
-			}
+        setContent {
+            val isTv = isRunningOnTv()
+            val appUiState by viewModel.uiState.collectAsStateWithLifecycle()
+            val appViewState by viewModel.appViewState.collectAsStateWithLifecycle()
 
-			val navController = rememberNavController()
-			val snackbarController = SnackbarController.current
+            val navController = rememberNavController()
+            val backStackEntry by navController.currentBackStackEntryAsState()
+            val navBarState by
+                currentNavBackStackEntryAsNavBarState(
+                    navController,
+                    backStackEntry,
+                    viewModel,
+                    appUiState,
+                    appViewState,
+                )
+            val snackbar = remember { SnackbarHostState() }
+            var showVpnPermissionDialog by remember { mutableStateOf(false) }
+            var vpnPermissionDenied by remember { mutableStateOf(false) }
 
-			with(appState) {
-				LaunchedEffect(isConfigChanged) {
-					if (isConfigChanged) {
-						Intent(this@MainActivity, MainActivity::class.java).also {
-							startActivity(it)
-							exitProcess(0)
-						}
-					}
-				}
-				LaunchedEffect(errorMessage) {
-					errorMessage?.let {
-						snackbarController.showMessage(it.asString(this@MainActivity))
-					}
-				}
-				LaunchedEffect(popBackStack) {
-					if (popBackStack) {
-						navController.popBackStack()
-						viewModel.handleEvent(AppEvent.BackStackPopped)
-					}
-				}
-			}
+            val vpnActivity =
+                rememberLauncherForActivityResult(
+                    ActivityResultContracts.StartActivityForResult(),
+                    onResult = {
+                        if (it.resultCode != RESULT_OK) {
+                            showVpnPermissionDialog = true
+                            vpnPermissionDenied = true
+                        } else {
+                            vpnPermissionDenied = false
+                            showVpnPermissionDialog = false
+                        }
+                    },
+                )
 
-			CompositionLocalProvider(LocalNavController provides navController) {
-				SnackbarControllerProvider { host ->
-					WireguardAutoTunnelTheme(theme = appUiState.generalState.theme) {
-						Scaffold(
-							contentWindowInsets = WindowInsets(0),
-							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,
-										),
-									),
-								)
-							},
-						) { padding ->
-							Box(modifier = Modifier.Companion.fillMaxSize().padding(padding)) {
-								NavHost(
-									navController,
-									startDestination = (if (appUiState.generalState.isPinLockEnabled) Route.Lock else Route.Main),
-								) {
-									composable<Route.Main> {
-										MainScreen(appUiState, viewModel)
-									}
-									composable<Route.Settings> {
-										SettingsScreen(appUiState, viewModel)
-									}
-									composable<Route.LocationDisclosure> {
-										LocationDisclosureScreen(appUiState, viewModel)
-									}
-									composable<Route.AutoTunnel> {
-										AutoTunnelScreen(appUiState.appSettings, viewModel)
-									}
-									composable<Route.Appearance> {
-										AppearanceScreen()
-									}
-									composable<Route.Language> {
-										LanguageScreen(appUiState, viewModel)
-									}
-									composable<Route.Display> {
-										DisplayScreen(appUiState, viewModel)
-									}
-									composable<Route.Support> {
-										SupportScreen(appUiState, viewModel)
-									}
-									composable<Route.AutoTunnelAdvanced> {
-										AdvancedScreen(appUiState)
-									}
-									composable<Route.Logs> {
-										LogsScreen()
-									}
-									composable<Route.Config> { backStack ->
-										val args = backStack.toRoute<Route.Config>()
-										val config = appUiState.tunnels.firstOrNull { it.id == args.id }
-										ConfigScreen(config)
-									}
-									composable<Route.TunnelOptions> { backStack ->
-										val args = backStack.toRoute<Route.TunnelOptions>()
-										appUiState.tunnels.firstOrNull { it.id == args.id }?.let { config ->
-											OptionsScreen(config, appUiState, viewModel)
-										}
-									}
-									composable<Route.Lock> {
-										PinLockScreen(viewModel)
-									}
-									composable<Route.Scanner> {
-										ScannerScreen(viewModel)
-									}
-									composable<Route.KillSwitch> {
-										KillSwitchScreen(appUiState, viewModel)
-									}
-									composable<Route.SplitTunnel> {
-										SplitTunnelScreen()
-									}
-									composable<Route.TunnelAutoTunnel> { backStack ->
-										val args = backStack.toRoute<Route.TunnelOptions>()
-										appUiState.tunnels.firstOrNull { it.id == args.id }?.let {
-											TunnelAutoTunnelScreen(it, appUiState.appSettings, viewModel)
-										}
-									}
-								}
-								BackHandler {
-									if (navController.previousBackStackEntry == null || !navController.popBackStack()) {
-										this@MainActivity.finish()
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	override fun onResume() {
-		super.onResume()
-		checkPermissionAndNotify()
-	}
+            LaunchedEffect(appUiState.tunnels) {
+                if (!appViewState.isAppReady) {
+                    viewModel.handleEvent(AppEvent.AppReadyCheck(appUiState.tunnels))
+                }
+            }
 
-	private fun checkPermissionAndNotify() {
-		val hasLocation = ContextCompat.checkSelfPermission(
-			this,
-			Manifest.permission.ACCESS_FINE_LOCATION,
-		) == PackageManager.PERMISSION_GRANTED
-		if (lastLocationPermissionState != hasLocation) {
-			Timber.d("Location permission changed to: $hasLocation")
-			if (hasLocation) {
-				networkMonitor.sendLocationPermissionsGrantedBroadcast()
-			}
-			lastLocationPermissionState = hasLocation
-		}
-	}
+            val batteryActivity =
+                rememberLauncherForActivityResult(
+                    ActivityResultContracts.StartActivityForResult()
+                ) { _: ActivityResult ->
+                    viewModel.handleEvent(AppEvent.SetBatteryOptimizeDisableShown)
+                }
+
+            with(appViewState) {
+                LaunchedEffect(isConfigChanged) {
+                    if (isConfigChanged) {
+                        Intent(this@MainActivity, MainActivity::class.java).also {
+                            startActivity(it)
+                            exitProcess(0)
+                        }
+                    }
+                }
+                LaunchedEffect(errorMessage) {
+                    errorMessage?.let {
+                        snackbar.showSnackbar(it.asString(this@MainActivity))
+                        viewModel.handleEvent(AppEvent.MessageShown)
+                    }
+                }
+                LaunchedEffect(popBackStack) {
+                    if (popBackStack) {
+                        navController.popBackStack()
+                        viewModel.handleEvent(AppEvent.PopBackStack(false))
+                    }
+                }
+                LaunchedEffect(requestVpnPermission) {
+                    if (requestVpnPermission) {
+                        if (!vpnPermissionDenied) {
+                            vpnActivity.launch(VpnService.prepare(this@MainActivity))
+                        } else {
+                            showVpnPermissionDialog = true
+                        }
+                        viewModel.handleEvent(AppEvent.VpnPermissionRequested)
+                    }
+                }
+                LaunchedEffect(requestBatteryPermission) {
+                    if (requestBatteryPermission) {
+                        batteryActivity.launch(
+                            Intent().apply {
+                                action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
+                                data = "package:${this@MainActivity.packageName}".toUri()
+                            }
+                        )
+                    }
+                }
+            }
+
+            CompositionLocalProvider(LocalIsAndroidTV provides isTv) {
+                CompositionLocalProvider(LocalNavController provides navController) {
+                    WireguardAutoTunnelTheme(theme = appUiState.appState.theme) {
+                        VpnDeniedDialog(
+                            showVpnPermissionDialog,
+                            onDismiss = {
+                                showVpnPermissionDialog = false
+                                vpnPermissionDenied = false
+                            },
+                        )
+
+                        Scaffold(
+                            modifier =
+                                Modifier.pointerInput(Unit) {
+                                    detectTapGestures {
+                                        viewModel.handleEvent(AppEvent.ClearSelectedTunnels)
+                                    }
+                                },
+                            snackbarHost = {
+                                SnackbarHost(snackbar) { snackbarData: SnackbarData ->
+                                    CustomSnackBar(
+                                        snackbarData.visuals.message,
+                                        isRtl = false,
+                                        containerColor =
+                                            MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp),
+                                    )
+                                }
+                            },
+                            topBar = { DynamicTopAppBar(navBarState) },
+                            bottomBar = {
+                                AnimatedVisibility(
+                                    visible = navBarState.showBottom,
+                                    enter = slideInVertically(initialOffsetY = { it }),
+                                    exit = slideOutVertically(targetOffsetY = { it }),
+                                ) {
+                                    BottomNavbar(appUiState = appUiState)
+                                }
+                            },
+                        ) { padding ->
+                            Box(
+                                modifier =
+                                    Modifier.fillMaxSize()
+                                        .background(MaterialTheme.colorScheme.surface)
+                                        .padding(padding)
+                                        .consumeWindowInsets(padding)
+                                        .imePadding()
+                            ) {
+                                NavHost(
+                                    navController,
+                                    startDestination =
+                                        (if (appUiState.appState.isPinLockEnabled) Route.Lock
+                                        else Route.Main),
+                                ) {
+                                    composable<Route.Main> {
+                                        MainScreen(appUiState, appViewState, viewModel)
+                                    }
+                                    composable<Route.Settings> {
+                                        SettingsScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.SettingsAdvanced> {
+                                        SettingsAdvancedScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.LocationDisclosure> {
+                                        LocationDisclosureScreen(viewModel)
+                                    }
+                                    composable<Route.AutoTunnel> {
+                                        AutoTunnelScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.Appearance> { AppearanceScreen() }
+                                    composable<Route.Language> {
+                                        LanguageScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.Display> {
+                                        DisplayScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.Support> {
+                                        SupportScreen(appViewModel = viewModel)
+                                    }
+                                    composable<Route.License> { LicenseScreen() }
+                                    composable<Route.AutoTunnelAdvanced> {
+                                        AutoTunnelAdvancedScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.WifiDetectionMethod> {
+                                        WifiDetectionMethodScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.Logs> { LogsScreen(appViewState, viewModel) }
+                                    composable<Route.Config> { backStack ->
+                                        val args = backStack.toRoute<Route.Config>()
+                                        val config =
+                                            appUiState.tunnels.firstOrNull { it.id == args.id }
+                                        ConfigScreen(config, viewModel)
+                                    }
+                                    composable<Route.TunnelOptions> { backStack ->
+                                        val args = backStack.toRoute<Route.TunnelOptions>()
+                                        appUiState.tunnels
+                                            .firstOrNull { it.id == args.id }
+                                            ?.let { config ->
+                                                TunnelOptionsScreen(
+                                                    config,
+                                                    viewModel,
+                                                    appViewState,
+                                                    appUiState.appSettings,
+                                                )
+                                            }
+                                    }
+                                    composable<Route.Lock> { PinLockScreen(viewModel) }
+                                    composable<Route.KillSwitch> {
+                                        KillSwitchScreen(appUiState, viewModel)
+                                    }
+                                    composable<Route.SplitTunnel> { SplitTunnelScreen(viewModel) }
+                                    composable<Route.TunnelAutoTunnel> { backStack ->
+                                        val args = backStack.toRoute<Route.TunnelOptions>()
+                                        appUiState.tunnels
+                                            .firstOrNull { it.id == args.id }
+                                            ?.let {
+                                                TunnelAutoTunnelScreen(
+                                                    it,
+                                                    appUiState.appSettings,
+                                                    viewModel,
+                                                )
+                                            }
+                                    }
+                                    composable<Route.Sort> { SortScreen(appUiState, viewModel) }
+                                    composable<Route.TunnelMonitoring> {
+                                        TunnelMonitoringScreen(appUiState, viewModel)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        WireGuardAutoTunnel.setUiActive(true)
+        networkMonitor.checkPermissionsAndUpdateState()
+    }
+
+    override fun onPause() {
+        super.onPause()
+        WireGuardAutoTunnel.setUiActive(false)
+    }
 }

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

@@ -4,12 +4,10 @@ import android.app.Application
 import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
 import androidx.hilt.work.HiltWorkerFactory
-import androidx.lifecycle.DefaultLifecycleObserver
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.work.Configuration
 import com.wireguard.android.backend.GoBackend
 import com.zaneschepke.logcatter.LogReader
+import com.zaneschepke.wireguardautotunnel.core.notification.NotificationMonitor
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.core.worker.ServiceWorker
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
@@ -19,123 +17,108 @@ import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.util.LocaleUtil
 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 kotlinx.coroutines.withContext
-import timber.log.Timber
 import javax.inject.Inject
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.update
+import timber.log.Timber
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application(), Configuration.Provider {
 
-	@Inject
-	lateinit var workerFactory: HiltWorkerFactory
+    @Inject lateinit var workerFactory: HiltWorkerFactory
 
-	override val workManagerConfiguration: Configuration
-		get() = Configuration.Builder()
-			.setWorkerFactory(workerFactory)
-			.build()
+    override val workManagerConfiguration: Configuration
+        get() = Configuration.Builder().setWorkerFactory(workerFactory).build()
 
-	@Inject
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
+    @Inject @ApplicationScope lateinit var applicationScope: CoroutineScope
 
-	@Inject
-	lateinit var logReader: LogReader
+    @Inject lateinit var logReader: LogReader
 
-	@Inject
-	lateinit var appDataRepository: AppDataRepository
+    @Inject lateinit var appDataRepository: AppDataRepository
 
-	@Inject
-	@IoDispatcher
-	lateinit var ioDispatcher: CoroutineDispatcher
+    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
 
-	@Inject
-	@MainDispatcher
-	lateinit var mainDispatcher: CoroutineDispatcher
+    @Inject @MainDispatcher lateinit var mainDispatcher: CoroutineDispatcher
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var notificationMonitor: NotificationMonitor
 
-	override fun onCreate() {
-		super.onCreate()
-		instance = this
-		ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
-		if (BuildConfig.DEBUG) {
-			Timber.plant(Timber.DebugTree())
-			StrictMode.setThreadPolicy(
-				ThreadPolicy.Builder()
-					.detectDiskReads()
-					.detectDiskWrites()
-					.detectNetwork()
-					.penaltyLog()
-					.build(),
-			)
-		} else {
-			Timber.plant(ReleaseTree())
-		}
+    @Inject lateinit var tunnelManager: TunnelManager
 
-		GoBackend.setAlwaysOnCallback {
-			applicationScope.launch {
-				val settings = appDataRepository.settings.get()
-				if (settings.isAlwaysOnVpnEnabled) {
-					val tunnel = appDataRepository.getPrimaryOrFirstTunnel()
-					tunnel?.let {
-						tunnelManager.startTunnel(it)
-					}
-				} else {
-					Timber.Forest.w("Always-on VPN is not enabled in app settings")
-				}
-			}
-		}
+    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())
+        }
 
-		ServiceWorker.start(this)
+        GoBackend.setAlwaysOnCallback {
+            applicationScope.launch {
+                val settings = appDataRepository.settings.get()
+                if (settings.isAlwaysOnVpnEnabled) {
+                    val tunnel = appDataRepository.getPrimaryOrFirstTunnel()
+                    tunnel?.let { tunnelManager.startTunnel(it) }
+                } else {
+                    Timber.w("Always-on VPN is not enabled in app settings")
+                }
+            }
+        }
 
-		applicationScope.launch {
-			withContext(mainDispatcher) {
-				if (appDataRepository.appState.isLocalLogsEnabled() && !isRunningOnTv()) logReader.start()
-			}
-			if (!appDataRepository.settings.get().isKernelEnabled) {
-				tunnelManager.setBackendState(BackendState.SERVICE_ACTIVE, emptyList())
-			}
-			appDataRepository.appState.getLocale()?.let {
-				withContext(mainDispatcher) {
-					LocaleUtil.changeLocale(it)
-				}
-			}
-		}
-	}
+        ServiceWorker.start(this)
 
-	override fun onTerminate() {
-		applicationScope.launch {
-			tunnelManager.setBackendState(BackendState.SERVICE_ACTIVE, emptyList())
-		}
-		super.onTerminate()
-	}
+        applicationScope.launch {
+            launch { notificationMonitor.handleApplicationNotifications() }
+            appDataRepository.appState.getLocale()?.let {
+                withContext(mainDispatcher) { LocaleUtil.changeLocale(it) }
+            }
+            appDataRepository.appState.isLocalLogsEnabled().let { enabled ->
+                if (enabled) logReader.start()
+            }
+        }
+    }
 
-	class AppLifecycleObserver : DefaultLifecycleObserver {
+    override fun onTerminate() {
+        applicationScope.cancel()
+        tunnelManager.setBackendState(BackendState.INACTIVE, emptyList())
+        super.onTerminate()
+    }
 
-		override fun onStart(owner: LifecycleOwner) {
-			Timber.d("Application entered foreground")
-			foreground = true
-		}
-		override fun onPause(owner: LifecycleOwner) {
-			Timber.d("Application entered background")
-			foreground = false
-		}
-	}
+    companion object {
 
-	companion object {
-		private var foreground = false
+        private val _uiActive = MutableStateFlow(false)
 
-		fun isForeground(): Boolean {
-			return foreground
-		}
+        val uiActive: StateFlow<Boolean>
+            get() = _uiActive
 
-		lateinit var instance: WireGuardAutoTunnel
-			private set
-	}
+        fun setUiActive(active: Boolean) {
+            _uiActive.update { active }
+        }
+
+        @Volatile private var lastActiveTunnels: List<Int> = emptyList()
+
+        @Synchronized
+        fun getLastActiveTunnels(): List<Int> {
+            return lastActiveTunnels
+        }
+
+        @Synchronized
+        fun setLastActiveTunnels(newTunnels: List<Int>) {
+            lastActiveTunnels = newTunnels
+        }
+
+        lateinit var instance: WireGuardAutoTunnel
+            private set
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/broadcast/KernelReceiver.kt

@@ -8,42 +8,35 @@ import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class KernelReceiver : BroadcastReceiver() {
 
-	@Inject
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
+    @Inject @ApplicationScope lateinit var applicationScope: CoroutineScope
 
-	@Inject
-	lateinit var tunnelRepository: TunnelRepository
+    @Inject lateinit var tunnelRepository: TunnelRepository
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	override fun onReceive(context: Context, intent: Intent) {
-		val action = intent.action ?: return
-		applicationScope.launch {
-			if (action == REFRESH_TUNNELS_ACTION) {
-				tunnelManager.runningTunnelNames().forEach { name ->
-					val tunnel = tunnelRepository.findByTunnelName(name)
-					tunnel?.let {
-						tunnelRepository.save(it.copy(isActive = true))
-					}
-				}
-				serviceManager.updateTunnelTile()
-			}
-		}
-	}
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action ?: return
+        applicationScope.launch {
+            if (action == REFRESH_TUNNELS_ACTION) {
+                tunnelManager.runningTunnelNames().forEach { name ->
+                    val tunnel = tunnelRepository.findByTunnelName(name)
+                    tunnel?.let { tunnelRepository.save(it.copy(isActive = true)) }
+                }
+                serviceManager.updateTunnelTile()
+            }
+        }
+    }
 
-	companion object {
-		const val REFRESH_TUNNELS_ACTION = "com.wireguard.android.action.REFRESH_TUNNEL_STATES"
-	}
+    companion object {
+        const val REFRESH_TUNNELS_ACTION = "com.wireguard.android.action.REFRESH_TUNNEL_STATES"
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/broadcast/NotificationActionReceiver.kt

@@ -10,37 +10,36 @@ import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
 import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class NotificationActionReceiver : BroadcastReceiver() {
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	@Inject
-	lateinit var tunnelRepository: TunnelRepository
+    @Inject lateinit var tunnelRepository: TunnelRepository
 
-	@Inject
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
+    @Inject @ApplicationScope lateinit var applicationScope: CoroutineScope
 
-	override fun onReceive(context: Context, intent: Intent) {
-		applicationScope.launch {
-			when (intent.action) {
-				NotificationAction.AUTO_TUNNEL_OFF.name -> serviceManager.stopAutoTunnel()
-				NotificationAction.TUNNEL_OFF.name -> {
-					val tunnelId = intent.getIntExtra(NotificationManager.EXTRA_ID, 0)
-					if (tunnelId == 0) return@launch tunnelManager.stopTunnel()
-					val tunnel = tunnelRepository.getById(tunnelId)
-					tunnelManager.stopTunnel(tunnel)
-				}
-			}
-		}
-	}
+    override fun onReceive(context: Context, intent: Intent) {
+        applicationScope.launch {
+            when (intent.action) {
+                NotificationAction.AUTO_TUNNEL_OFF.name -> serviceManager.stopAutoTunnel()
+                NotificationAction.TUNNEL_OFF.name -> {
+                    val tunnelId = intent.getIntExtra(NotificationManager.EXTRA_ID, 0)
+                    if (tunnelId == STOP_ALL_TUNNELS_ID) return@launch tunnelManager.stopTunnel()
+                    val tunnel = tunnelRepository.getById(tunnelId)
+                    tunnelManager.stopTunnel(tunnel)
+                }
+            }
+        }
+    }
+
+    companion object {
+        const val STOP_ALL_TUNNELS_ID = 0
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/broadcast/RemoteControlReceiver.kt

@@ -0,0 +1,96 @@
+package com.zaneschepke.wireguardautotunnel.core.broadcast
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import timber.log.Timber
+
+@AndroidEntryPoint
+class RemoteControlReceiver : BroadcastReceiver() {
+
+    @Inject @ApplicationScope lateinit var applicationScope: CoroutineScope
+
+    @Inject lateinit var appDataRepository: AppDataRepository
+
+    @Inject lateinit var serviceManager: ServiceManager
+
+    @Inject lateinit var tunnelManager: TunnelManager
+
+    enum class Action(private val suffix: String) {
+        START_TUNNEL("START_TUNNEL"),
+        STOP_TUNNEL("STOP_TUNNEL"),
+        START_AUTO_TUNNEL("START_AUTO_TUNNEL"),
+        STOP_AUTO_TUNNEL("STOP_AUTO_TUNNEL");
+
+        fun getFullAction(): String {
+            return "${Constants.BASE_PACKAGE}.$suffix"
+        }
+
+        companion object {
+            fun fromAction(action: String): Action? {
+                for (a in entries) {
+                    if (a.getFullAction() == action) {
+                        return a
+                    }
+                }
+                return null
+            }
+        }
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        Timber.i("onReceive")
+        val action = intent.action ?: return
+        val appAction = Action.fromAction(action) ?: return Timber.w("Unknown action $action")
+        applicationScope.launch {
+            if (!appDataRepository.appState.isRemoteControlEnabled())
+                return@launch Timber.w("Remote control disabled")
+            val key =
+                appDataRepository.appState.getRemoteKey()
+                    ?: return@launch Timber.w("Remote control key missing")
+            if (key != intent.getStringExtra(EXTRA_KEY)?.trim())
+                return@launch Timber.w("Invalid remote control key")
+            when (appAction) {
+                Action.START_TUNNEL -> {
+                    val tunnelName =
+                        intent.getStringExtra(EXTRA_TUN_NAME) ?: return@launch startDefaultTunnel()
+                    val tunnel =
+                        appDataRepository.tunnels.findByTunnelName(tunnelName)
+                            ?: return@launch startDefaultTunnel()
+                    tunnelManager.startTunnel(tunnel)
+                }
+                Action.STOP_TUNNEL -> {
+                    val tunnelName =
+                        intent.getStringExtra(EXTRA_TUN_NAME)
+                            ?: return@launch tunnelManager.stopTunnel()
+                    val tunnel =
+                        appDataRepository.tunnels.findByTunnelName(tunnelName)
+                            ?: return@launch tunnelManager.stopTunnel()
+                    tunnelManager.stopTunnel(tunnel)
+                }
+                Action.START_AUTO_TUNNEL -> serviceManager.startAutoTunnel()
+                Action.STOP_AUTO_TUNNEL -> serviceManager.stopAutoTunnel()
+            }
+        }
+    }
+
+    private suspend fun startDefaultTunnel() {
+        appDataRepository.getPrimaryOrFirstTunnel()?.let { tunnel ->
+            tunnelManager.startTunnel(tunnel)
+        }
+    }
+
+    companion object {
+        const val EXTRA_TUN_NAME = "tunnelName"
+        const val EXTRA_KEY = "key"
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/broadcast/RestartReceiver.kt

@@ -3,62 +3,53 @@ package com.zaneschepke.wireguardautotunnel.core.broadcast
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class RestartReceiver : BroadcastReceiver() {
-	@Inject
-	lateinit var appDataRepository: AppDataRepository
+    @Inject lateinit var appDataRepository: AppDataRepository
 
-	@Inject
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
+    @Inject @ApplicationScope lateinit var applicationScope: CoroutineScope
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	@Inject
-	@IoDispatcher
-	lateinit var ioDispatcher: CoroutineDispatcher
+    @Inject lateinit var logReader: LogReader
 
-	override fun onReceive(context: Context, intent: Intent) {
-		val action = intent.action ?: return
-		if (action != Intent.ACTION_BOOT_COMPLETED &&
-			action != Intent.ACTION_MY_PACKAGE_REPLACED &&
-			action != "com.htc.intent.action.QUICKBOOT_POWERON"
-		) {
-			return
-		}
+    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
 
-		Timber.d("RestartReceiver triggered with action: ${intent.action}")
-		applicationScope.launch(ioDispatcher) {
-			serviceManager.updateTunnelTile()
-			serviceManager.updateAutoTunnelTile()
-			val settings = appDataRepository.settings.get()
-			if (settings.isRestoreOnBootEnabled) {
-				if (settings.isAutoTunnelEnabled && !serviceManager.autoTunnelActive.value) {
-					Timber.d("Starting auto-tunnel on boot/update")
-					serviceManager.startAutoTunnel()
-				} else {
-					Timber.d("Restoring previous tunnel state")
-					tunnelManager.restorePreviousState()
-				}
-			} else {
-				Timber.d("Restore on boot disabled, skipping")
-			}
-		}
-	}
+    override fun onReceive(context: Context, intent: Intent) {
+        Timber.d("RestartReceiver triggered with action: ${intent.action}")
+        serviceManager.updateTunnelTile()
+        serviceManager.updateAutoTunnelTile()
+        applicationScope.launch(ioDispatcher) {
+            val settings = appDataRepository.settings.get()
+            if (settings.isRestoreOnBootEnabled) {
+                if (
+                    settings.isAutoTunnelEnabled && serviceManager.autoTunnelService.value == null
+                ) {
+                    Timber.d("Starting auto-tunnel on boot/update")
+                    serviceManager.startAutoTunnel()
+                } else {
+                    Timber.d("Restoring previous tunnel state")
+                    tunnelManager.restorePreviousState()
+                }
+            } else {
+                Timber.d("Restore on boot disabled, skipping")
+            }
+            if (intent.action == Intent.ACTION_MY_PACKAGE_REPLACED) logReader.deleteAndClearLogs()
+        }
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/notification/NotificationManager.kt

@@ -9,39 +9,48 @@ import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
 import com.zaneschepke.wireguardautotunnel.util.StringValue
 
 interface NotificationManager {
-	val context: Context
-	fun createNotification(
-		channel: NotificationChannels,
-		title: String = "",
-		actions: Collection<NotificationCompat.Action> = emptyList(),
-		description: String = "",
-		showTimestamp: Boolean = false,
-		importance: Int = NotificationManager.IMPORTANCE_HIGH,
-		onGoing: Boolean = true,
-		onlyAlertOnce: Boolean = true,
-	): Notification
+    val context: Context
 
-	fun createNotification(
-		channel: NotificationChannels,
-		title: StringValue,
-		actions: Collection<NotificationCompat.Action> = emptyList(),
-		description: StringValue,
-		showTimestamp: Boolean = false,
-		importance: Int = NotificationManager.IMPORTANCE_HIGH,
-		onGoing: Boolean = true,
-		onlyAlertOnce: Boolean = true,
-	): Notification
+    fun createNotification(
+        channel: NotificationChannels,
+        title: String = "",
+        actions: Collection<NotificationCompat.Action> = emptyList(),
+        description: String = "",
+        showTimestamp: Boolean = false,
+        importance: Int = NotificationManager.IMPORTANCE_HIGH,
+        onGoing: Boolean = true,
+        onlyAlertOnce: Boolean = true,
+    ): Notification
 
-	fun createNotificationAction(notificationAction: NotificationAction, extraId: Int? = null): NotificationCompat.Action
+    fun createNotification(
+        channel: NotificationChannels,
+        title: StringValue,
+        actions: Collection<NotificationCompat.Action> = emptyList(),
+        description: StringValue,
+        showTimestamp: Boolean = false,
+        importance: Int = NotificationManager.IMPORTANCE_HIGH,
+        onGoing: Boolean = true,
+        onlyAlertOnce: Boolean = true,
+    ): Notification
 
-	fun remove(notificationId: Int)
+    fun createNotificationAction(
+        notificationAction: NotificationAction,
+        extraId: Int? = null,
+    ): NotificationCompat.Action
 
-	fun show(notificationId: Int, notification: Notification)
+    fun remove(notificationId: Int)
 
-	companion object {
-		const val KERNEL_SERVICE_NOTIFICATION_ID = 123
-		const val AUTO_TUNNEL_NOTIFICATION_ID = 122
-		const val VPN_NOTIFICATION_ID = 100
-		const val EXTRA_ID = "id"
-	}
+    fun show(notificationId: Int, notification: Notification)
+
+    companion object {
+        const val AUTO_TUNNEL_LOCATION_PERMISSION_ID = 123
+        const val AUTO_TUNNEL_LOCATION_SERVICES_ID = 124
+        // For auto tunnel foreground notification
+        const val AUTO_TUNNEL_NOTIFICATION_ID = 122
+        // for tunnel foreground notification
+        const val VPN_NOTIFICATION_ID = 100
+        const val TUNNEL_ERROR_NOTIFICATION_ID = 101
+        const val TUNNEL_MESSAGES_NOTIFICATION_ID = 102
+        const val EXTRA_ID = "id"
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/notification/NotificationMonitor.kt

@@ -0,0 +1,63 @@
+package com.zaneschepke.wireguardautotunnel.core.notification
+
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+import jakarta.inject.Inject
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
+
+class NotificationMonitor
+@Inject
+constructor(
+    private val tunnelManager: TunnelManager,
+    private val notificationManager: NotificationManager,
+) {
+    suspend fun handleApplicationNotifications() = coroutineScope {
+        launch { handleTunnelErrors() }
+        launch { handleTunnelMessages() }
+    }
+
+    private suspend fun handleTunnelErrors() =
+        tunnelManager.errorEvents.collectLatest { (tunnelConf, error) ->
+            if (!WireGuardAutoTunnel.uiActive.value) {
+                val notification =
+                    notificationManager.createNotification(
+                        WireGuardNotification.NotificationChannels.VPN,
+                        title = StringValue.DynamicString(tunnelConf.name),
+                        description =
+                            when (error) {
+                                is BackendError.BounceFailed -> error.toStringValue()
+                                else ->
+                                    StringValue.StringResource(
+                                        R.string.tunnel_error_template,
+                                        error.toStringRes(),
+                                    )
+                            },
+                    )
+                notificationManager.show(
+                    NotificationManager.TUNNEL_ERROR_NOTIFICATION_ID,
+                    notification,
+                )
+            }
+        }
+
+    private suspend fun handleTunnelMessages() =
+        tunnelManager.messageEvents.collectLatest { (tunnelConf, message) ->
+            if (!WireGuardAutoTunnel.uiActive.value) {
+                val notification =
+                    notificationManager.createNotification(
+                        WireGuardNotification.NotificationChannels.VPN,
+                        title = StringValue.DynamicString(tunnelConf.name),
+                        description = message.toStringValue(),
+                    )
+                notificationManager.show(
+                    NotificationManager.TUNNEL_MESSAGES_NOTIFICATION_ID,
+                    notification,
+                )
+            }
+        }
+}

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

@@ -21,149 +21,156 @@ import com.zaneschepke.wireguardautotunnel.util.StringValue
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WireGuardNotification
-@Inject
-constructor(
-	@ApplicationContext override val context: Context,
-) : com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager {
+class WireGuardNotification @Inject constructor(@ApplicationContext override val context: Context) :
+    com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager {
 
-	enum class NotificationChannels {
-		VPN,
-		AUTO_TUNNEL,
-	}
+    enum class NotificationChannels {
+        VPN,
+        AUTO_TUNNEL,
+    }
 
-	private val notificationManager = NotificationManagerCompat.from(context)
+    private val notificationManager = NotificationManagerCompat.from(context)
 
-	override fun createNotification(
-		channel: NotificationChannels,
-		title: String,
-		actions: Collection<NotificationCompat.Action>,
-		description: String,
-		showTimestamp: Boolean,
-		importance: Int,
-		onGoing: Boolean,
-		onlyAlertOnce: Boolean,
-	): Notification {
-		notificationManager.createNotificationChannel(channel.asChannel())
-		return channel.asBuilder().apply {
-			actions.forEach {
-				addAction(it)
-			}
-			setContentTitle(title)
-			setContentIntent(
-				PendingIntent.getActivity(
-					context,
-					0,
-					Intent(context, MainActivity::class.java),
-					PendingIntent.FLAG_IMMUTABLE,
-				),
-			)
-			setContentText(description)
-			setOnlyAlertOnce(onlyAlertOnce)
-			setOngoing(onGoing)
-			setPriority(NotificationCompat.PRIORITY_HIGH)
-			setShowWhen(showTimestamp)
-			setSmallIcon(R.drawable.ic_launcher)
-		}.build()
-	}
+    override fun createNotification(
+        channel: NotificationChannels,
+        title: String,
+        actions: Collection<NotificationCompat.Action>,
+        description: String,
+        showTimestamp: Boolean,
+        importance: Int,
+        onGoing: Boolean,
+        onlyAlertOnce: Boolean,
+    ): Notification {
+        notificationManager.createNotificationChannel(channel.asChannel())
+        return channel
+            .asBuilder()
+            .apply {
+                actions.forEach { addAction(it) }
+                setContentTitle(title)
+                setContentIntent(
+                    PendingIntent.getActivity(
+                        context,
+                        0,
+                        Intent(context, MainActivity::class.java),
+                        PendingIntent.FLAG_IMMUTABLE,
+                    )
+                )
+                setContentText(description)
+                setOnlyAlertOnce(onlyAlertOnce)
+                setOngoing(onGoing)
+                setPriority(NotificationCompat.PRIORITY_HIGH)
+                setShowWhen(showTimestamp)
+                setSmallIcon(R.drawable.ic_notification)
+            }
+            .build()
+    }
 
-	override fun createNotification(
-		channel: NotificationChannels,
-		title: StringValue,
-		actions: Collection<NotificationCompat.Action>,
-		description: StringValue,
-		showTimestamp: Boolean,
-		importance: Int,
-		onGoing: Boolean,
-		onlyAlertOnce: Boolean,
-	): Notification {
-		return createNotification(
-			channel,
-			title.asString(context),
-			actions,
-			description.asString(context),
-			showTimestamp,
-			importance,
-			onGoing,
-			onlyAlertOnce,
-		)
-	}
+    override fun createNotification(
+        channel: NotificationChannels,
+        title: StringValue,
+        actions: Collection<NotificationCompat.Action>,
+        description: StringValue,
+        showTimestamp: Boolean,
+        importance: Int,
+        onGoing: Boolean,
+        onlyAlertOnce: Boolean,
+    ): Notification {
+        return createNotification(
+            channel,
+            title.asString(context),
+            actions,
+            description.asString(context),
+            showTimestamp,
+            importance,
+            onGoing,
+            onlyAlertOnce,
+        )
+    }
 
-	override fun createNotificationAction(notificationAction: NotificationAction, extraId: Int?): NotificationCompat.Action {
-		val pendingIntent = PendingIntent.getBroadcast(
-			context,
-			0,
-			Intent(context, NotificationActionReceiver::class.java).apply {
-				action = notificationAction.name
-				if (extraId != null) putExtra(EXTRA_ID, extraId)
-			},
-			PendingIntent.FLAG_IMMUTABLE,
-		)
-		return NotificationCompat.Action.Builder(
-			R.drawable.ic_launcher,
-			notificationAction.title(context).uppercase(),
-			pendingIntent,
-		).build()
-	}
+    override fun createNotificationAction(
+        notificationAction: NotificationAction,
+        extraId: Int?,
+    ): NotificationCompat.Action {
+        val pendingIntent =
+            PendingIntent.getBroadcast(
+                context,
+                0,
+                Intent(context, NotificationActionReceiver::class.java).apply {
+                    action = notificationAction.name
+                    if (extraId != null) putExtra(EXTRA_ID, extraId)
+                },
+                PendingIntent.FLAG_IMMUTABLE,
+            )
+        return NotificationCompat.Action.Builder(
+                R.drawable.ic_notification,
+                notificationAction.title(context).uppercase(),
+                pendingIntent,
+            )
+            .build()
+    }
 
-	override fun remove(notificationId: Int) {
-		notificationManager.cancel(notificationId)
-	}
+    override fun remove(notificationId: Int) {
+        notificationManager.cancel(notificationId)
+    }
 
-	override fun show(notificationId: Int, notification: Notification) {
-		with(notificationManager) {
-			if (ActivityCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
-				return
-			}
-			notify(notificationId, notification)
-		}
-	}
+    override fun show(notificationId: Int, notification: Notification) {
+        with(notificationManager) {
+            if (
+                ActivityCompat.checkSelfPermission(
+                    context,
+                    Manifest.permission.POST_NOTIFICATIONS,
+                ) != PackageManager.PERMISSION_GRANTED
+            ) {
+                return
+            }
+            notify(notificationId, notification)
+        }
+    }
 
-	private fun NotificationChannels.asBuilder(): NotificationCompat.Builder {
-		return when (this) {
-			NotificationChannels.AUTO_TUNNEL -> {
-				NotificationCompat.Builder(
-					context,
-					context.getString(R.string.auto_tunnel_channel_id),
-				)
-			}
-			NotificationChannels.VPN -> {
-				NotificationCompat.Builder(
-					context,
-					context.getString(R.string.vpn_channel_id),
-				)
-			}
-		}
-	}
+    private fun NotificationChannels.asBuilder(): NotificationCompat.Builder {
+        return when (this) {
+            NotificationChannels.AUTO_TUNNEL -> {
+                NotificationCompat.Builder(
+                    context,
+                    context.getString(R.string.auto_tunnel_channel_id),
+                )
+            }
+            NotificationChannels.VPN -> {
+                NotificationCompat.Builder(context, context.getString(R.string.vpn_channel_id))
+            }
+        }
+    }
 
-	private fun NotificationChannels.asChannel(): NotificationChannel {
-		return when (this) {
-			NotificationChannels.VPN -> {
-				NotificationChannel(
-					context.getString(R.string.vpn_channel_id),
-					context.getString(R.string.vpn_channel_name),
-					NotificationManager.IMPORTANCE_HIGH,
-				).apply {
-					description = context.getString(R.string.vpn_channel_description)
-					enableLights(true)
-					lightColor = Color.WHITE
-					enableVibration(false)
-					vibrationPattern = longArrayOf(100, 200, 300)
-				}
-			}
-			NotificationChannels.AUTO_TUNNEL -> {
-				NotificationChannel(
-					context.getString(R.string.auto_tunnel_channel_id),
-					context.getString(R.string.auto_tunnel_channel_name),
-					NotificationManager.IMPORTANCE_HIGH,
-				).apply {
-					description = context.getString(R.string.auto_tunnel_channel_description)
-					enableLights(true)
-					lightColor = Color.WHITE
-					enableVibration(false)
-					vibrationPattern = longArrayOf(100, 200, 300)
-				}
-			}
-		}
-	}
+    private fun NotificationChannels.asChannel(): NotificationChannel {
+        return when (this) {
+            NotificationChannels.VPN -> {
+                NotificationChannel(
+                        context.getString(R.string.vpn_channel_id),
+                        context.getString(R.string.vpn_channel_name),
+                        NotificationManager.IMPORTANCE_HIGH,
+                    )
+                    .apply {
+                        description = context.getString(R.string.vpn_channel_description)
+                        enableLights(true)
+                        lightColor = Color.WHITE
+                        enableVibration(false)
+                        vibrationPattern = longArrayOf(100, 200, 300)
+                    }
+            }
+            NotificationChannels.AUTO_TUNNEL -> {
+                NotificationChannel(
+                        context.getString(R.string.auto_tunnel_channel_id),
+                        context.getString(R.string.auto_tunnel_channel_name),
+                        NotificationManager.IMPORTANCE_HIGH,
+                    )
+                    .apply {
+                        description = context.getString(R.string.auto_tunnel_channel_description)
+                        enableLights(true)
+                        lightColor = Color.WHITE
+                        enableVibration(false)
+                        vibrationPattern = longArrayOf(100, 200, 300)
+                    }
+            }
+        }
+    }
 }

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

@@ -1,143 +1,151 @@
 package com.zaneschepke.wireguardautotunnel.core.service
 
-import android.app.Service
+import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import android.content.ServiceConnection
+import android.net.VpnService
+import android.os.IBinder
 import com.zaneschepke.wireguardautotunnel.core.service.autotunnel.AutoTunnelService
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.util.extensions.requestAutoTunnelTileServiceUpdate
 import com.zaneschepke.wireguardautotunnel.util.extensions.requestTunnelTileServiceStateUpdate
 import jakarta.inject.Inject
-import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withTimeoutOrNull
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
 import timber.log.Timber
 
-class ServiceManager @Inject constructor(
-	private val context: Context,
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-	@ApplicationScope private val applicationScope: CoroutineScope,
-	private val appDataRepository: AppDataRepository,
+class ServiceManager
+@Inject
+constructor(
+    private val context: Context,
+    private val ioDispatcher: CoroutineDispatcher,
+    private val applicationScope: CoroutineScope,
+    private val mainDispatcher: CoroutineDispatcher,
+    private val appDataRepository: AppDataRepository,
 ) {
 
-	private val _autoTunnelActive = MutableStateFlow(false)
-	val autoTunnelActive = _autoTunnelActive.asStateFlow()
+    private val autoTunnelMutex = Mutex()
 
-	var autoTunnelService = CompletableDeferred<AutoTunnelService>()
-	var backgroundService = CompletableDeferred<TunnelForegroundService>()
+    private val _tunnelService = MutableStateFlow<TunnelForegroundService?>(null)
+    private val _autoTunnelService = MutableStateFlow<AutoTunnelService?>(null)
+    val autoTunnelService = _autoTunnelService.asStateFlow()
 
-	private fun <T : Service> startService(cls: Class<T>, background: Boolean) {
-		runCatching {
-			val intent = Intent(context, cls)
-			if (background) {
-				context.startForegroundService(intent)
-			} else {
-				context.startService(intent)
-			}
-		}.onFailure { Timber.e(it) }
-	}
+    private val tunnelServiceConnection =
+        object : ServiceConnection {
+            override fun onServiceConnected(name: ComponentName, service: IBinder) {
+                val binder = service as? TunnelForegroundService.LocalBinder
+                _tunnelService.value = binder?.service
+                Timber.d("TunnelForegroundService connected")
+            }
 
-	fun startAutoTunnel() {
-		applicationScope.launch(ioDispatcher) {
-			val settings = appDataRepository.settings.get()
-			appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = true))
-			if (autoTunnelService.isCompleted) {
-				_autoTunnelActive.update { true }
-				return@launch
-			}
-			runCatching {
-				autoTunnelService = CompletableDeferred()
-				startService(AutoTunnelService::class.java, !WireGuardAutoTunnel.isForeground())
-				_autoTunnelActive.update { true }
-			}.onFailure {
-				Timber.e(it)
-				_autoTunnelActive.update { false }
-			}
-		}
-		updateAutoTunnelTile()
-	}
+            override fun onServiceDisconnected(name: ComponentName) {
+                _tunnelService.value = null
+                Timber.d("TunnelForegroundService disconnected")
+            }
+        }
 
-	fun startTunnelForegroundService(tunnelConf: TunnelConf) {
-		applicationScope.launch(ioDispatcher) {
-			if (backgroundService.isCompleted) return@launch
-			runCatching {
-				backgroundService = CompletableDeferred()
-				startService(TunnelForegroundService::class.java, !WireGuardAutoTunnel.isForeground())
-				val service = withTimeoutOrNull(SERVICE_START_TIMEOUT) { backgroundService.await() }
-					?: throw IllegalStateException("Background service start timed out")
-				service.start(tunnelConf)
-			}.onFailure {
-				Timber.e(it)
-			}
-		}
-	}
+    private val autoTunnelServiceConnection =
+        object : ServiceConnection {
+            override fun onServiceConnected(name: ComponentName, service: IBinder) {
+                val binder = service as? AutoTunnelService.LocalBinder
+                _autoTunnelService.value = binder?.service
+                Timber.d("AutoTunnelService connected")
+            }
 
-	fun updateTunnelForegroundServiceNotification(tunnelConf: TunnelConf) {
-		applicationScope.launch(ioDispatcher) {
-			if (!backgroundService.isCompleted) return@launch
-			runCatching {
-				val service = backgroundService.await()
-				service.start(tunnelConf)
-			}.onFailure {
-				Timber.e(it)
-			}
-		}
-	}
+            override fun onServiceDisconnected(name: ComponentName) {
+                _autoTunnelService.value = null
+                Timber.d("AutoTunnelService disconnected")
+            }
+        }
 
-	fun stopTunnelForegroundService() {
-		applicationScope.launch(ioDispatcher) {
-			if (!backgroundService.isCompleted) return@launch
-			runCatching {
-				val service = backgroundService.await()
-				service.stop()
-				backgroundService = CompletableDeferred()
-			}.onFailure {
-				Timber.e(it)
-			}
-		}
-	}
+    fun hasVpnPermission(): Boolean {
+        return VpnService.prepare(context) == null
+    }
 
-	fun toggleAutoTunnel() {
-		applicationScope.launch(ioDispatcher) {
-			if (_autoTunnelActive.value) stopAutoTunnel() else startAutoTunnel()
-		}
-	}
+    suspend fun startAutoTunnel() {
+        autoTunnelMutex.withLock {
+            val settings = appDataRepository.settings.get()
+            appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = true))
+            if (_autoTunnelService.value != null) return
+            withContext(ioDispatcher) {
+                val intent = Intent(context, AutoTunnelService::class.java)
+                context.startForegroundService(intent)
+                context.bindService(intent, autoTunnelServiceConnection, Context.BIND_AUTO_CREATE)
+                withContext(mainDispatcher) { updateAutoTunnelTile() }
+            }
+        }
+    }
 
-	fun updateAutoTunnelTile() {
-		context.requestAutoTunnelTileServiceUpdate()
-	}
+    suspend fun stopAutoTunnel() {
+        autoTunnelMutex.withLock {
+            val settings = appDataRepository.settings.get()
+            appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = false))
+            if (_autoTunnelService.value == null) return
+            _autoTunnelService.value?.let { service ->
+                service.stop()
+                try {
+                    context.unbindService(autoTunnelServiceConnection)
+                } catch (e: Exception) {
+                    Timber.e(e, "Failed to unbind AutoTunnelService")
+                } finally {
+                    _tunnelService.value = null
+                }
+            }
+            withContext(mainDispatcher) { updateAutoTunnelTile() }
+        }
+    }
 
-	fun updateTunnelTile() {
-		context.requestTunnelTileServiceStateUpdate()
-	}
+    suspend fun startTunnelForegroundService() {
+        if (_tunnelService.value != null) return
+        withContext(ioDispatcher) {
+            applicationScope.launch(ioDispatcher) {
+                val intent = Intent(context, TunnelForegroundService::class.java)
+                context.startForegroundService(intent)
+                context.bindService(intent, tunnelServiceConnection, Context.BIND_AUTO_CREATE)
+            }
+        }
+    }
 
-	fun stopAutoTunnel() {
-		applicationScope.launch(ioDispatcher) {
-			val settings = appDataRepository.settings.get()
-			appDataRepository.settings.save(settings.copy(isAutoTunnelEnabled = false))
-			if (!autoTunnelService.isCompleted) return@launch
-			runCatching {
-				val service = autoTunnelService.await()
-				service.stop()
-				_autoTunnelActive.update { false }
-				autoTunnelService = CompletableDeferred()
-				updateAutoTunnelTile()
-			}.onFailure {
-				Timber.e(it)
-			}
-		}
-	}
+    fun stopTunnelForegroundService() {
+        _tunnelService.value?.let { service ->
+            service.stop()
+            try {
+                context.unbindService(tunnelServiceConnection)
+            } catch (e: Exception) {
+                Timber.e(e, "Failed to stop TunnelForegroundService")
+            } finally {
+                _tunnelService.value = null
+            }
+        }
+    }
 
-	companion object {
-		const val SERVICE_START_TIMEOUT = 5_000L
-	}
+    fun toggleAutoTunnel() {
+        applicationScope.launch(ioDispatcher) {
+            if (_autoTunnelService.value != null) stopAutoTunnel() else startAutoTunnel()
+        }
+    }
+
+    fun updateAutoTunnelTile() {
+        context.requestAutoTunnelTileServiceUpdate()
+    }
+
+    fun updateTunnelTile() {
+        context.requestTunnelTileServiceStateUpdate()
+    }
+
+    fun handleTunnelServiceDestroy() {
+        _tunnelService.update { null }
+    }
+
+    fun handleAutoTunnelServiceDestroy() {
+        _autoTunnelService.update { null }
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/service/TunnelForegroundService.kt

@@ -2,179 +2,153 @@ package com.zaneschepke.wireguardautotunnel.core.service
 
 import android.app.Notification
 import android.content.Intent
+import android.os.Binder
 import android.os.IBinder
 import androidx.core.app.ServiceCompat
 import androidx.lifecycle.LifecycleService
 import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.networkmonitor.NetworkMonitor
-import com.zaneschepke.networkmonitor.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
-import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.extensions.distinctByKeys
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CompletableDeferred
+import io.ktor.util.collections.*
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.isActive
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class TunnelForegroundService : LifecycleService() {
 
-	@Inject
-	lateinit var notificationManager: NotificationManager
+    @Inject lateinit var notificationManager: NotificationManager
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	@Inject
-	lateinit var networkMonitor: NetworkMonitor
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	@Inject
-	@IoDispatcher
-	lateinit var ioDispatcher: CoroutineDispatcher
+    @Inject lateinit var tunnelMonitor: TunnelMonitor
 
-	@Inject
-	lateinit var tunnelRepo: TunnelRepository
+    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
 
-	private val isNetworkConnected = MutableStateFlow(true)
+    @Inject lateinit var appDataRepository: AppDataRepository
 
-	override fun onCreate() {
-		super.onCreate()
-		serviceManager.backgroundService.complete(this)
-	}
+    class LocalBinder(val service: TunnelForegroundService) : Binder()
 
-	override fun onBind(intent: Intent): IBinder? {
-		super.onBind(intent)
-		return null
-	}
+    private val tunnelJobs = ConcurrentMap<TunnelConf, Job>()
 
-	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-		serviceManager.backgroundService.complete(this)
-		return super.onStartCommand(intent, flags, startId)
-	}
+    private val binder = LocalBinder(this)
 
-	fun start(tunnelConf: TunnelConf) {
-		Timber.d("Service starting with TunnelConf instance: ${tunnelConf.hashCode()}")
-		ServiceCompat.startForeground(
-			this@TunnelForegroundService,
-			NotificationManager.KERNEL_SERVICE_NOTIFICATION_ID,
-			createNotification(tunnelConf),
-			Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
-		)
-		// monitor if we have internet connectivity
-		startNetworkMonitorJob()
+    override fun onCreate() {
+        super.onCreate()
+        ServiceCompat.startForeground(
+            this@TunnelForegroundService,
+            NotificationManager.VPN_NOTIFICATION_ID,
+            onCreateNotification(),
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
+        )
+    }
 
-		// job to trigger stats emit on interval
-		startTunnelStatsJob(tunnelConf)
+    override fun onBind(intent: Intent): IBinder {
+        super.onBind(intent)
+        return binder
+    }
 
-		// monitor changes to the tunnel config
-		startTunnelConfChangesJob(tunnelConf)
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        super.onStartCommand(intent, flags, startId)
+        ServiceCompat.startForeground(
+            this@TunnelForegroundService,
+            NotificationManager.VPN_NOTIFICATION_ID,
+            onCreateNotification(),
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
+        )
+        start()
+        return START_STICKY
+    }
 
-		startPingJob(tunnelConf)
-	}
+    fun start() =
+        lifecycleScope.launch(ioDispatcher) {
+            tunnelManager.activeTunnels.distinctByKeys().collect { activeTunnels ->
+                val activeTunConfigs = activeTunnels.keys
+                val obsoleteJobs = tunnelJobs.keys - activeTunConfigs
+                obsoleteJobs.forEach { tunnelConf -> tunnelJobs[tunnelConf]?.cancel() }
+                activeTunConfigs.forEach { tun ->
+                    if (tunnelJobs.containsKey(tun)) return@forEach
+                    tunnelJobs[tun] = launch { tunnelMonitor.startMonitoring(tun, true) }
+                }
+                updateServiceNotification(activeTunnels)
+            }
+        }
 
-	private fun startTunnelConfChangesJob(tunnelConf: TunnelConf) = lifecycleScope.launch(ioDispatcher) {
-		tunnelRepo.flow
-			.flowOn(ioDispatcher)
-			.map { storedTunnels ->
-				storedTunnels.firstOrNull { it.id == tunnelConf.id }
-			}
-			.filterNotNull()
-			// only emit when one of these 3 values change
-			.distinctUntilChanged { old, new ->
-				old.tunName == new.tunName && old.wgQuick == new.wgQuick && old.amQuick == new.amQuick
-			}
-			.collect { storedTunnel ->
-				if (tunnelConf.isTunnelConfigChanged(storedTunnel)) {
-					Timber.d("Config changed for ${storedTunnel.tunName}, bouncing")
-					tunnelConf.bounceTunnel(storedTunnel)
-				}
-			}
-	}
+    // TODO Would be cool to have this include kill switch
+    private fun updateServiceNotification(activeTunnels: Map<TunnelConf, TunnelState>) {
+        val notification =
+            when (activeTunnels.size) {
+                0 -> onCreateNotification()
+                1 -> createTunnelNotification(activeTunnels.keys.first())
+                else -> createTunnelsNotification()
+            }
+        ServiceCompat.startForeground(
+            this@TunnelForegroundService,
+            NotificationManager.VPN_NOTIFICATION_ID,
+            notification,
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
+        )
+    }
 
-	private fun startNetworkMonitorJob() = lifecycleScope.launch(ioDispatcher) {
-		networkMonitor.networkStatusFlow
-			.flowOn(ioDispatcher)
-			.collectLatest { status ->
-				val isAvailable = status !is NetworkStatus.Disconnected
-				isNetworkConnected.value = isAvailable
-				Timber.d("Network available: $status")
-			}
-	}
+    fun stop() {
+        Timber.d("Stop called")
+        tunnelJobs.forEach { it.value.cancel() }
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        stopSelf()
+    }
 
-	private fun startTunnelStatsJob(tunnel: TunnelConf) = lifecycleScope.launch(ioDispatcher) {
-		while (isActive) {
-			tunnel.onUpdateStatistics()
-			delay(STATS_DELAY)
-		}
-	}
+    override fun onDestroy() {
+        tunnelJobs.forEach { it.value.cancel() }
+        serviceManager.handleTunnelServiceDestroy()
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        Timber.d("onDestroy")
+        super.onDestroy()
+    }
 
-	private fun startPingJob(tunnel: TunnelConf) = lifecycleScope.launch(ioDispatcher) {
-		delay(PING_START_DELAY)
-		while (isActive) {
-			val shouldBounce = shouldBounceTunnel(tunnel)
-			val delayMs = if (shouldBounce) {
-				tunnel.bounceTunnel(tunnel)
-				tunnel.pingCooldown ?: Constants.PING_COOLDOWN
-			} else {
-				tunnel.pingInterval ?: Constants.PING_INTERVAL
-			}
-			delay(delayMs)
-		}
-	}
+    private fun createTunnelNotification(tunnelConf: TunnelConf): Notification {
+        return notificationManager.createNotification(
+            WireGuardNotification.NotificationChannels.VPN,
+            title = "${getString(R.string.tunnel_running)} - ${tunnelConf.tunName}",
+            actions =
+                listOf(
+                    notificationManager.createNotificationAction(
+                        NotificationAction.TUNNEL_OFF,
+                        tunnelConf.id,
+                    )
+                ),
+        )
+    }
 
-	private suspend fun shouldBounceTunnel(tunnel: TunnelConf): Boolean {
-		if (!isNetworkConnected.value) {
-			Timber.d("Network disconnected, skipping ping for ${tunnel.tunName}")
-			return false
-		}
-		return runCatching {
-			!tunnel.isTunnelPingable(ioDispatcher)
-		}.onFailure { e ->
-			Timber.e(e, "Ping check failed for ${tunnel.tunName}")
-		}.getOrDefault(true)
-	}
+    private fun createTunnelsNotification(): Notification {
+        return notificationManager.createNotification(
+            WireGuardNotification.NotificationChannels.VPN,
+            title = "${getString(R.string.tunnel_running)} - ${getString(R.string.multiple)}",
+            actions =
+                listOf(
+                    notificationManager.createNotificationAction(NotificationAction.TUNNEL_OFF, 0)
+                ),
+        )
+    }
 
-	fun stop() {
-		stopSelf()
-	}
-
-	override fun onDestroy() {
-		serviceManager.backgroundService = CompletableDeferred()
-		ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
-		super.onDestroy()
-	}
-
-	private fun createNotification(tunnelConf: TunnelConf): Notification {
-		return notificationManager.createNotification(
-			WireGuardNotification.NotificationChannels.VPN,
-			title = "${getString(R.string.tunnel_running)} - ${tunnelConf.tunName}",
-			actions = listOf(
-				notificationManager.createNotificationAction(NotificationAction.TUNNEL_OFF, tunnelConf.id),
-			),
-		)
-	}
-
-	companion object {
-		const val STATS_DELAY = 1_000L
-		const val PING_START_DELAY = 30_000L
-		// ipv6 disabled or block on network
-// 		const val userspaceStartFailed = "Failed to send handshake initiation: write udp [::]"
-// 		const val ipv6Fails = "Failed to send data packets: write udp [::]"
-// 		const val ipv4Fails = "Failed to send data packets: write udp 0.0.0.0:51820"
-	}
+    private fun onCreateNotification(): Notification {
+        return notificationManager.createNotification(
+            WireGuardNotification.NotificationChannels.VPN,
+            title = getString(R.string.tunnel_starting),
+        )
+    }
 }

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

@@ -1,255 +1,462 @@
 package com.zaneschepke.wireguardautotunnel.core.service.autotunnel
 
 import android.content.Intent
+import android.os.Binder
 import android.os.IBinder
-import android.os.PowerManager
 import androidx.core.app.ServiceCompat
 import androidx.lifecycle.LifecycleService
 import androidx.lifecycle.lifecycleScope
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
+import com.zaneschepke.networkmonitor.ConnectivityState
 import com.zaneschepke.networkmonitor.NetworkMonitor
-import com.zaneschepke.networkmonitor.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelMonitor
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.di.MainImmediateDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
 import com.zaneschepke.wireguardautotunnel.domain.enums.NotificationAction
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus.StopReason.Ping
 import com.zaneschepke.wireguardautotunnel.domain.events.AutoTunnelEvent
-import com.zaneschepke.wireguardautotunnel.domain.events.KillSwitchEvent
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.AutoTunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
+import com.zaneschepke.wireguardautotunnel.util.extensions.toMillis
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.FlowPreview
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import timber.log.Timber
 import javax.inject.Inject
 import javax.inject.Provider
+import kotlin.math.pow
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import timber.log.Timber
 
 @AndroidEntryPoint
 class AutoTunnelService : LifecycleService() {
 
-	@Inject
-	lateinit var networkMonitor: NetworkMonitor
+    @Inject lateinit var networkMonitor: NetworkMonitor
 
-	@Inject
-	lateinit var appDataRepository: Provider<AppDataRepository>
+    @Inject lateinit var appDataRepository: Provider<AppDataRepository>
 
-	@Inject
-	lateinit var notificationManager: NotificationManager
+    @Inject lateinit var notificationManager: NotificationManager
 
-	@Inject
-	@IoDispatcher
-	lateinit var ioDispatcher: CoroutineDispatcher
+    @Inject @IoDispatcher lateinit var ioDispatcher: CoroutineDispatcher
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	@Inject
-	@MainImmediateDispatcher
-	lateinit var mainImmediateDispatcher: CoroutineDispatcher
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var tunnelMonitor: TunnelMonitor
 
-	private val defaultState = AutoTunnelState()
+    private val defaultState = AutoTunnelState()
 
-	private val autoTunnelStateFlow = MutableStateFlow(defaultState)
+    private val autoTunMutex = Mutex()
 
-	private var wakeLock: PowerManager.WakeLock? = null
+    private val autoTunnelStateFlow = MutableStateFlow(defaultState)
 
-	override fun onCreate() {
-		super.onCreate()
-		serviceManager.autoTunnelService.complete(this)
-		lifecycleScope.launch(mainImmediateDispatcher) {
-			runCatching {
-				launchWatcherNotification()
-			}.onFailure {
-				Timber.e(it)
-			}
-		}
-	}
+    private val bounceCounts = MutableStateFlow<Map<Int, Int>>(emptyMap())
 
-	override fun onBind(intent: Intent): IBinder? {
-		super.onBind(intent)
-		return null
-	}
+    private var eventHandlerJob: Job? = null
 
-	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-		super.onStartCommand(intent, flags, startId)
-		Timber.d("onStartCommand executed with startId: $startId")
-		serviceManager.autoTunnelService.complete(this)
-		start()
-		return START_STICKY
-	}
+    private val lastBounceTimes = mutableMapOf<Int, Long>()
 
-	fun start() {
-		kotlin.runCatching {
-			lifecycleScope.launch(mainImmediateDispatcher) {
-				launchWatcherNotification()
-				initWakeLock()
-			}
-			startAutoTunnelJob()
-			startAutoTunnelStateJob()
-			startKillSwitchJob()
-		}.onFailure {
-			Timber.e(it)
-		}
-	}
+    class LocalBinder(val service: AutoTunnelService) : Binder()
 
-	fun stop() {
-		wakeLock?.let { if (it.isHeld) it.release() }
-		stopSelf()
-	}
+    private val binder = LocalBinder(this)
 
-	override fun onDestroy() {
-		serviceManager.autoTunnelService = CompletableDeferred()
-		super.onDestroy()
-	}
+    override fun onCreate() {
+        super.onCreate()
+        launchWatcherNotification()
+    }
 
-	private fun launchWatcherNotification(description: String = getString(R.string.monitoring_state_changes)) {
-		val notification =
-			notificationManager.createNotification(
-				WireGuardNotification.NotificationChannels.AUTO_TUNNEL,
-				title = getString(R.string.auto_tunnel_title),
-				description = description,
-				actions = listOf(
-					notificationManager.createNotificationAction(NotificationAction.AUTO_TUNNEL_OFF),
-				),
-			)
-		ServiceCompat.startForeground(
-			this,
-			NotificationManager.AUTO_TUNNEL_NOTIFICATION_ID,
-			notification,
-			Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
-		)
-	}
+    override fun onBind(intent: Intent): IBinder {
+        super.onBind(intent)
+        return binder
+    }
 
-	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()
-				}
-			}
-		}
-	}
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        super.onStartCommand(intent, flags, startId)
+        Timber.d("onStartCommand executed with startId: $startId")
+        start()
+        return START_STICKY
+    }
 
-	private fun buildNetworkState(networkStatus: NetworkStatus): NetworkState {
-		return with(autoTunnelStateFlow.value.networkState) {
-			val wifiName = when (networkStatus) {
-				is NetworkStatus.Connected -> {
-					networkStatus.wifiSsid
-				}
-				else -> null
-			}
-			copy(
-				isWifiConnected = networkStatus.wifiConnected,
-				isMobileDataConnected = networkStatus.cellularConnected,
-				isEthernetConnected = networkStatus.ethernetConnected,
-				wifiName = wifiName,
-			)
-		}
-	}
+    fun start() {
+        launchWatcherNotification()
+        startAutoTunnelStateJob()
+        startLocationPermissionsNotificationJob()
+    }
 
-	@OptIn(ExperimentalCoroutinesApi::class)
-	private fun startAutoTunnelStateJob() = lifecycleScope.launch(ioDispatcher) {
-		combine(
-			combineSettings(),
-			appDataRepository.get().settings.flow
-				.distinctUntilChanged { old, new -> old.isKernelEnabled == new.isKernelEnabled } // Only emit when isKernelEnabled changes
-				.flatMapLatest {
-					networkMonitor.networkStatusFlow
-						.flowOn(ioDispatcher)
-						.map { buildNetworkState(it) }
-				}
-				.distinctUntilChanged(),
-		) { double, networkState ->
-			AutoTunnelState(
-				tunnelManager.activeTunnels.value,
-				networkState,
-				double.first,
-				double.second,
-			)
-		}.collect { state ->
-			autoTunnelStateFlow.update {
-				it.copy(
-					activeTunnels = state.activeTunnels,
-					networkState = state.networkState,
-					settings = state.settings,
-					tunnels = state.tunnels,
-				)
-			}
-		}
-	}
+    fun stop() {
+        stopSelf()
+    }
 
-	private fun combineSettings(): Flow<Pair<AppSettings, Tunnels>> {
-		return combine(
-			appDataRepository.get().settings.flow,
-			appDataRepository.get().tunnels.flow.map { tunnels ->
-				// isActive is ignored for equality checks so user can manually toggle off tunnel with auto-tunnel
-				tunnels.map { it.copy(isActive = false) }
-			},
-		) { settings, tunnels ->
-			Pair(settings, tunnels)
-		}.distinctUntilChanged()
-	}
+    override fun onDestroy() {
+        serviceManager.handleAutoTunnelServiceDestroy()
+        restoreVpnKillSwitch()
+        ServiceCompat.stopForeground(this, ServiceCompat.STOP_FOREGROUND_REMOVE)
+        super.onDestroy()
+    }
 
-	private fun startKillSwitchJob() = lifecycleScope.launch(ioDispatcher) {
-		autoTunnelStateFlow.collect {
-			if (it == defaultState) return@collect
-			when (val event = it.asKillSwitchEvent()) {
-				KillSwitchEvent.DoNothing -> Unit
-				is KillSwitchEvent.Start -> {
-					Timber.d("Starting kill switch")
-					tunnelManager.setBackendState(BackendState.KILL_SWITCH_ACTIVE, event.allowedIps)
-				}
-				KillSwitchEvent.Stop -> {
-					Timber.d("Stopping kill switch")
-					tunnelManager.setBackendState(BackendState.SERVICE_ACTIVE, emptySet())
-				}
-			}
-		}
-	}
+    private fun restoreVpnKillSwitch() {
+        with(autoTunnelStateFlow.value) {
+            if (
+                settings.isVpnKillSwitchEnabled &&
+                    tunnelManager.getBackendState() != BackendState.KILL_SWITCH_ACTIVE
+            ) {
+                eventHandlerJob?.cancel()
+                val allowedIps =
+                    if (settings.isLanOnKillSwitchEnabled) TunnelConf.LAN_BYPASS_ALLOWED_IPS
+                    else emptyList()
+                tunnelManager.setBackendState(BackendState.KILL_SWITCH_ACTIVE, allowedIps)
+            }
+        }
+    }
 
-	@OptIn(FlowPreview::class)
-	private fun startAutoTunnelJob() = lifecycleScope.launch(ioDispatcher) {
-		Timber.i("Starting auto-tunnel network event watcher")
-		val settings = appDataRepository.get().settings.get()
-		Timber.d("Starting with debounce delay of: ${settings.debounceDelaySeconds} seconds")
-		autoTunnelStateFlow.debounce(settings.debounceDelayMillis()).collect { watcherState ->
-			if (watcherState == defaultState) return@collect
-			Timber.d("New auto tunnel state emitted ${watcherState.networkState}")
-			when (val event = watcherState.asAutoTunnelEvent()) {
-				is AutoTunnelEvent.Start -> (event.tunnelConf ?: appDataRepository.get().getPrimaryOrFirstTunnel())?.let {
-					tunnelManager.startTunnel(it)
-				}
-				// TODO improve this to target specific tunnels to better support multi-tunnel
-				is AutoTunnelEvent.Stop -> tunnelManager.stopTunnel()
-				AutoTunnelEvent.DoNothing -> Timber.i("Auto-tunneling: no condition met")
-			}
-		}
-	}
+    private fun launchWatcherNotification(
+        description: String = getString(R.string.monitoring_state_changes)
+    ) {
+        val notification =
+            notificationManager.createNotification(
+                WireGuardNotification.NotificationChannels.AUTO_TUNNEL,
+                title = getString(R.string.auto_tunnel_title),
+                description = description,
+                actions =
+                    listOf(
+                        notificationManager.createNotificationAction(
+                            NotificationAction.AUTO_TUNNEL_OFF
+                        )
+                    ),
+            )
+        ServiceCompat.startForeground(
+            this,
+            NotificationManager.AUTO_TUNNEL_NOTIFICATION_ID,
+            notification,
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
+        )
+    }
+
+    private fun startAutoTunnelStateJob() =
+        lifecycleScope.launch(ioDispatcher) {
+            val networkFlow =
+                debouncedConnectivityStateFlow
+                    .flowOn(ioDispatcher)
+                    .map(NetworkState::from)
+                    .map { StateChange.NetworkChange(it) }
+                    .distinctUntilChanged()
+
+            val settingsFlow =
+                combineSettings().map { StateChange.SettingsChange(it.first, it.second) }
+
+            val tunnelsFlow =
+                tunnelManager.activeTunnels.map { StateChange.ActiveTunnelsChange(it) }
+
+            val monitoringFlow =
+                tunnelManager.activeTunnels
+                    .map { map -> map.mapValues { (_, state) -> state.pingStates } }
+                    .distinctUntilChanged()
+                    .map { StateChange.MonitoringChange(it) }
+
+            var reevaluationJob: Job? = null
+
+            // get everything in sync before we use merge
+            combine(networkFlow, settingsFlow, tunnelsFlow, monitoringFlow) {
+                    network,
+                    settings,
+                    tunnels,
+                    monitoring ->
+                    autoTunnelStateFlow.update {
+                        it.copy(
+                            activeTunnels = tunnels.activeTunnels,
+                            networkState = network.networkState,
+                            settings = settings.settings,
+                            tunnels = settings.tunnels,
+                        )
+                    }
+                }
+                .first()
+
+            // use merge to limit the noise of a combine and also increase the scalability of auto
+            // tunnel handling new states
+            merge(networkFlow, settingsFlow, tunnelsFlow, monitoringFlow).collect { change ->
+                if (change !is StateChange.ActiveTunnelsChange) {
+                    Timber.d("New state changed to ${change.javaClass.simpleName}")
+                }
+
+                when (change) {
+                    is StateChange.NetworkChange -> {
+                        reevaluationJob?.cancel()
+                        val previousState = autoTunnelStateFlow.value
+                        autoTunnelStateFlow.update { it.copy(networkState = change.networkState) }
+                        // Android late mobile data state change, we can ignore handling this
+                        if (
+                            isAndroidLateCellularActiveChange(
+                                previousState.networkState,
+                                change.networkState,
+                            )
+                        ) {
+                            Timber.d("Android late cellular active state change")
+                            return@collect
+                        }
+                    }
+                    is StateChange.SettingsChange -> {
+                        reevaluationJob?.cancel()
+                        autoTunnelStateFlow.update {
+                            it.copy(settings = change.settings, tunnels = change.tunnels)
+                        }
+                    }
+                    is StateChange.ActiveTunnelsChange -> {
+                        autoTunnelStateFlow.update { it.copy(activeTunnels = change.activeTunnels) }
+                        return@collect
+                    }
+                    is StateChange.MonitoringChange -> {
+                        change.pingStates.forEach { (config, pingState) ->
+                            Timber.d("Ping state $pingState")
+                            if (pingState?.all { it.value.isReachable } == true) {
+                                Timber.d("Clearing bounce count on success")
+                                bounceCounts.update { current ->
+                                    current.toMutableMap().apply { remove(config.id) }
+                                }
+                            }
+                        }
+                        return@collect handleAutoTunnelEvent(
+                            autoTunnelStateFlow.value.determineAutoTunnelEvent(
+                                StateChange.MonitoringChange(change.pingStates)
+                            )
+                        )
+                    }
+                }
+
+                handleAutoTunnelEvent(autoTunnelStateFlow.value.determineAutoTunnelEvent(change))
+
+                reevaluationJob = launch {
+                    delay(REEVALUATE_CHECK_DELAY)
+                    val currentState = autoTunnelStateFlow.value
+                    if (currentState != defaultState) {
+                        Timber.d("Re-evaluating auto-tunnel state..")
+                        handleAutoTunnelEvent(currentState.determineAutoTunnelEvent(change))
+                    }
+                }
+            }
+        }
+
+    private fun isAndroidLateCellularActiveChange(
+        previous: NetworkState,
+        new: NetworkState,
+    ): Boolean {
+        return (previous.isWifiConnected != new.isWifiConnected &&
+            previous.wifiName == new.wifiName &&
+            previous.isMobileDataConnected != new.isMobileDataConnected)
+    }
+
+    // all relevant settings to auto tunnel
+    private fun areAutoTunnelSettingsTheSame(old: AppSettings, new: AppSettings): Boolean {
+        return (old.isTunnelOnWifiEnabled == new.isTunnelOnWifiEnabled &&
+            old.isTunnelOnMobileDataEnabled == new.isTunnelOnMobileDataEnabled &&
+            old.isTunnelOnEthernetEnabled == new.isTunnelOnEthernetEnabled &&
+            old.trustedNetworkSSIDs == new.trustedNetworkSSIDs &&
+            old.isPingEnabled == new.isPingEnabled &&
+            old.debounceDelaySeconds == new.debounceDelaySeconds &&
+            old.wifiDetectionMethod == new.wifiDetectionMethod &&
+            old.isVpnKillSwitchEnabled == new.isVpnKillSwitchEnabled &&
+            old.isLanOnKillSwitchEnabled == new.isLanOnKillSwitchEnabled &&
+            old.isDisableKillSwitchOnTrustedEnabled == new.isDisableKillSwitchOnTrustedEnabled &&
+            old.isStopOnNoInternetEnabled == new.isStopOnNoInternetEnabled)
+    }
+
+    private fun combineSettings(): Flow<Pair<AppSettings, Tunnels>> {
+        return combine(
+                appDataRepository
+                    .get()
+                    .settings
+                    .flow
+                    .distinctUntilChanged(::areAutoTunnelSettingsTheSame),
+                appDataRepository.get().tunnels.flow.map { tunnels ->
+                    // isActive is ignored for equality checks so user can manually toggle off
+                    // tunnel with auto-tunnel
+                    tunnels.map { it.copy(isActive = false) }
+                },
+            ) { settings, tunnels ->
+                Pair(settings, tunnels)
+            }
+            .distinctUntilChanged()
+    }
+
+    private fun areAutoTunnelPermissionsRequiredTheSame(
+        old: AutoTunnelState,
+        new: AutoTunnelState,
+    ): Boolean {
+        return (old.settings.wifiDetectionMethod == new.settings.wifiDetectionMethod &&
+            old.networkState.locationPermissionGranted ==
+                new.networkState.locationPermissionGranted &&
+            old.networkState.locationServicesEnabled == new.networkState.locationServicesEnabled &&
+            old.tunnels == new.tunnels &&
+            old.settings.trustedNetworkSSIDs == new.settings.trustedNetworkSSIDs)
+    }
+
+    //     watch for changes to location permission and notify user it will impact auto-tunneling
+    //     TODO or a recheck button for location permission so we dont have to poll it
+    private fun startLocationPermissionsNotificationJob(): Job =
+        lifecycleScope.launch(ioDispatcher) {
+            var locationServicesShown = false
+            var locationPermissionsShown = false
+
+            data class NetworkPermissionState(
+                val detectionMethod: AndroidNetworkMonitor.WifiDetectionMethod,
+                val locationServicesEnabled: Boolean,
+                val locationPermissionsEnabled: Boolean,
+                val ssidReadRequired: Boolean,
+            )
+
+            autoTunnelStateFlow
+                .distinctUntilChanged(::areAutoTunnelPermissionsRequiredTheSame)
+                .map {
+                    NetworkPermissionState(
+                        it.settings.wifiDetectionMethod,
+                        it.networkState.locationServicesEnabled == true,
+                        it.networkState.locationPermissionGranted == true,
+                        (it.tunnels.any { tunnel -> tunnel.tunnelNetworks.isNotEmpty() } ||
+                            it.settings.trustedNetworkSSIDs.isNotEmpty()),
+                    )
+                }
+                .collect { state ->
+                    when (state.detectionMethod) {
+                        AndroidNetworkMonitor.WifiDetectionMethod.DEFAULT,
+                        AndroidNetworkMonitor.WifiDetectionMethod.LEGACY -> {
+                            if (
+                                !state.locationPermissionsEnabled &&
+                                    !locationPermissionsShown &&
+                                    state.ssidReadRequired
+                            ) {
+                                locationPermissionsShown = true
+                                val notification =
+                                    notificationManager.createNotification(
+                                        WireGuardNotification.NotificationChannels.AUTO_TUNNEL,
+                                        title = getString(R.string.warning),
+                                        description =
+                                            getString(R.string.location_permissions_missing),
+                                    )
+                                notificationManager.show(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_PERMISSION_ID,
+                                    notification,
+                                )
+                            }
+                            if (
+                                !state.locationServicesEnabled &&
+                                    !locationServicesShown &&
+                                    state.ssidReadRequired
+                            ) {
+                                locationServicesShown = true
+                                val notification =
+                                    notificationManager.createNotification(
+                                        WireGuardNotification.NotificationChannels.AUTO_TUNNEL,
+                                        title = getString(R.string.warning),
+                                        description =
+                                            getString(R.string.location_services_not_detected),
+                                    )
+                                notificationManager.show(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_SERVICES_ID,
+                                    notification,
+                                )
+                            }
+                            if (state.locationServicesEnabled || !state.ssidReadRequired) {
+                                notificationManager.remove(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_SERVICES_ID
+                                )
+                                locationServicesShown = false
+                            }
+                            if (state.locationPermissionsEnabled || !state.ssidReadRequired) {
+                                notificationManager.remove(
+                                    NotificationManager.AUTO_TUNNEL_LOCATION_PERMISSION_ID
+                                )
+                                locationPermissionsShown = false
+                            }
+                        }
+                        else -> Unit
+                    }
+                }
+        }
+
+    private suspend fun handleAutoTunnelEvent(autoTunnelEvent: AutoTunnelEvent) {
+        autoTunMutex.withLock {
+            when (
+                val event =
+                    autoTunnelEvent.also {
+                        Timber.i("Auto tunnel event: ${it.javaClass.simpleName}")
+                    }
+            ) {
+                is AutoTunnelEvent.Start ->
+                    (event.tunnelConf ?: appDataRepository.get().getPrimaryOrFirstTunnel())?.let {
+                        tunnelManager.startTunnel(it)
+                    }
+                is AutoTunnelEvent.Stop -> tunnelManager.stopTunnel()
+                AutoTunnelEvent.DoNothing -> Timber.i("Auto-tunneling: nothing to do")
+                is AutoTunnelEvent.Bounce ->
+                    handleBounceWithBackoff(event.configsPeerKeyResolvedMap)
+                is AutoTunnelEvent.StartKillSwitch -> {
+                    Timber.d("Starting kill switch")
+                    tunnelManager.setBackendState(BackendState.KILL_SWITCH_ACTIVE, event.allowedIps)
+                }
+                AutoTunnelEvent.StopKillSwitch -> {
+                    Timber.d("Stopping kill switch")
+                    tunnelManager.setBackendState(BackendState.SERVICE_ACTIVE, emptySet())
+                }
+            }
+        }
+    }
+
+    private suspend fun handleBounceWithBackoff(
+        configsPeerKeyResolvedMap: List<Pair<TunnelConf, Map<String, String?>>>
+    ) { // Simplified param: no failureCount
+        val settings = appDataRepository.get().settings.get()
+        val pingIntervalMillis = settings.tunnelPingIntervalSeconds.toMillis()
+        configsPeerKeyResolvedMap.forEach { (config, peerMap) ->
+            val bounceCount = bounceCounts.value.getOrDefault(config.id, 0)
+            val exponent = bounceCount.toDouble()
+            val backoffDelay =
+                (pingIntervalMillis * 2.0.pow(exponent)).toLong().coerceAtMost(MAX_BACKOFF_MS)
+            val currentTime = System.currentTimeMillis()
+            val lastTime = lastBounceTimes.getOrDefault(config.id, 0L)
+            if (currentTime - lastTime >= backoffDelay) {
+                Timber.d(
+                    "Bouncing tunnel ${config.name} after detecting failure, with bounce count $bounceCount and calculated backoff delay $backoffDelay ms"
+                )
+                tunnelManager.bounceTunnel(config, Ping(peerMap))
+                lastBounceTimes[config.id] = currentTime
+                bounceCounts.update { current ->
+                    current.toMutableMap().apply { this[config.id] = (this[config.id] ?: 0) + 1 }
+                }
+            } else {
+                Timber.d(
+                    "Backoff in progress for tunnel ${config.name}, skipping bounce (required delay: $backoffDelay ms)"
+                )
+            }
+        }
+    }
+
+    @OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
+    private val debouncedConnectivityStateFlow: Flow<ConnectivityState> by lazy {
+        appDataRepository
+            .get()
+            .settings
+            .flow
+            .map { it.debounceDelaySeconds.toMillis() }
+            .distinctUntilChanged()
+            .flatMapLatest { debounceMillis ->
+                networkMonitor.connectivityStateFlow.debounce(debounceMillis)
+            }
+    }
+
+    companion object {
+        // try to keep this window short as it will interrupt manual overrides
+        const val REEVALUATE_CHECK_DELAY = 2_000L
+        const val MAX_BACKOFF_MS = 300_000L // 5 minutes
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/service/autotunnel/StateChange.kt

@@ -0,0 +1,20 @@
+package com.zaneschepke.wireguardautotunnel.core.service.autotunnel
+
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.state.NetworkState
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
+import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
+import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
+import org.amnezia.awg.crypto.Key
+
+sealed class StateChange {
+    data class NetworkChange(val networkState: NetworkState) : StateChange()
+
+    data class SettingsChange(val settings: AppSettings, val tunnels: Tunnels) : StateChange()
+
+    data class ActiveTunnelsChange(val activeTunnels: Map<TunnelConf, TunnelState>) : StateChange()
+
+    data class MonitoringChange(val pingStates: Map<TunnelConf, Map<Key, PingState>?>) :
+        StateChange()
+}

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

@@ -11,97 +11,94 @@ import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class AutoTunnelControlTile : TileService(), LifecycleOwner {
-	@Inject
-	lateinit var appDataRepository: AppDataRepository
+    @Inject lateinit var appDataRepository: AppDataRepository
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
+    private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
 
-	override fun onCreate() {
-		super.onCreate()
-		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
-	}
+    override fun onCreate() {
+        super.onCreate()
+        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+    }
 
-	override fun onDestroy() {
-		super.onDestroy()
-		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
-	}
+    override fun onDestroy() {
+        super.onDestroy()
+        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+    }
 
-	override fun onStartListening() {
-		super.onStartListening()
-		Timber.d("Start listening called for auto tunnel tile")
-		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
-		lifecycleScope.launch {
-			serviceManager.autoTunnelActive.collect {
-				if (it) setActive() else setInactive()
-			}
-		}
-		lifecycleScope.launch {
-			appDataRepository.tunnels.flow.collect {
-				if (it.isEmpty()) {
-					setUnavailable()
-				} else {
-					if (qsTile.state == Tile.STATE_ACTIVE) setInactive()
-				}
-			}
-		}
-	}
+    override fun onStartListening() {
+        super.onStartListening()
+        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
+        Timber.d("Start listening called for auto tunnel tile")
+        lifecycleScope.launch {
+            serviceManager.autoTunnelService.collect {
+                if (it != null) return@collect setActive()
+                setInactive()
+            }
+        }
+        lifecycleScope.launch {
+            appDataRepository.tunnels.flow.collect {
+                if (it.isEmpty()) {
+                    setUnavailable()
+                }
+            }
+        }
+    }
 
-	override fun onClick() {
-		super.onClick()
-		unlockAndRun {
-			lifecycleScope.launch {
-				if (serviceManager.autoTunnelActive.value) {
-					serviceManager.stopAutoTunnel()
-					setInactive()
-				} else {
-					serviceManager.startAutoTunnel()
-					setActive()
-				}
-			}
-		}
-	}
+    override fun onClick() {
+        super.onClick()
+        unlockAndRun {
+            lifecycleScope.launch {
+                if (serviceManager.autoTunnelService.value != null) {
+                    serviceManager.stopAutoTunnel()
+                    setInactive()
+                } else {
+                    serviceManager.startAutoTunnel()
+                    setActive()
+                }
+            }
+        }
+    }
 
-	private fun setActive() {
-		runCatching {
-			qsTile.state = Tile.STATE_ACTIVE
-			qsTile.updateTile()
-		}
-	}
+    private fun setActive() {
+        runCatching {
+            qsTile.state = Tile.STATE_ACTIVE
+            qsTile.updateTile()
+        }
+    }
 
-	private fun setInactive() {
-		runCatching {
-			qsTile.state = Tile.STATE_INACTIVE
-			qsTile.updateTile()
-		}
-	}
+    private fun setInactive() {
+        runCatching {
+            qsTile.state = Tile.STATE_INACTIVE
+            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
-	}
+    /* 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
+    }
 
-	private fun setUnavailable() {
-		runCatching {
-			qsTile.state = Tile.STATE_UNAVAILABLE
-			qsTile.updateTile()
-		}
-	}
+    private fun setUnavailable() {
+        runCatching {
+            qsTile.state = Tile.STATE_UNAVAILABLE
+            qsTile.updateTile()
+        }
+    }
 
-	override val lifecycle: Lifecycle
-		get() = lifecycleRegistry
+    override val lifecycle: Lifecycle
+        get() = lifecycleRegistry
 }

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

@@ -10,133 +10,175 @@ import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.LifecycleRegistry
 import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class TunnelControlTile : TileService(), LifecycleOwner {
-	@Inject
-	lateinit var appDataRepository: AppDataRepository
+    @Inject lateinit var appDataRepository: AppDataRepository
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
+    private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
 
-	private var isCollecting = false
+    private var isCollecting = false
 
-	override fun onCreate() {
-		super.onCreate()
-		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
-	}
+    override fun onCreate() {
+        super.onCreate()
+        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+    }
 
-	override fun onDestroy() {
-		super.onDestroy()
-		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
-	}
+    override fun onDestroy() {
+        super.onDestroy()
+        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+    }
 
-	override fun onStartListening() {
-		super.onStartListening()
-		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
-		Timber.d("Start listening called for tunnel tile")
-		if (isCollecting) return
-		isCollecting = true
-		lifecycleScope.launch {
-			tunnelManager.activeTunnels.collect {
-				updateTileState()
-			}
-		}
-	}
+    override fun onStartListening() {
+        super.onStartListening()
+        lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
+        Timber.d("Start listening called for tunnel tile")
+        if (isCollecting) return
+        isCollecting = true
+        lifecycleScope.launch { tunnelManager.activeTunnels.collect { updateTileState() } }
+    }
 
-	private fun updateTileState() = lifecycleScope.launch {
-		val tunnels = appDataRepository.tunnels.getAll()
-		if (tunnels.isEmpty()) return@launch setUnavailable()
-		with(tunnelManager.activeTunnels.value) {
-			if (isNotEmpty()) if (size == 1) {
-				tunnels.firstOrNull { it.id == keys.first().id }?.let { return@launch updateTile(it.tunName, true) }
-			} else {
-				return@launch updateTile(getString(R.string.multiple), true)
-			}
-		}
-		appDataRepository.getStartTunnelConfig()?.let {
-			updateTile(it.tunName, false)
-		}
-	}
+    private suspend fun updateTileState() {
+        try {
+            val tunnels = appDataRepository.tunnels.getAll()
+            if (tunnels.isEmpty()) {
+                setUnavailable()
+                return
+            }
 
-	override fun onClick() {
-		super.onClick()
-		unlockAndRun {
-			lifecycleScope.launch {
-				if (tunnelManager.activeTunnels.value.isNotEmpty()) return@launch tunnelManager.stopTunnel()
-				appDataRepository.getStartTunnelConfig()?.let {
-					tunnelManager.startTunnel(it)
-				}
-			}
-		}
-	}
+            val activeTunnels =
+                tunnelManager.activeTunnels.value.filter { it.value.status.isUpOrStarting() }
 
-	private fun setActive() {
-		runCatching {
-			qsTile.state = Tile.STATE_ACTIVE
-			qsTile.updateTile()
-		}
-	}
+            when {
+                activeTunnels.isNotEmpty() -> {
+                    val activeIds = activeTunnels.map { it.key.id }
+                    // TODO improvements would be needed to make this work well with toggling
+                    // multiple tunnels
+                    // this would be better managed elsewhere
+                    WireGuardAutoTunnel.setLastActiveTunnels(activeIds)
+                    updateTileForActiveTunnels(activeTunnels)
+                }
+                else -> updateTileForLastActiveTunnels()
+            }
+        } catch (e: Exception) {
+            setUnavailable()
+        }
+    }
 
-	private fun setInactive() {
-		runCatching {
-			qsTile.state = Tile.STATE_INACTIVE
-			qsTile.updateTile()
-		}
-	}
+    private fun updateTileForActiveTunnels(activeTunnels: Map<TunnelConf, TunnelState>) {
+        val tileName =
+            when (activeTunnels.size) {
+                1 -> activeTunnels.keys.first().tunName
+                else -> getString(R.string.multiple)
+            }
+        updateTile(tileName, true)
+    }
 
-	private fun setUnavailable() {
-		runCatching {
-			qsTile.state = Tile.STATE_UNAVAILABLE
-			setTileDescription("")
-			qsTile.updateTile()
-		}
-	}
+    private suspend fun updateTileForLastActiveTunnels() {
+        val lastActiveIds = WireGuardAutoTunnel.getLastActiveTunnels()
+        when {
+            lastActiveIds.isEmpty() -> {
+                appDataRepository.getStartTunnelConfig()?.let { config ->
+                    updateTile(config.tunName, false)
+                } ?: setUnavailable()
+            }
+            lastActiveIds.size > 1 -> updateTile(getString(R.string.multiple), false)
+            else -> {
+                val tunnelId = lastActiveIds.first()
+                appDataRepository.tunnels.getById(tunnelId)?.let { tunnel ->
+                    updateTile(tunnel.tunName, false)
+                } ?: setUnavailable()
+            }
+        }
+    }
 
-	private fun setTileDescription(description: String) {
-		runCatching {
-			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()
-		}
-	}
+    override fun onClick() {
+        super.onClick()
+        unlockAndRun {
+            lifecycleScope.launch {
+                if (tunnelManager.activeTunnels.value.isNotEmpty())
+                    return@launch tunnelManager.stopTunnel()
+                val lastActive = WireGuardAutoTunnel.getLastActiveTunnels()
+                if (lastActive.isEmpty()) {
+                    appDataRepository.getStartTunnelConfig()?.let { tunnelManager.startTunnel(it) }
+                } else {
+                    lastActive.forEach { id ->
+                        appDataRepository.tunnels.getById(id)?.let { tunnelManager.startTunnel(it) }
+                    }
+                }
+            }
+        }
+    }
 
-	/* 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
-	}
+    private fun setActive() {
+        runCatching {
+            qsTile.state = Tile.STATE_ACTIVE
+            qsTile.updateTile()
+        }
+    }
 
-	private fun updateTile(name: String, active: Boolean) {
-		runCatching {
-			setTileDescription(name)
-			if (active) return setActive()
-			setInactive()
-		}.onFailure {
-			Timber.e(it)
-		}
-	}
-	override val lifecycle: Lifecycle
-		get() = lifecycleRegistry
+    private fun setInactive() {
+        runCatching {
+            qsTile.state = Tile.STATE_INACTIVE
+            qsTile.updateTile()
+        }
+    }
+
+    private fun setUnavailable() {
+        runCatching {
+            qsTile.state = Tile.STATE_UNAVAILABLE
+            setTileDescription("")
+            qsTile.updateTile()
+        }
+    }
+
+    private fun setTileDescription(description: String) {
+        runCatching {
+            if (qsTile == null) return@runCatching
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                qsTile.subtitle = description
+                qsTile.stateDescription = description
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                qsTile.subtitle = 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
+    }
+
+    private fun updateTile(name: String, active: Boolean) {
+        runCatching {
+                setTileDescription(name)
+                if (active) return setActive()
+                setInactive()
+            }
+            .onFailure { Timber.e(it) }
+    }
+
+    override val lifecycle: Lifecycle
+        get() = lifecycleRegistry
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/shortcut/DynamicShortcutManager.kt

@@ -10,70 +10,83 @@ import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
 
-class DynamicShortcutManager(private val context: Context, @IoDispatcher private val ioDispatcher: CoroutineDispatcher) : ShortcutManager {
-	override suspend fun addShortcuts() {
-		withContext(ioDispatcher) {
-			ShortcutManagerCompat.setDynamicShortcuts(context, createShortcuts())
-		}
-	}
+class DynamicShortcutManager(
+    private val context: Context,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+) : ShortcutManager {
+    override suspend fun addShortcuts() {
+        withContext(ioDispatcher) {
+            ShortcutManagerCompat.setDynamicShortcuts(context, createShortcuts())
+        }
+    }
 
-	override suspend fun removeShortcuts() {
-		withContext(ioDispatcher) {
-			ShortcutManagerCompat.removeDynamicShortcuts(context, createShortcuts().map { it.id })
-		}
-	}
+    override suspend fun removeShortcuts() {
+        withContext(ioDispatcher) {
+            ShortcutManagerCompat.removeDynamicShortcuts(context, createShortcuts().map { it.id })
+        }
+    }
 
-	private fun createShortcuts(): List<ShortcutInfoCompat> {
-		return listOf(
-			buildShortcut(
-				context.getString(R.string.vpn_off),
-				context.getString(R.string.vpn_off),
-				context.getString(R.string.vpn_off),
-				intent = Intent(context, ShortcutsActivity::class.java).apply {
-					putExtra("className", "WireGuardTunnelService")
-					action = ShortcutsActivity.Action.STOP.name
-				},
-				shortcutIcon = R.drawable.vpn_off,
-			),
-			buildShortcut(
-				context.getString(R.string.vpn_on),
-				context.getString(R.string.vpn_on),
-				context.getString(R.string.vpn_on),
-				intent = Intent(context, ShortcutsActivity::class.java).apply {
-					putExtra("className", "WireGuardTunnelService")
-					action = ShortcutsActivity.Action.START.name
-				},
-				shortcutIcon = R.drawable.vpn_on,
-			),
-			buildShortcut(
-				context.getString(R.string.start_auto),
-				context.getString(R.string.start_auto),
-				context.getString(R.string.start_auto),
-				intent = Intent(context, ShortcutsActivity::class.java).apply {
-					putExtra("className", "WireGuardConnectivityWatcherService")
-					action = ShortcutsActivity.Action.START.name
-				},
-				shortcutIcon = R.drawable.auto_play,
-			),
-			buildShortcut(
-				context.getString(R.string.stop_auto),
-				context.getString(R.string.stop_auto),
-				context.getString(R.string.stop_auto),
-				intent = Intent(context, ShortcutsActivity::class.java).apply {
-					putExtra("className", "WireGuardConnectivityWatcherService")
-					action = ShortcutsActivity.Action.STOP.name
-				},
-				shortcutIcon = R.drawable.auto_pause,
-			),
-		)
-	}
+    private fun createShortcuts(): List<ShortcutInfoCompat> {
+        return listOf(
+            buildShortcut(
+                context.getString(R.string.vpn_off),
+                context.getString(R.string.vpn_off),
+                context.getString(R.string.vpn_off),
+                intent =
+                    Intent(context, ShortcutsActivity::class.java).apply {
+                        putExtra("className", "WireGuardTunnelService")
+                        action = ShortcutsActivity.Action.STOP.name
+                    },
+                shortcutIcon = R.drawable.vpn_off,
+            ),
+            buildShortcut(
+                context.getString(R.string.vpn_on),
+                context.getString(R.string.vpn_on),
+                context.getString(R.string.vpn_on),
+                intent =
+                    Intent(context, ShortcutsActivity::class.java).apply {
+                        putExtra("className", "WireGuardTunnelService")
+                        action = ShortcutsActivity.Action.START.name
+                    },
+                shortcutIcon = R.drawable.vpn_on,
+            ),
+            buildShortcut(
+                context.getString(R.string.start_auto),
+                context.getString(R.string.start_auto),
+                context.getString(R.string.start_auto),
+                intent =
+                    Intent(context, ShortcutsActivity::class.java).apply {
+                        putExtra("className", "WireGuardConnectivityWatcherService")
+                        action = ShortcutsActivity.Action.START.name
+                    },
+                shortcutIcon = R.drawable.auto_play,
+            ),
+            buildShortcut(
+                context.getString(R.string.stop_auto),
+                context.getString(R.string.stop_auto),
+                context.getString(R.string.stop_auto),
+                intent =
+                    Intent(context, ShortcutsActivity::class.java).apply {
+                        putExtra("className", "WireGuardConnectivityWatcherService")
+                        action = ShortcutsActivity.Action.STOP.name
+                    },
+                shortcutIcon = R.drawable.auto_pause,
+            ),
+        )
+    }
 
-	private fun buildShortcut(id: String, shortLabel: String, longLabel: String, intent: Intent, shortcutIcon: Int): ShortcutInfoCompat {
-		return ShortcutInfoCompat.Builder(context, id)
-			.setShortLabel(shortLabel)
-			.setLongLabel(longLabel)
-			.setIntent(intent)
-			.setIcon(IconCompat.createWithResource(context, shortcutIcon))
-			.build()
-	}
+    private fun buildShortcut(
+        id: String,
+        shortLabel: String,
+        longLabel: String,
+        intent: Intent,
+        shortcutIcon: Int,
+    ): ShortcutInfoCompat {
+        return ShortcutInfoCompat.Builder(context, id)
+            .setShortLabel(shortLabel)
+            .setLongLabel(longLabel)
+            .setIntent(intent)
+            .setIcon(IconCompat.createWithResource(context, shortcutIcon))
+            .build()
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/shortcut/ShortcutManager.kt

@@ -1,6 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.core.shortcut
 
 interface ShortcutManager {
-	suspend fun addShortcuts()
-	suspend fun removeShortcuts()
+    suspend fun addShortcuts()
+
+    suspend fun removeShortcuts()
 }

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

@@ -9,69 +9,68 @@ import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelProvider
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import dagger.hilt.android.AndroidEntryPoint
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class ShortcutsActivity : ComponentActivity() {
-	@Inject
-	lateinit var appDataRepository: AppDataRepository
+    @Inject lateinit var appDataRepository: AppDataRepository
 
-	@Inject
-	lateinit var serviceManager: ServiceManager
+    @Inject lateinit var serviceManager: ServiceManager
 
-	@Inject
-	lateinit var tunnelManager: TunnelManager
+    @Inject lateinit var tunnelManager: TunnelManager
 
-	@Inject
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
+    @Inject @ApplicationScope lateinit var applicationScope: CoroutineScope
 
-	override fun onCreate(savedInstanceState: Bundle?) {
-		super.onCreate(savedInstanceState)
-		applicationScope.launch {
-			val settings = appDataRepository.settings.get()
-			if (settings.isShortcutsEnabled) {
-				when (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)) {
-					LEGACY_TUNNEL_SERVICE_NAME, TunnelProvider::class.java.simpleName -> {
-						val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
-						Timber.d("Tunnel name extra: $tunnelName")
-						val tunnelConfig = tunnelName?.let {
-							appDataRepository.tunnels.getAll()
-								.firstOrNull { it.tunName == tunnelName }
-						} ?: appDataRepository.getStartTunnelConfig()
-						Timber.d("Shortcut action on name: ${tunnelConfig?.tunName}")
-						tunnelConfig?.let {
-							when (intent.action) {
-								Action.START.name -> tunnelManager.startTunnel(it)
-								Action.STOP.name -> tunnelManager.stopTunnel()
-								else -> Unit
-							}
-						}
-					}
-					AutoTunnelService::class.java.simpleName, LEGACY_AUTO_TUNNEL_SERVICE_NAME -> {
-						when (intent.action) {
-							Action.START.name -> serviceManager.startAutoTunnel()
-							Action.STOP.name -> serviceManager.stopAutoTunnel()
-						}
-					}
-				}
-			}
-		}
-		finish()
-	}
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        applicationScope.launch {
+            val settings = appDataRepository.settings.get()
+            if (settings.isShortcutsEnabled) {
+                when (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)) {
+                    LEGACY_TUNNEL_SERVICE_NAME,
+                    TunnelProvider::class.java.simpleName -> {
+                        val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
+                        Timber.d("Tunnel name extra: $tunnelName")
+                        val tunnelConfig =
+                            tunnelName?.let {
+                                appDataRepository.tunnels.getAll().firstOrNull {
+                                    it.tunName == tunnelName
+                                }
+                            } ?: appDataRepository.getStartTunnelConfig()
+                        Timber.d("Shortcut action on name: ${tunnelConfig?.tunName}")
+                        tunnelConfig?.let {
+                            when (intent.action) {
+                                Action.START.name -> tunnelManager.startTunnel(it)
+                                Action.STOP.name -> tunnelManager.stopTunnel()
+                                else -> Unit
+                            }
+                        }
+                    }
+                    AutoTunnelService::class.java.simpleName,
+                    LEGACY_AUTO_TUNNEL_SERVICE_NAME -> {
+                        when (intent.action) {
+                            Action.START.name -> serviceManager.startAutoTunnel()
+                            Action.STOP.name -> serviceManager.stopAutoTunnel()
+                        }
+                    }
+                }
+            }
+        }
+        finish()
+    }
 
-	enum class Action {
-		START,
-		STOP,
-	}
+    enum class Action {
+        START,
+        STOP,
+    }
 
-	companion object {
-		const val LEGACY_TUNNEL_SERVICE_NAME = "WireGuardTunnelService"
-		const val LEGACY_AUTO_TUNNEL_SERVICE_NAME = "WireGuardConnectivityWatcherService"
-		const val TUNNEL_NAME_EXTRA_KEY = "tunnelName"
-		const val CLASS_NAME_EXTRA_KEY = "className"
-	}
+    companion object {
+        const val LEGACY_TUNNEL_SERVICE_NAME = "WireGuardTunnelService"
+        const val LEGACY_AUTO_TUNNEL_SERVICE_NAME = "WireGuardConnectivityWatcherService"
+        const val TUNNEL_NAME_EXTRA_KEY = "tunnelName"
+        const val CLASS_NAME_EXTRA_KEY = "className"
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/BaseTunnel.kt

@@ -1,213 +1,292 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel
 
-import com.wireguard.android.backend.BackendException
 import com.wireguard.android.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
-import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
-import com.zaneschepke.wireguardautotunnel.domain.enums.BackendError
 import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
-import com.zaneschepke.wireguardautotunnel.ui.common.snackbar.SnackbarController
-import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.ui.state.ConfigProxy
 import com.zaneschepke.wireguardautotunnel.util.extensions.asTunnelState
-import com.zaneschepke.wireguardautotunnel.util.extensions.toBackendError
-import kotlinx.coroutines.CoroutineDispatcher
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.coroutines.cancellation.CancellationException
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import org.amnezia.awg.crypto.Key
 import timber.log.Timber
-import java.util.concurrent.atomic.AtomicBoolean
 
 abstract class BaseTunnel(
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-	@ApplicationScope private val applicationScope: CoroutineScope,
-	private val appDataRepository: AppDataRepository,
-	private val serviceManager: ServiceManager,
-	private val notificationManager: NotificationManager,
+    private val applicationScope: CoroutineScope,
+    private val appDataRepository: AppDataRepository,
+    private val serviceManager: ServiceManager,
 ) : TunnelProvider {
 
-	private val activeTuns = MutableStateFlow<Map<TunnelConf, TunnelState>>(emptyMap())
-	override val activeTunnels = activeTuns.asStateFlow()
+    private val _errorEvents = MutableSharedFlow<Pair<TunnelConf, BackendError>>()
+    override val errorEvents = _errorEvents.asSharedFlow()
 
-	private val isBounce = AtomicBoolean(false)
+    private val _messageEvents = MutableSharedFlow<Pair<TunnelConf, BackendMessage>>()
+    override val messageEvents = _messageEvents.asSharedFlow()
 
-	private val mutex = Mutex()
+    private val activeTuns = MutableStateFlow<Map<TunnelConf, TunnelState>>(emptyMap())
+    private val tunJobs = ConcurrentHashMap<Int, Job>()
+    override val activeTunnels = activeTuns.asStateFlow()
 
-	abstract suspend fun startBackend(tunnel: TunnelConf)
+    private val tunMutex = Mutex()
+    private val tunStatusMutex = Mutex()
+    private val bounceTunnelMutex = Mutex()
 
-	abstract fun stopBackend(tunnel: TunnelConf)
+    override val bouncingTunnelIds = ConcurrentHashMap<Int, TunnelStatus.StopReason>()
 
-	private fun findActiveTunnel(id: Int): TunnelConf? = activeTuns.value.keys.find { it.id == id }
+    abstract suspend fun startBackend(tunnel: TunnelConf)
 
-	private fun isTunnelActive(id: Int) = (activeTuns.value.any { it.key.id == id })
+    abstract fun stopBackend(tunnel: TunnelConf)
 
-	private fun handleBackendThrowable(throwable: Throwable) {
-		val backendError = when (throwable) {
-			is BackendException -> throwable.toBackendError()
-			is org.amnezia.awg.backend.BackendException -> throwable.toBackendError()
-			else -> BackendError.Unknown
-		}
-		val message = when (backendError) {
-			BackendError.Config -> StringValue.StringResource(R.string.start_failed_config)
-			BackendError.DNS -> StringValue.StringResource(R.string.dns_error)
-			BackendError.Unauthorized -> StringValue.StringResource(R.string.unauthorized)
-			BackendError.Unknown -> StringValue.StringResource(R.string.unknown_error)
-		}
-		if (WireGuardAutoTunnel.isForeground()) {
-			SnackbarController.showMessage(message)
-		} else {
-			notificationManager.show(
-				NotificationManager.VPN_NOTIFICATION_ID,
-				notificationManager.createNotification(
-					WireGuardNotification.NotificationChannels.VPN,
-					title = StringValue.StringResource(R.string.tunne_start_failed_title),
-					description = message,
-				),
-			)
-		}
-	}
+    override fun hasVpnPermission(): Boolean {
+        return serviceManager.hasVpnPermission()
+    }
 
-	private fun updateTunnelState(tunnelConf: TunnelConf, state: TunnelStatus? = null, stats: TunnelStatistics? = null) {
-		applicationScope.launch(ioDispatcher) {
-			mutex.withLock {
-				activeTuns.update { current ->
-					val originalConf = current.getKeyById(tunnelConf.id) ?: tunnelConf
-					val existingState = current.getValueById(tunnelConf.id) ?: TunnelState()
-					val newState = state ?: existingState.state
-					if (newState == TunnelStatus.DOWN) {
-						Timber.d("Removing tunnel ${tunnelConf.id} from activeTunnels as state is DOWN")
-						current - originalConf
-					} else if (existingState.state == newState && stats == null) {
-						Timber.d("Skipping redundant state update for ${tunnelConf.id}: $newState")
-						current
-					} else {
-						val updated = existingState.copy(
-							state = newState,
-							statistics = stats ?: existingState.statistics,
-						)
-						current + (originalConf to updated)
-					}
-				}
-			}
-		}
-	}
+    override suspend fun updateTunnelStatus(
+        tunnelConf: TunnelConf,
+        status: TunnelStatus?,
+        stats: TunnelStatistics?,
+        pingStates: Map<Key, PingState>?,
+        handshakeSuccessLogs: Boolean?,
+    ) {
+        tunStatusMutex.withLock {
+            activeTuns.update { currentTuns ->
+                val originalConf = currentTuns.getKeyById(tunnelConf.id) ?: tunnelConf
+                val existingState = currentTuns.getValueById(tunnelConf.id) ?: TunnelState()
+                val newStatus = status ?: existingState.status
+                if (newStatus == TunnelStatus.Down) {
+                    Timber.d("Removing tunnel ${tunnelConf.id} from activeTunnels as state is DOWN")
+                    cleanUpTunJob(tunnelConf)
+                    currentTuns - originalConf
+                } else if (
+                    existingState.status == newStatus &&
+                        stats == null &&
+                        pingStates == null &&
+                        handshakeSuccessLogs == null
+                ) {
+                    Timber.d("Skipping redundant state update for ${tunnelConf.id}: $newStatus")
+                    currentTuns
+                } else {
+                    val updated =
+                        existingState.copy(
+                            status = newStatus,
+                            statistics = stats ?: existingState.statistics,
+                            pingStates = pingStates ?: existingState.pingStates,
+                            handshakeSuccessLogs =
+                                handshakeSuccessLogs ?: existingState.handshakeSuccessLogs,
+                        )
+                    currentTuns + (originalConf to updated)
+                }
+            }
+            handleServiceStateOnChange()
+        }
+    }
 
-	protected suspend fun stopActiveTunnels() {
-		activeTunnels.value.forEach { (config, state) ->
-			if (state.state.isUp()) {
-				stopTunnel(config)
-				delay(300)
-			}
-		}
-	}
+    private suspend fun stopActiveTunnels() {
+        activeTunnels.value.forEach { (config, state) ->
+            if (state.status.isUpOrStarting()) {
+                stopTunnel(config)
+            }
+        }
+    }
 
-	private fun configureTunnelCallbacks(tunnelConf: TunnelConf) {
-		Timber.d("Configuring TunnelConf instance: ${tunnelConf.hashCode()}")
+    private fun configureTunnelCallbacks(tunnelConf: TunnelConf) {
+        Timber.d("Configuring TunnelConf instance: ${tunnelConf.hashCode()}")
+        tunnelConf.setStateChangeCallback { state ->
+            applicationScope.launch {
+                Timber.d(
+                    "State change callback triggered for tunnel ${tunnelConf.id}: ${tunnelConf.tunName} with state $state at ${System.currentTimeMillis()}"
+                )
+                when (state) {
+                    is Tunnel.State -> updateTunnelStatus(tunnelConf, state.asTunnelState())
+                    is org.amnezia.awg.backend.Tunnel.State ->
+                        updateTunnelStatus(tunnelConf, state.asTunnelState())
+                }
+                handleServiceStateOnChange()
+            }
+            serviceManager.updateTunnelTile()
+        }
+    }
 
-		tunnelConf.setStateChangeCallback { state ->
-			Timber.d("State change callback triggered for tunnel ${tunnelConf.id}: ${tunnelConf.tunName} with state $state at ${System.currentTimeMillis()}")
-			when (state) {
-				is Tunnel.State -> updateTunnelState(tunnelConf, state.asTunnelState())
-				is org.amnezia.awg.backend.Tunnel.State -> updateTunnelState(tunnelConf, state.asTunnelState())
-			}
-			serviceManager.updateTunnelTile()
-		}
-		tunnelConf.setTunnelStatsCallback {
-			val stats = getStatistics(tunnelConf)
-			updateTunnelState(tunnelConf, null, stats)
-		}
-		tunnelConf.setBounceTunnelCallback(::bounceTunnel)
-	}
+    override suspend fun startTunnel(tunnelConf: TunnelConf) {
+        if (activeTuns.exists(tunnelConf.id) || tunJobs.containsKey(tunnelConf.id))
+            return Timber.w("Tunnel is already running ${tunnelConf.name}")
+        // For userspace, we need to make sure all previous tunnels are down
+        if (this@BaseTunnel is UserspaceTunnel) stopActiveTunnels()
+        tunMutex.withLock {
+            val job =
+                applicationScope.launch {
+                    try {
+                        Timber.d("Starting tunnel ${tunnelConf.id}...")
+                        startTunnelInner(tunnelConf)
+                        Timber.d("Started complete for tunnel ${tunnelConf.name}...")
+                        // catch cancellation that could occur before and during startTunnelInner
+                        // and trigger at that suspend point
+                    } catch (e: CancellationException) {
+                        Timber.w(
+                            "Tunnel start has been cancelled as ${tunnelConf.name} failed to start"
+                        )
+                    }
+                }
+            tunJobs[tunnelConf.id] = job
+            job.invokeOnCompletion {
+                tunJobs.remove(tunnelConf.id)
+                Timber.d("Start job completed for tunnel ${tunnelConf.id}")
+            }
+        }
+    }
 
-	override fun startTunnel(tunnelConf: TunnelConf) {
-		applicationScope.launch(ioDispatcher) {
-			runCatching {
-				if (isTunnelActive(tunnelConf.id)) return@launch
-				saveTunnelActiveState(tunnelConf, true)
-				startTunnelInner(tunnelConf)
-			}.onFailure { exception ->
-				Timber.e(exception, "Failed to start tunnel ${tunnelConf.id} userspace")
-				stopTunnel(tunnelConf)
-				handleBackendThrowable(exception)
-			}.onSuccess {
-				Timber.i("Tunnel ${tunnelConf.id} started successfully")
-			}
-		}
-	}
+    private suspend fun startTunnelInner(tunnelConf: TunnelConf) {
+        configureTunnelCallbacks(tunnelConf)
+        Timber.d("Starting backend for tunnel ${tunnelConf.id}...")
 
-	private suspend fun startTunnelInner(tunnelConf: TunnelConf) {
-		mutex.withLock {
-			configureTunnelCallbacks(tunnelConf)
-			startBackend(tunnelConf)
-			if (!isBounce.get()) serviceManager.startTunnelForegroundService(tunnelConf)
-		}
-	}
+        var currentConf = tunnelConf
+        var restoreAttempted = false
+        var originalError: BackendError? = null
 
-	private suspend fun saveTunnelActiveState(tunnelConf: TunnelConf, active: Boolean) {
-		val tunnelCopy = tunnelConf.copyWithCallback(isActive = active)
-		appDataRepository.tunnels.save(tunnelCopy)
-	}
+        while (true) {
+            try {
+                startBackend(currentConf)
+                updateTunnelStatus(currentConf, TunnelStatus.Up)
+                Timber.d("Started for tun ${currentConf.id}...")
+                saveTunnelActiveState(currentConf, true)
+                serviceManager.startTunnelForegroundService()
+                if (restoreAttempted)
+                    _messageEvents.emit(tunnelConf to BackendMessage.BounceRecovery)
+                if (bouncingTunnelIds[currentConf.id] is TunnelStatus.StopReason.Ping) {
+                    _messageEvents.emit(tunnelConf to BackendMessage.BounceSuccess)
+                }
+                return // Success, return
+            } catch (e: BackendError) {
+                originalError = originalError ?: e
+                val bounceReason = bouncingTunnelIds[currentConf.id]
+                if (!restoreAttempted && bounceReason is TunnelStatus.StopReason.Ping) {
+                    Timber.i(
+                        "Attempting to recover bounce failure with previously resolved endpoints for ${currentConf.name}"
+                    )
+                    try {
+                        val previouslyResolved = bounceReason.previouslyResolvedEndpoints
+                        val configProxy = ConfigProxy.from(currentConf.toAmConfig())
+                        val updatedConfigProxy =
+                            configProxy.copy(
+                                peers =
+                                    configProxy.peers.map {
+                                        it.copy(
+                                            endpoint =
+                                                previouslyResolved[it.publicKey] ?: it.endpoint
+                                        )
+                                    }
+                            )
+                        val (wg, amnezia) = updatedConfigProxy.buildConfigs()
+                        currentConf =
+                            currentConf.copyWithCallback(
+                                amQuick = amnezia.toAwgQuickString(true),
+                                wgQuick = wg.toWgQuickString(true),
+                            )
+                        bouncingTunnelIds.remove(currentConf.id)
+                        restoreAttempted = true
+                        continue // Retry
+                    } catch (e: Exception) {
+                        Timber.e(
+                            e,
+                            "Failed to update config with resolved endpoints for ${currentConf.name}",
+                        )
+                        // Fall through to failure (will emit BounceFailed since
+                        // retryAttempted=true)
+                    }
+                }
+                Timber.e(e, "Failed to start backend for ${currentConf.name}")
+                val emitError =
+                    if (restoreAttempted) BackendError.BounceFailed(originalError) else e
+                _errorEvents.emit(currentConf to emitError)
+                updateTunnelStatus(currentConf, TunnelStatus.Down)
+                return
+            }
+        }
+    }
 
-	override fun stopTunnel(tunnelConf: TunnelConf?) {
-		applicationScope.launch(ioDispatcher) {
-			runCatching {
-				if (tunnelConf == null) return@launch stopActiveTunnels()
-				stopTunnelInner(tunnelConf)
-			}.onFailure { e ->
-				Timber.e(e, "Failed to stop tunnel ${tunnelConf?.id}")
-			}
-		}
-	}
+    private suspend fun saveTunnelActiveState(tunnelConf: TunnelConf, active: Boolean) {
+        val tunnelCopy = tunnelConf.copyWithCallback(isActive = active)
+        appDataRepository.tunnels.save(tunnelCopy)
+    }
 
-	private suspend fun stopTunnelInner(tunnelConf: TunnelConf) {
-		mutex.withLock {
-			val tunnel = findActiveTunnel(tunnelConf.id) ?: return
-			saveTunnelActiveState(tunnelConf, false)
-			stopBackend(tunnel)
-			removeActiveTunnel(tunnel)
-			// use latest tunnel
-			handleServiceChangesOnStop()
-		}
-	}
+    override suspend fun stopTunnel(tunnelConf: TunnelConf?, reason: TunnelStatus.StopReason) {
+        if (tunnelConf == null) return stopActiveTunnels()
+        tunMutex.withLock {
+            if (activeTuns.isStarting(tunnelConf.id))
+                return handleStuckStartingTunnelShutdown(tunnelConf)
+            updateTunnelStatus(tunnelConf, TunnelStatus.Stopping(reason))
+            stopTunnelInner(tunnelConf)
+        }
+    }
 
-	private fun handleServiceChangesOnStop() {
-		if (activeTuns.value.isEmpty() && !isBounce.get()) return serviceManager.stopTunnelForegroundService()
-		val nextActive = activeTuns.value.keys.firstOrNull()
-		if (nextActive != null) {
-			Timber.d("Next active tunnel: ${nextActive.id}")
-			serviceManager.updateTunnelForegroundServiceNotification(nextActive)
-		}
-	}
+    private suspend fun stopTunnelInner(tunnelConf: TunnelConf) {
+        try {
+            val tunnel = activeTuns.findTunnel(tunnelConf.id) ?: return
+            stopBackend(tunnel)
+            saveTunnelActiveState(tunnelConf, false)
+            removeActiveTunnel(tunnel)
+        } catch (e: BackendError) {
+            Timber.e(e, "Failed to stop tunnel ${tunnelConf.id}")
+            _errorEvents.emit(tunnelConf to e)
+            updateTunnelStatus(tunnelConf, TunnelStatus.Down)
+        }
+    }
 
-	private fun removeActiveTunnel(tunnelConf: TunnelConf) {
-		activeTuns.update { current ->
-			current.toMutableMap().apply { remove(tunnelConf) }
-		}
-	}
+    private fun handleServiceStateOnChange() {
+        if (activeTuns.value.isEmpty()) serviceManager.stopTunnelForegroundService()
+    }
 
-	override fun bounceTunnel(tunnelConf: TunnelConf) {
-		applicationScope.launch(ioDispatcher) {
-			Timber.i("Bounce tunnel ${tunnelConf.name}")
-			isBounce.set(true)
-			stopTunnel(tunnelConf)
-			delay(300)
-			startTunnel(tunnelConf)
-			isBounce.set(false)
-		}
-	}
+    private suspend fun handleStuckStartingTunnelShutdown(tunnel: TunnelConf) {
+        Timber.d("Stuck in starting state so cancelling job for tunnel ${tunnel.name}")
+        try {
+            tunJobs[tunnel.id]?.cancel() ?: Timber.d("No job found for ${tunnel.name}")
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to cancel job for ${tunnel.name}")
+        } finally {
+            updateTunnelStatus(tunnel, TunnelStatus.Down)
+        }
+    }
 
-	override suspend fun runningTunnelNames(): Set<String> = activeTuns.value.keys.map { it.tunName }.toSet()
+    private fun cleanUpTunJob(tunnel: TunnelConf) {
+        Timber.d("Removing job for ${tunnel.name}")
+        tunJobs -= tunnel.id
+    }
+
+    private fun removeActiveTunnel(tunnelConf: TunnelConf) {
+        activeTuns.update { current -> current.toMutableMap().apply { remove(tunnelConf) } }
+    }
+
+    override suspend fun bounceTunnel(tunnelConf: TunnelConf, reason: TunnelStatus.StopReason) {
+        bounceTunnelMutex.withLock {
+            Timber.i(
+                "Bounce tunnel ${tunnelConf.name} for reason: $reason, current bouncing: ${bouncingTunnelIds.size}"
+            )
+            bouncingTunnelIds[tunnelConf.id] = reason
+            runCatching {
+                stopTunnel(tunnelConf, reason)
+                delay(BOUNCE_DELAY)
+                startTunnel(tunnelConf)
+            }
+        }
+    }
+
+    override suspend fun runningTunnelNames(): Set<String> =
+        activeTuns.value.keys.map { it.tunName }.toSet()
+
+    companion object {
+        const val BOUNCE_DELAY = 300L
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/Extensions.kt

@@ -1,25 +1,50 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel
 
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
+import kotlinx.coroutines.flow.MutableStateFlow
 
 fun Map<TunnelConf, TunnelState>.allDown(): Boolean {
-	return this.all { it.value.state.isDown() }
+    return this.all { it.value.status.isDown() }
 }
 
 fun Map<TunnelConf, TunnelState>.hasActive(): Boolean {
-	return this.any { it.value.state.isUp() }
+    return this.any { it.value.status.isUp() }
 }
 
 fun Map<TunnelConf, TunnelState>.getValueById(id: Int): TunnelState? {
-	val key = this.keys.find { it.id == id }
-	return key?.let { this@getValueById[it] }
+    val key = this.keys.find { it.id == id }
+    return key?.let { this@getValueById[it] }
 }
 
 fun Map<TunnelConf, TunnelState>.getKeyById(id: Int): TunnelConf? {
-	return this.keys.find { it.id == id }
+    return this.keys.find { it.id == id }
 }
 
 fun Map<TunnelConf, TunnelState>.isUp(tunnelConf: TunnelConf): Boolean {
-	return this.getValueById(tunnelConf.id)?.state?.isUp() ?: false
+    return this.getValueById(tunnelConf.id)?.status?.isUp() ?: false
+}
+
+fun MutableStateFlow<Map<TunnelConf, TunnelState>>.exists(id: Int): Boolean {
+    return this.value.any { it.key.id == id }
+}
+
+fun MutableStateFlow<Map<TunnelConf, TunnelState>>.isUp(id: Int): Boolean {
+    return this.value.any { it.key.id == id && it.value.status == TunnelStatus.Up }
+}
+
+fun MutableStateFlow<Map<TunnelConf, TunnelState>>.isStarting(id: Int): Boolean {
+    return this.value.any { it.key.id == id && it.value.status == TunnelStatus.Starting }
+}
+
+fun MutableStateFlow<Map<TunnelConf, TunnelState>>.findTunnel(id: Int): TunnelConf? {
+    return this.value.keys.find { it.id == id }
+}
+
+private val URL_PATTERN =
+    Regex("""^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}:[0-9]{1,5}$""")
+
+fun String.isUrl(): Boolean {
+    return URL_PATTERN.matches(this)
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/KernelTunnel.kt

@@ -1,53 +1,73 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel
 
 import com.wireguard.android.backend.Backend
+import com.wireguard.android.backend.BackendException
 import com.wireguard.android.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.domain.state.WireGuardStatistics
-import kotlinx.coroutines.CoroutineDispatcher
+import com.zaneschepke.wireguardautotunnel.util.extensions.toBackendError
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import timber.log.Timber
-import javax.inject.Inject
 
-class KernelTunnel @Inject constructor(
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-	@ApplicationScope private val applicationScope: CoroutineScope,
-	serviceManager: ServiceManager,
-	appDataRepository: AppDataRepository,
-	notificationManager: NotificationManager,
-	private val backend: Backend,
-) : BaseTunnel(ioDispatcher, applicationScope, appDataRepository, serviceManager, notificationManager) {
+class KernelTunnel
+@Inject
+constructor(
+    @ApplicationScope private val applicationScope: CoroutineScope,
+    serviceManager: ServiceManager,
+    appDataRepository: AppDataRepository,
+    private val backend: Backend,
+) : BaseTunnel(applicationScope, appDataRepository, serviceManager) {
 
-	override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
-		return try {
-			WireGuardStatistics(backend.getStatistics(tunnelConf))
-		} catch (e: Exception) {
-			Timber.e(e)
-			null
-		}
-	}
+    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
+        return try {
+            WireGuardStatistics(backend.getStatistics(tunnelConf))
+        } catch (e: Exception) {
+            Timber.e(e)
+            null
+        }
+    }
 
-	override suspend fun startBackend(tunnel: TunnelConf) {
-		backend.setState(tunnel, Tunnel.State.UP, tunnel.toWgConfig())
-	}
+    override suspend fun startBackend(tunnel: TunnelConf) {
+        // name too long for kernel mode
+        if (!tunnel.isNameKernelCompatible) throw BackendError.TunnelNameTooLong
+        try {
+            updateTunnelStatus(tunnel, TunnelStatus.Starting)
+            backend.setState(tunnel, Tunnel.State.UP, tunnel.toWgConfig())
+        } catch (e: BackendException) {
+            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
+            throw e.toBackendError()
+        } catch (e: IllegalArgumentException) {
+            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
+            throw BackendError.Config
+        }
+    }
 
-	override fun stopBackend(tunnel: TunnelConf) {
-		Timber.i("Stopping tunnel ${tunnel.id} kernel")
-		backend.setState(tunnel, Tunnel.State.DOWN, tunnel.toWgConfig())
-	}
+    override fun stopBackend(tunnel: TunnelConf) {
+        Timber.i("Stopping tunnel ${tunnel.id} kernel")
+        try {
+            backend.setState(tunnel, Tunnel.State.DOWN, tunnel.toWgConfig())
+        } catch (e: BackendException) {
+            throw e.toBackendError()
+        }
+    }
 
-	override suspend fun setBackendState(backendState: BackendState, allowedIps: Collection<String>) {
-		Timber.w("Not yet implemented for kernel")
-	}
+    override fun setBackendState(backendState: BackendState, allowedIps: Collection<String>) {
+        Timber.w("Not yet implemented for kernel")
+    }
 
-	override suspend fun runningTunnelNames(): Set<String> {
-		return backend.runningTunnelNames
-	}
+    override fun getBackendState(): BackendState {
+        return BackendState.INACTIVE
+    }
+
+    override suspend fun runningTunnelNames(): Set<String> {
+        return backend.runningTunnelNames
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/TunnelManager.kt

@@ -1,97 +1,135 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel
 
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.di.Kernel
-import com.zaneschepke.wireguardautotunnel.di.Userspace
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
+import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.plus
-import javax.inject.Inject
+import org.amnezia.awg.crypto.Key
 
-class TunnelManager @Inject constructor(
-	@Kernel private val kernelTunnel: TunnelProvider,
-	@Userspace private val userspaceTunnel: TunnelProvider,
-	private val appDataRepository: AppDataRepository,
-	@ApplicationScope private val applicationScope: CoroutineScope,
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+@OptIn(ExperimentalCoroutinesApi::class)
+class TunnelManager
+@Inject
+constructor(
+    private val kernelTunnel: TunnelProvider,
+    private val userspaceTunnel: TunnelProvider,
+    private val appDataRepository: AppDataRepository,
+    applicationScope: CoroutineScope,
+    ioDispatcher: CoroutineDispatcher,
 ) : TunnelProvider {
 
-	@OptIn(ExperimentalCoroutinesApi::class)
-	private val tunnelProviderFlow = appDataRepository.settings.flow
-		.filterNotNull()
-		.flatMapLatest { settings ->
-			MutableStateFlow(if (settings.isKernelEnabled) kernelTunnel else userspaceTunnel)
-		}
-		.stateIn(
-			scope = applicationScope.plus(ioDispatcher),
-			started = SharingStarted.Eagerly,
-			initialValue = userspaceTunnel,
-		)
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private val tunnelProviderFlow =
+        appDataRepository.settings.flow
+            .filterNotNull()
+            .flatMapLatest { settings ->
+                MutableStateFlow(if (settings.isKernelEnabled) kernelTunnel else userspaceTunnel)
+            }
+            .stateIn(
+                scope = applicationScope.plus(ioDispatcher),
+                started = SharingStarted.Eagerly,
+                initialValue = userspaceTunnel,
+            )
 
-	@OptIn(ExperimentalCoroutinesApi::class)
-	override val activeTunnels = appDataRepository.settings.flow
-		.filterNotNull()
-		.flatMapLatest { settings ->
-			if (settings.isKernelEnabled) {
-				kernelTunnel.activeTunnels
-			} else {
-				userspaceTunnel.activeTunnels
-			}
-		}
-		.stateIn(
-			scope = applicationScope.plus(ioDispatcher),
-			started = SharingStarted.Eagerly,
-			initialValue = emptyMap(),
-		)
+    override val activeTunnels: StateFlow<Map<TunnelConf, TunnelState>> =
+        tunnelProviderFlow.value.activeTunnels
 
-	override fun startTunnel(tunnelConf: TunnelConf) {
-		tunnelProviderFlow.value.startTunnel(tunnelConf)
-	}
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override val errorEvents: SharedFlow<Pair<TunnelConf, BackendError>> =
+        tunnelProviderFlow
+            .flatMapLatest { it.errorEvents }
+            .shareIn(
+                scope = applicationScope.plus(ioDispatcher),
+                started = SharingStarted.Eagerly,
+                replay = 0,
+            )
 
-	override fun stopTunnel(tunnelConf: TunnelConf?) {
-		tunnelProviderFlow.value.stopTunnel(tunnelConf)
-	}
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override val messageEvents: SharedFlow<Pair<TunnelConf, BackendMessage>> =
+        tunnelProviderFlow
+            .flatMapLatest { it.messageEvents }
+            .filterNotNull()
+            .shareIn(
+                scope = applicationScope.plus(ioDispatcher),
+                started = SharingStarted.Eagerly,
+                replay = 0,
+            )
 
-	override fun bounceTunnel(tunnelConf: TunnelConf) {
-		tunnelProviderFlow.value.bounceTunnel(tunnelConf)
-	}
+    override val bouncingTunnelIds: ConcurrentHashMap<Int, TunnelStatus.StopReason> =
+        tunnelProviderFlow.value.bouncingTunnelIds
 
-	override suspend fun setBackendState(backendState: BackendState, allowedIps: Collection<String>) {
-		tunnelProviderFlow.value.setBackendState(backendState, allowedIps)
-	}
+    override fun hasVpnPermission(): Boolean {
+        return userspaceTunnel.hasVpnPermission()
+    }
 
-	override suspend fun runningTunnelNames(): Set<String> {
-		return tunnelProviderFlow.value.runningTunnelNames()
-	}
+    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
+        return tunnelProviderFlow.value.getStatistics(tunnelConf)
+    }
 
-	override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
-		return tunnelProviderFlow.value.getStatistics(tunnelConf)
-	}
+    override suspend fun startTunnel(tunnelConf: TunnelConf) {
+        tunnelProviderFlow.value.startTunnel(tunnelConf)
+    }
 
-	fun restorePreviousState() = applicationScope.launch(ioDispatcher) {
-		val settings = appDataRepository.settings.get()
-		if (settings.isRestoreOnBootEnabled) {
-			val previouslyActiveTuns = appDataRepository.tunnels.getActive()
-			val tunsToStart = previouslyActiveTuns.filterNot { tun -> activeTunnels.value.any { tun.id == it.key.id } }
-			if (settings.isKernelEnabled) {
-				return@launch tunsToStart.forEach {
-					startTunnel(it)
-				}
-			} else {
-				tunsToStart.firstOrNull()?.let { startTunnel(it) }
-			}
-		}
-	}
+    override suspend fun stopTunnel(tunnelConf: TunnelConf?, reason: TunnelStatus.StopReason) {
+        tunnelProviderFlow.value.stopTunnel(tunnelConf, reason)
+    }
+
+    override suspend fun bounceTunnel(tunnelConf: TunnelConf, reason: TunnelStatus.StopReason) {
+        tunnelProviderFlow.value.bounceTunnel(tunnelConf, reason)
+    }
+
+    override fun setBackendState(backendState: BackendState, allowedIps: Collection<String>) {
+        tunnelProviderFlow.value.setBackendState(backendState, allowedIps)
+    }
+
+    override fun getBackendState(): BackendState {
+        return tunnelProviderFlow.value.getBackendState()
+    }
+
+    override suspend fun runningTunnelNames(): Set<String> {
+        return tunnelProviderFlow.value.runningTunnelNames()
+    }
+
+    override suspend fun updateTunnelStatus(
+        tunnelConf: TunnelConf,
+        status: TunnelStatus?,
+        stats: TunnelStatistics?,
+        pingStates: Map<Key, PingState>?,
+        handshakeSuccessLogs: Boolean?,
+    ) {
+        tunnelProviderFlow.value.updateTunnelStatus(
+            tunnelConf,
+            status,
+            stats,
+            pingStates,
+            handshakeSuccessLogs,
+        )
+    }
+
+    suspend fun restorePreviousState() {
+        val settings = appDataRepository.settings.get()
+        if (settings.isRestoreOnBootEnabled) {
+            val previouslyActiveTuns = appDataRepository.tunnels.getActive()
+            val tunsToStart =
+                previouslyActiveTuns.filterNot { tun ->
+                    activeTunnels.value.any { tun.id == it.key.id }
+                }
+            if (settings.isKernelEnabled) {
+                return tunsToStart.forEach { startTunnel(it) }
+            } else {
+                tunsToStart.firstOrNull()?.let { startTunnel(it) }
+            }
+        }
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/TunnelMonitor.kt

@@ -0,0 +1,266 @@
+package com.zaneschepke.wireguardautotunnel.core.tunnel
+
+import com.zaneschepke.logcatter.LogReader
+import com.zaneschepke.networkmonitor.NetworkMonitor
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.domain.state.FailureReason
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
+import com.zaneschepke.wireguardautotunnel.util.extensions.toMillis
+import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
+import dagger.hilt.android.scopes.ServiceScoped
+import io.ktor.util.collections.*
+import javax.inject.Inject
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import org.amnezia.awg.crypto.Key
+import timber.log.Timber
+
+@ServiceScoped
+class TunnelMonitor
+@Inject
+constructor(
+    private val appDataRepository: AppDataRepository,
+    private val tunnelManager: TunnelManager,
+    private val networkMonitor: NetworkMonitor,
+    private val networkUtils: NetworkUtils,
+    private val logReader: LogReader,
+) {
+
+    @OptIn(FlowPreview::class)
+    suspend fun startMonitoring(tunnelConf: TunnelConf, withLogs: Boolean): Job = coroutineScope {
+        launch {
+            launch { startTunnelConfChangesJob(tunnelConf) }
+            launch { startPingMonitor(tunnelConf) }
+            launch { startWgStatsPoll(tunnelConf) }
+            if (withLogs) launch { startLogsMonitor(tunnelConf) }
+        }
+    }
+
+    private suspend fun startTunnelConfChangesJob(tunnelConf: TunnelConf) {
+        appDataRepository.tunnels.flow
+            .map { storedTunnels -> storedTunnels.firstOrNull { it.id == tunnelConf.id } }
+            .filterNotNull()
+            .distinctUntilChanged { old, new -> old == new }
+            .collect { storedTunnel ->
+                if (tunnelConf != storedTunnel) {
+                    Timber.d("Config changed for ${storedTunnel.tunName}, bouncing")
+                    withContext(NonCancellable) {
+                        tunnelManager.bounceTunnel(
+                            storedTunnel,
+                            TunnelStatus.StopReason.ConfigChanged,
+                        )
+                    }
+                }
+            }
+    }
+
+    private suspend fun startLogsMonitor(tunnelConf: TunnelConf) {
+        logReader.liveLogs.collect { log ->
+            val healthLogs =
+                when {
+                    log.message.contains(HANDSHAKE_RESPONSE_TEXT, true) ||
+                        log.message.contains(KEEPALIVE_RESPONSE_TEXT, true) -> true
+                    log.message.contains(HANDSHAKE_INIT_FAILED_TEXT, true) ||
+                        log.message.contains(HANDSHAKE_NOT_COMPLETED_TEXT) ||
+                        log.message.contains(DATA_PACKET_FAILED_TEXT) -> false
+
+                    else -> null
+                }
+            healthLogs?.let { healthy ->
+                tunnelManager.updateTunnelStatus(tunnelConf, null, null, null, healthy)
+            }
+        }
+    }
+
+    private suspend fun startPingMonitor(tunnelConf: TunnelConf) = coroutineScope {
+        val pingStatsFlow = MutableStateFlow<Map<Key, PingState>>(emptyMap())
+
+        val tunStateFlow =
+            tunnelManager.activeTunnels.mapNotNull { it.getValueById(tunnelConf.id) }.stateIn(this)
+
+        val connectivityStateFlow = networkMonitor.connectivityStateFlow.stateIn(this)
+
+        val isNetworkConnected = connectivityStateFlow.map { it.hasConnectivity() }.stateIn(this)
+
+        data class NetworkChangeKey(
+            val ethernetConnected: Boolean,
+            val wifiConnected: Boolean,
+            val cellularConnected: Boolean,
+            val wifiSsid: String?,
+        )
+
+        connectivityStateFlow
+            .map {
+                NetworkChangeKey(
+                    ethernetConnected = it.ethernetConnected,
+                    wifiConnected = it.wifiState.connected,
+                    cellularConnected = it.cellularConnected,
+                    wifiSsid = if (it.wifiState.connected) it.wifiState.ssid else null,
+                )
+            }
+            .distinctUntilChanged()
+            .stateIn(this)
+
+        appDataRepository.settings.flow
+            .distinctUntilChanged { old, new ->
+                old.isPingEnabled == new.isPingEnabled &&
+                    old.tunnelPingIntervalSeconds == new.tunnelPingIntervalSeconds &&
+                    old.tunnelPingAttempts == new.tunnelPingAttempts &&
+                    old.tunnelPingTimeoutSeconds == new.tunnelPingTimeoutSeconds
+            }
+            .collectLatest { settings ->
+                if (!settings.isPingEnabled) return@collectLatest
+
+                Timber.d("Starting pinger for ${tunnelConf.tunName} with settings")
+
+                val config = tunnelConf.toAmConfig()
+
+                val pingablePeers = config.peers.filter { it.allowedIps.isNotEmpty() }
+                if (pingablePeers.isEmpty()) return@collectLatest
+
+                suspend fun performPing() {
+                    val updates = ConcurrentMap<Key, PingState>()
+
+                    pingablePeers.forEach { peer ->
+                        val previousState = pingStatsFlow.value[peer.publicKey] ?: PingState()
+
+                        val allowedIpStr = peer.allowedIps.firstOrNull()?.toString()
+                        if (allowedIpStr == null) {
+                            updates[peer.publicKey] =
+                                previousState.copy(
+                                    isReachable = false,
+                                    failureReason = FailureReason.NoResolvedEndpoint,
+                                    lastPingAttemptMillis = System.currentTimeMillis(),
+                                )
+                            return@forEach
+                        }
+
+                        val host =
+                            {
+                                    val parts = allowedIpStr.split("/")
+                                    val internalIp = if (parts.size == 2) parts[0] else allowedIpStr
+
+                                    val prefix =
+                                        if (parts.size == 2) parts[1].toIntOrNull() ?: 32 else 32
+                                    if (prefix <= 1) {
+                                        tunnelConf.pingTarget ?: CLOUDFLARE_IPV4_IP
+                                    } else {
+                                        internalIp.removeSurrounding("[", "]")
+                                    }
+                                }
+                                .invoke()
+
+                        val attemptTime = System.currentTimeMillis()
+                        runCatching {
+                                val pingStats =
+                                    settings.tunnelPingTimeoutSeconds?.let {
+                                        networkUtils.pingWithStats(
+                                            host,
+                                            settings.tunnelPingAttempts,
+                                            it.toMillis(),
+                                        )
+                                    }
+                                        ?: networkUtils.pingWithStats(
+                                            host,
+                                            settings.tunnelPingAttempts,
+                                        )
+
+                                updates[peer.publicKey] =
+                                    previousState.copy(
+                                        transmitted = pingStats.transmitted,
+                                        received = pingStats.received,
+                                        packetLoss = pingStats.packetLoss,
+                                        rttMin = pingStats.rttMin,
+                                        rttMax = pingStats.rttMax,
+                                        rttAvg = pingStats.rttAvg,
+                                        rttStddev = pingStats.rttStddev,
+                                        isReachable = pingStats.isReachable,
+                                        failureReason =
+                                            if (pingStats.isReachable) null
+                                            else FailureReason.PingFailed,
+                                        lastSuccessfulPingMillis =
+                                            pingStats.lastSuccessfulPingMillis
+                                                ?: previousState.lastSuccessfulPingMillis,
+                                        pingTarget = host,
+                                        lastPingAttemptMillis = attemptTime,
+                                    )
+                                Timber.d(
+                                    "Ping completed for peer ${peer.publicKey.toBase64().substring(0, 5)}.. to host $host with stats: $pingStats"
+                                )
+                            }
+                            .onFailure {
+                                Timber.e(
+                                    it,
+                                    "Ping failed for peer ${peer.publicKey} in ${tunnelConf.tunName} to host $host",
+                                )
+                                updates[peer.publicKey] =
+                                    previousState.copy(
+                                        isReachable = false,
+                                        failureReason = FailureReason.PingFailed,
+                                        pingTarget = host,
+                                        lastPingAttemptMillis = attemptTime,
+                                    )
+                            }
+                    }
+
+                    if (updates.isNotEmpty()) {
+                        pingStatsFlow.update { updates }
+                        tunnelManager.updateTunnelStatus(tunnelConf, null, null, updates)
+                    }
+                }
+
+                // Wait for the tunnel to be fully active
+                tunStateFlow.filter { state -> state.status == TunnelStatus.Up }.first()
+
+                // small delay to make sure tunnel is fully up before we actively monitor
+                delay(3_000L)
+
+                while (isActive) {
+                    if (isNetworkConnected.value) {
+                        performPing()
+                    } else {
+                        pingStatsFlow.update { current ->
+                            current.mapValues { entry ->
+                                entry.value.copy(
+                                    isReachable = false,
+                                    failureReason = FailureReason.NoConnectivity,
+                                    lastPingAttemptMillis = System.currentTimeMillis(),
+                                )
+                            }
+                        }
+                        tunnelManager.updateTunnelStatus(
+                            tunnelConf,
+                            null,
+                            null,
+                            pingStatsFlow.value,
+                        )
+                    }
+                    delay(settings.tunnelPingIntervalSeconds.toMillis())
+                }
+            }
+    }
+
+    private suspend fun startWgStatsPoll(tunnelConf: TunnelConf) = coroutineScope {
+        while (isActive) {
+            val stats = tunnelManager.getStatistics(tunnelConf)
+            tunnelManager.updateTunnelStatus(tunnelConf, null, stats, null)
+            delay(STATS_DELAY)
+        }
+    }
+
+    companion object {
+        const val CLOUDFLARE_IPV6_IP = "2606:4700:4700::1111"
+        const val CLOUDFLARE_IPV4_IP = "1.1.1.1"
+
+        const val STATS_DELAY = 1_000L
+
+        const val KEEPALIVE_RESPONSE_TEXT = "Receiving keepalive packet"
+        const val HANDSHAKE_RESPONSE_TEXT = "Received handshake response"
+        const val HANDSHAKE_INIT_FAILED_TEXT = "Failed to send handshake initiation: write udp"
+        const val DATA_PACKET_FAILED_TEXT = "Failed to send data packets"
+        const val HANDSHAKE_NOT_COMPLETED_TEXT =
+            "Handshake did not complete after 5 seconds, retrying"
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/TunnelProvider.kt

@@ -1,17 +1,69 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel
 
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendMessage
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.state.PingState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelState
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
+import java.util.concurrent.ConcurrentHashMap
+import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.StateFlow
+import org.amnezia.awg.crypto.Key
 
 interface TunnelProvider {
-	fun startTunnel(tunnelConf: TunnelConf)
-	fun stopTunnel(tunnelConf: TunnelConf? = null)
-	fun bounceTunnel(tunnelConf: TunnelConf)
-	suspend fun setBackendState(backendState: BackendState, allowedIps: Collection<String>)
-	suspend fun runningTunnelNames(): Set<String>
-	fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics?
-	val activeTunnels: StateFlow<Map<TunnelConf, TunnelState>>
+    /** Starts the specified tunnel configuration. */
+    suspend fun startTunnel(tunnelConf: TunnelConf)
+
+    /**
+     * Stops the specified tunnel, or all tunnels if none is provided.
+     *
+     * @param tunnelConf The tunnel to stop, or null to stop all active tunnels.
+     * @param reason The reason for stopping, defaults to USER for manual stops. Callers should
+     *   override with specific reasons (e.g., PING, CONFIG_CHANGED) when applicable.
+     */
+    suspend fun stopTunnel(
+        tunnelConf: TunnelConf? = null,
+        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.User,
+    )
+
+    /**
+     * Bounces (stops and restarts) the specified tunnel.
+     *
+     * @param tunnelConf The tunnel to bounce.
+     * @param reason The reason for bouncing, defaults to User for manual actions. Callers should
+     *   override with specific reasons (e.g., Ping, ConfigChanged) when applicable.
+     */
+    suspend fun bounceTunnel(
+        tunnelConf: TunnelConf,
+        reason: TunnelStatus.StopReason = TunnelStatus.StopReason.User,
+    )
+
+    fun setBackendState(backendState: BackendState, allowedIps: Collection<String>)
+
+    fun getBackendState(): BackendState
+
+    suspend fun runningTunnelNames(): Set<String>
+
+    fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics?
+
+    val activeTunnels: StateFlow<Map<TunnelConf, TunnelState>>
+
+    val errorEvents: SharedFlow<Pair<TunnelConf, BackendError>>
+
+    val messageEvents: SharedFlow<Pair<TunnelConf, BackendMessage>>
+
+    val bouncingTunnelIds: ConcurrentHashMap<Int, TunnelStatus.StopReason>
+
+    fun hasVpnPermission(): Boolean
+
+    suspend fun updateTunnelStatus(
+        tunnelConf: TunnelConf,
+        status: TunnelStatus? = null,
+        stats: TunnelStatistics? = null,
+        pingStates: Map<Key, PingState>? = null,
+        handshakeSuccessLogs: Boolean? = null,
+    )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/tunnel/UserspaceTunnel.kt

@@ -1,56 +1,111 @@
 package com.zaneschepke.wireguardautotunnel.core.tunnel
 
-import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
-import com.zaneschepke.wireguardautotunnel.di.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.enums.BackendState
+import com.zaneschepke.wireguardautotunnel.domain.enums.TunnelStatus
+import com.zaneschepke.wireguardautotunnel.domain.events.BackendError
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.state.AmneziaStatistics
 import com.zaneschepke.wireguardautotunnel.domain.state.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.util.extensions.asAmBackendState
-import kotlinx.coroutines.CoroutineDispatcher
+import com.zaneschepke.wireguardautotunnel.util.extensions.asBackendState
+import com.zaneschepke.wireguardautotunnel.util.extensions.toBackendError
+import javax.inject.Inject
+import kotlin.jvm.optionals.getOrNull
 import kotlinx.coroutines.CoroutineScope
 import org.amnezia.awg.backend.Backend
+import org.amnezia.awg.backend.BackendException
 import org.amnezia.awg.backend.Tunnel
+import org.amnezia.awg.config.Config
 import timber.log.Timber
-import javax.inject.Inject
 
-class UserspaceTunnel @Inject constructor(
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-	@ApplicationScope private val applicationScope: CoroutineScope,
-	serviceManager: ServiceManager,
-	appDataRepository: AppDataRepository,
-	notificationManager: NotificationManager,
-	private val backend: Backend,
-) : BaseTunnel(ioDispatcher, applicationScope, appDataRepository, serviceManager, notificationManager) {
+class UserspaceTunnel
+@Inject
+constructor(
+    applicationScope: CoroutineScope,
+    val serviceManager: ServiceManager,
+    val appDataRepository: AppDataRepository,
+    private val backend: Backend,
+) : BaseTunnel(applicationScope, appDataRepository, serviceManager) {
 
-	override suspend fun startBackend(tunnel: TunnelConf) {
-		stopActiveTunnels()
-		backend.setState(tunnel, Tunnel.State.UP, tunnel.toAmConfig())
-	}
+    private var previousBackendState: Pair<BackendState, Boolean>? = null
 
-	override fun stopBackend(tunnel: TunnelConf) {
-		Timber.i("Stopping tunnel ${tunnel.id} userspace")
-		backend.setState(tunnel, Tunnel.State.DOWN, tunnel.toAmConfig())
-	}
+    override suspend fun startBackend(tunnel: TunnelConf) {
+        try {
+            updateTunnelStatus(tunnel, TunnelStatus.Starting)
+            val amConfig = tunnel.toAmConfig()
+            handleVpnKillSwitchWithDomainEndpoints(amConfig)
+            backend.setState(tunnel, Tunnel.State.UP, amConfig)
+        } catch (e: BackendException) {
+            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
+            throw e.toBackendError()
+        } catch (e: IllegalArgumentException) {
+            Timber.e(e, "Failed to start up backend for tunnel ${tunnel.name}")
+            throw BackendError.Config
+        }
+    }
 
-	override suspend fun setBackendState(backendState: BackendState, allowedIps: Collection<String>) {
-		Timber.d("Setting backend state: $backendState with allowedIps: $allowedIps")
-		backend.setBackendState(backendState.asAmBackendState(), allowedIps)
-	}
+    override fun stopBackend(tunnel: TunnelConf) {
+        Timber.i("Stopping tunnel ${tunnel.name} userspace")
+        try {
+            backend.setState(tunnel, Tunnel.State.DOWN, tunnel.toAmConfig())
+        } catch (e: BackendException) {
+            Timber.e(e, "Failed to stop tunnel ${tunnel.id}")
+            throw e.toBackendError()
+        } finally {
+            handlePreviouslyEnabledVpnKillSwitch()
+        }
+    }
 
-	override suspend fun runningTunnelNames(): Set<String> {
-		return backend.runningTunnelNames
-	}
+    // stop vpn kill switch if we need to resolve DNS for peer endpoints
+    private suspend fun handleVpnKillSwitchWithDomainEndpoints(config: Config) {
+        if (
+            config.peers.any { it.endpoint.getOrNull()?.toString()?.isUrl() == true } &&
+                backend.backendState.asBackendState() == BackendState.KILL_SWITCH_ACTIVE
+        ) {
+            val bypassLan = appDataRepository.settings.get().isLanOnKillSwitchEnabled
+            previousBackendState = Pair(BackendState.KILL_SWITCH_ACTIVE, bypassLan)
+            setBackendState(BackendState.SERVICE_ACTIVE, emptyList())
+        }
+    }
 
-	override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
-		return try {
-			AmneziaStatistics(backend.getStatistics(tunnelConf))
-		} catch (e: Exception) {
-			Timber.e(e, "Failed to get stats for ${tunnelConf.tunName}")
-			null
-		}
-	}
+    // restore vpn kill switch if needed
+    private fun handlePreviouslyEnabledVpnKillSwitch() {
+        // let auto tunnel handle this if it is active
+        if (serviceManager.autoTunnelService.value == null) {
+            previousBackendState?.let { (state, lanEnabled) ->
+                Timber.d("Restoring kill switch configuration")
+                val lan = if (lanEnabled) TunnelConf.LAN_BYPASS_ALLOWED_IPS else emptyList()
+                backend.setBackendState(state.asAmBackendState(), lan)
+            }
+        }
+        previousBackendState = null
+    }
+
+    override fun setBackendState(backendState: BackendState, allowedIps: Collection<String>) {
+        Timber.d("Setting backend state: $backendState with allowedIps: $allowedIps")
+        try {
+            backend.setBackendState(backendState.asAmBackendState(), allowedIps)
+        } catch (e: BackendException) {
+            throw e.toBackendError()
+        }
+    }
+
+    override fun getBackendState(): BackendState {
+        return backend.backendState.asBackendState()
+    }
+
+    override suspend fun runningTunnelNames(): Set<String> {
+        return backend.runningTunnelNames
+    }
+
+    override fun getStatistics(tunnelConf: TunnelConf): TunnelStatistics? {
+        return try {
+            AmneziaStatistics(backend.getStatistics(tunnelConf))
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to get stats for ${tunnelConf.tunName}")
+            null
+        }
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/core/worker/ServiceWorker.kt

@@ -2,59 +2,62 @@ package com.zaneschepke.wireguardautotunnel.core.worker
 
 import android.content.Context
 import androidx.hilt.work.HiltWorker
-import androidx.work.CoroutineWorker
-import androidx.work.ExistingPeriodicWorkPolicy
-import androidx.work.PeriodicWorkRequestBuilder
-import androidx.work.WorkManager
-import androidx.work.WorkerParameters
+import androidx.work.*
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
 import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
+import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
 import timber.log.Timber
-import java.util.concurrent.TimeUnit
 
 @HiltWorker
-class ServiceWorker @AssistedInject constructor(
-	@Assisted private val context: Context,
-	@Assisted private val params: WorkerParameters,
-	private val serviceManager: ServiceManager,
-	private val appDataRepository: AppDataRepository,
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
-	private val tunnelManager: TunnelManager,
+class ServiceWorker
+@AssistedInject
+constructor(
+    @Assisted private val context: Context,
+    @Assisted private val params: WorkerParameters,
+    private val serviceManager: ServiceManager,
+    private val appDataRepository: AppDataRepository,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    private val tunnelManager: TunnelManager,
 ) : CoroutineWorker(context, params) {
 
-	companion object {
-		private const val TAG = "service_worker"
+    companion object {
+        private const val TAG = "service_worker"
 
-		fun stop(context: Context) {
-			WorkManager.getInstance(context).cancelAllWorkByTag(TAG)
-		}
+        fun stop(context: Context) {
+            WorkManager.getInstance(context).cancelAllWorkByTag(TAG)
+        }
 
-		fun start(context: Context) {
-			val periodicWorkRequest = PeriodicWorkRequestBuilder<ServiceWorker>(
-				repeatInterval = 15,
-				repeatIntervalTimeUnit = TimeUnit.MINUTES,
-			).build()
-			WorkManager.getInstance(context)
-				.enqueueUniquePeriodicWork(
-					TAG,
-					ExistingPeriodicWorkPolicy.KEEP,
-					periodicWorkRequest,
-				)
-		}
-	}
+        fun start(context: Context) {
+            val periodicWorkRequest =
+                PeriodicWorkRequestBuilder<ServiceWorker>(
+                        repeatInterval = 15,
+                        repeatIntervalTimeUnit = TimeUnit.MINUTES,
+                    )
+                    .build()
+            WorkManager.getInstance(context)
+                .enqueueUniquePeriodicWork(
+                    TAG,
+                    ExistingPeriodicWorkPolicy.KEEP,
+                    periodicWorkRequest,
+                )
+        }
+    }
 
-	override suspend fun doWork(): Result = withContext(ioDispatcher) {
-		Timber.i("Service worker started")
-		with(appDataRepository.settings.get()) {
-			if (isAutoTunnelEnabled && !serviceManager.autoTunnelActive.value) return@with serviceManager.startAutoTunnel()
-			if (tunnelManager.activeTunnels.value.isEmpty()) tunnelManager.restorePreviousState()
-		}
-		Result.success()
-	}
+    override suspend fun doWork(): Result =
+        withContext(ioDispatcher) {
+            Timber.i("Service worker started")
+            with(appDataRepository.settings.get()) {
+                if (isAutoTunnelEnabled && serviceManager.autoTunnelService.value == null)
+                    return@with serviceManager.startAutoTunnel()
+                if (tunnelManager.activeTunnels.value.isEmpty())
+                    tunnelManager.restorePreviousState()
+            }
+            Result.success()
+        }
 }

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

@@ -1,90 +1,70 @@
 package com.zaneschepke.wireguardautotunnel.data
 
-import androidx.room.AutoMigration
-import androidx.room.Database
-import androidx.room.DeleteColumn
-import androidx.room.RoomDatabase
-import androidx.room.TypeConverters
+import androidx.room.*
 import androidx.room.migration.AutoMigrationSpec
 import com.zaneschepke.wireguardautotunnel.data.dao.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.dao.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import com.zaneschepke.wireguardautotunnel.data.entity.TunnelConfig
 
 @Database(
-	entities = [Settings::class, TunnelConfig::class],
-	version = 16,
-	autoMigrations =
-	[
-		AutoMigration(from = 1, to = 2),
-		AutoMigration(from = 2, to = 3),
-		AutoMigration(
-			from = 3,
-			to = 4,
-		),
-		AutoMigration(
-			from = 4,
-			to = 5,
-		),
-		AutoMigration(
-			from = 5,
-			to = 6,
-		),
-		AutoMigration(
-			from = 6,
-			to = 7,
-			spec = RemoveLegacySettingColumnsMigration::class,
-		),
-		AutoMigration(7, 8),
-		AutoMigration(8, 9),
-		AutoMigration(9, 10),
-		AutoMigration(
-			from = 10,
-			to = 11,
-			spec = RemoveTunnelPauseMigration::class,
-		),
-		AutoMigration(
-			from = 11,
-			to = 12,
-		),
-		AutoMigration(
-			from = 12,
-			to = 13,
-		),
-		AutoMigration(
-			from = 13,
-			to = 14,
-		),
-		AutoMigration(
-			from = 14,
-			to = 15,
-		),
-		AutoMigration(
-			from = 15,
-			to = 16,
-		),
-	],
-	exportSchema = true,
+    entities = [Settings::class, TunnelConfig::class],
+    version = 19,
+    autoMigrations =
+        [
+            AutoMigration(from = 1, to = 2),
+            AutoMigration(from = 2, to = 3),
+            AutoMigration(from = 3, to = 4),
+            AutoMigration(from = 4, to = 5),
+            AutoMigration(from = 5, to = 6),
+            AutoMigration(from = 6, to = 7, spec = RemoveLegacySettingColumnsMigration::class),
+            AutoMigration(7, 8),
+            AutoMigration(8, 9),
+            AutoMigration(9, 10),
+            AutoMigration(from = 10, to = 11, spec = RemoveTunnelPauseMigration::class),
+            AutoMigration(from = 11, to = 12),
+            AutoMigration(from = 12, to = 13),
+            AutoMigration(from = 13, to = 14),
+            AutoMigration(from = 14, to = 15),
+            AutoMigration(from = 15, to = 16),
+            AutoMigration(from = 16, to = 17, spec = WifiDetectionMigration::class),
+            AutoMigration(from = 17, to = 18),
+            AutoMigration(from = 18, to = 19, spec = PingMigration::class),
+        ],
+    exportSchema = true,
 )
-@TypeConverters(DatabaseListConverters::class)
+@TypeConverters(DatabaseConverters::class)
 abstract class AppDatabase : RoomDatabase() {
-	abstract fun settingDao(): SettingsDao
+    abstract fun settingDao(): SettingsDao
 
-	abstract fun tunnelConfigDoa(): TunnelConfigDao
+    abstract fun tunnelConfigDoa(): TunnelConfigDao
 }
 
-@DeleteColumn(
-	tableName = "Settings",
-	columnName = "default_tunnel",
-)
-@DeleteColumn(
-	tableName = "Settings",
-	columnName = "is_battery_saver_enabled",
-)
+@DeleteColumn(tableName = "Settings", columnName = "default_tunnel")
+@DeleteColumn(tableName = "Settings", columnName = "is_battery_saver_enabled")
 class RemoveLegacySettingColumnsMigration : AutoMigrationSpec
 
-@DeleteColumn(
-	tableName = "Settings",
-	columnName = "is_auto_tunnel_paused",
-)
+@DeleteColumn(tableName = "Settings", columnName = "is_auto_tunnel_paused")
 class RemoveTunnelPauseMigration : AutoMigrationSpec
+
+@DeleteColumn(tableName = "Settings", columnName = "is_wifi_by_shell_enabled")
+class WifiDetectionMigration : AutoMigrationSpec
+
+@DeleteColumn.Entries(
+    DeleteColumn(tableName = "TunnelConfig", columnName = "ping_interval"),
+    DeleteColumn(tableName = "TunnelConfig", columnName = "ping_cooldown"),
+    DeleteColumn(tableName = "Settings", columnName = "split_tunnel_apps"),
+)
+@RenameColumn.Entries(
+    RenameColumn(
+        tableName = "TunnelConfig",
+        fromColumnName = "is_ping_enabled",
+        toColumnName = "restart_on_ping_failure",
+    ),
+    RenameColumn(
+        tableName = "TunnelConfig",
+        fromColumnName = "ping_ip",
+        toColumnName = "ping_target",
+    ),
+)
+class PingMigration : AutoMigrationSpec

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

@@ -7,6 +7,7 @@ import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
+import java.io.IOException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
@@ -15,80 +16,78 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import timber.log.Timber
-import java.io.IOException
 
 class DataStoreManager(
-	private val context: Context,
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    private val context: Context,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) {
-	companion object {
-		val locationDisclosureShown = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
-		val batteryDisableShown = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
-		val currentSSID = stringPreferencesKey("CURRENT_SSID")
-		val pinLockEnabled = booleanPreferencesKey("PIN_LOCK_ENABLED")
-		val tunnelStatsExpanded = booleanPreferencesKey("TUNNEL_STATS_EXPANDED")
-		val isLocalLogsEnabled = booleanPreferencesKey("LOCAL_LOGS_ENABLED")
-		val locale = stringPreferencesKey("LOCALE")
-		val theme = stringPreferencesKey("THEME")
-	}
+    companion object {
+        val locationDisclosureShown = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
+        val batteryDisableShown = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
+        val pinLockEnabled = booleanPreferencesKey("PIN_LOCK_ENABLED")
+        val expandedTunnelIds = stringPreferencesKey("EXPANDED_TUNNEL_IDS")
+        val isLocalLogsEnabled = booleanPreferencesKey("LOCAL_LOGS_ENABLED")
+        val locale = stringPreferencesKey("LOCALE")
+        val theme = stringPreferencesKey("THEME")
+        val isRemoteControlEnabled = booleanPreferencesKey("IS_REMOTE_CONTROL_ENABLED")
+        val remoteKey = stringPreferencesKey("REMOTE_KEY")
+        val showDetailedPingStats = booleanPreferencesKey("SHOW_DETAILED_PING_STATS")
+    }
 
-	// preferences
-	private val preferencesKey = "preferences"
-	private val Context.dataStore by
-		preferencesDataStore(
-			name = preferencesKey,
-		)
+    // preferences
+    private val preferencesKey = "preferences"
+    private val Context.dataStore by preferencesDataStore(name = preferencesKey)
 
-	suspend fun init() {
-		withContext(ioDispatcher) {
-			try {
-				context.dataStore.data.first()
-			} catch (e: IOException) {
-				Timber.Forest.e(e)
-			}
-		}
-	}
+    suspend fun init() {
+        withContext(ioDispatcher) {
+            try {
+                context.dataStore.data.first()
+            } catch (e: IOException) {
+                Timber.Forest.e(e)
+            }
+        }
+    }
 
-	suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) {
-		withContext(ioDispatcher) {
-			try {
-				context.dataStore.edit { it[key] = value }
-			} catch (e: IOException) {
-				Timber.Forest.e(e)
-			} catch (e: Exception) {
-				Timber.Forest.e(e)
-			}
-		}
-	}
+    suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) {
+        withContext(ioDispatcher) {
+            try {
+                context.dataStore.edit { it[key] = value }
+            } catch (e: IOException) {
+                Timber.Forest.e(e)
+            } catch (e: Exception) {
+                Timber.Forest.e(e)
+            }
+        }
+    }
 
-	suspend fun <T> removeFromDataStore(key: Preferences.Key<T>) {
-		withContext(ioDispatcher) {
-			try {
-				context.dataStore.edit { it.remove(key) }
-			} catch (e: IOException) {
-				Timber.Forest.e(e)
-			} catch (e: Exception) {
-				Timber.Forest.e(e)
-			}
-		}
-	}
+    suspend fun <T> removeFromDataStore(key: Preferences.Key<T>) {
+        withContext(ioDispatcher) {
+            try {
+                context.dataStore.edit { it.remove(key) }
+            } catch (e: IOException) {
+                Timber.Forest.e(e)
+            } catch (e: Exception) {
+                Timber.Forest.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? {
-		return withContext(ioDispatcher) {
-			try {
-				context.dataStore.data.map { it[key] }.first()
-			} catch (e: IOException) {
-				Timber.Forest.e(e)
-				null
-			}
-		}
-	}
+    suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
+        return withContext(ioDispatcher) {
+            try {
+                context.dataStore.data.map { it[key] }.first()
+            } catch (e: IOException) {
+                Timber.Forest.e(e)
+                null
+            }
+        }
+    }
 
-	fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
-		context.dataStore.data.map { it[key] }.first()
-	}
+    fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
+        context.dataStore.data.map { it[key] }.first()
+    }
 
-	val preferencesFlow: Flow<Preferences?> = context.dataStore.data.flowOn(ioDispatcher)
+    val preferencesFlow: Flow<Preferences?> = context.dataStore.data.flowOn(ioDispatcher)
 }

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 {
-		// Notice non-ui thread is here
-		beginTransaction()
-		try {
-			execSQL(Queries.createDefaultSettings())
-			Timber.i("Bootstrapping settings data")
-			setTransactionSuccessful()
-		} catch (e: Exception) {
-			Timber.e(e)
-		} finally {
-			endTransaction()
-		}
-	}
+    override fun onCreate(db: SupportSQLiteDatabase) =
+        db.run {
+            beginTransaction()
+            try {
+                execSQL(Queries.createDefaultSettings())
+                Timber.i("Bootstrapping settings data")
+                setTransactionSuccessful()
+            } catch (e: Exception) {
+                Timber.e(e)
+            } finally {
+                endTransaction()
+            }
+        }
 }

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

@@ -0,0 +1,30 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.TypeConverter
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import kotlinx.serialization.json.Json
+
+class DatabaseConverters {
+    @TypeConverter
+    fun listToString(value: List<String>): String {
+        return Json.encodeToString(value)
+    }
+
+    @TypeConverter
+    fun stringToList(value: String): List<String> {
+        if (value.isBlank() || value.isEmpty()) return mutableListOf()
+        return try {
+            Json.decodeFromString<List<String>>(value)
+        } catch (e: Exception) {
+            val list = value.split(",").toMutableList()
+            val json = listToString(list)
+            Json.decodeFromString<List<String>>(json)
+        }
+    }
+
+    @TypeConverter fun fromStatus(status: Settings.WifiDetectionMethod): Int = status.value
+
+    @TypeConverter
+    fun toStatus(value: Int): Settings.WifiDetectionMethod =
+        Settings.WifiDetectionMethod.fromValue(value)
+}

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

@@ -1,23 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data
-
-import androidx.room.TypeConverter
-import kotlinx.serialization.json.Json
-
-class DatabaseListConverters {
-	@TypeConverter
-	fun listToString(value: MutableList<String>): String {
-		return Json.encodeToString(value)
-	}
-
-	@TypeConverter
-	fun stringToList(value: String): MutableList<String> {
-		if (value.isBlank() || value.isEmpty()) return mutableListOf()
-		return try {
-			Json.decodeFromString<MutableList<String>>(value)
-		} catch (e: Exception) {
-			val list = value.split(",").toMutableList()
-			val json = listToString(list)
-			Json.decodeFromString<MutableList<String>>(json)
-		}
-	}
-}

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

@@ -1,8 +1,8 @@
 package com.zaneschepke.wireguardautotunnel.data
 
 object Queries {
-	fun createDefaultSettings(): String {
-		return """
+    fun createDefaultSettings(): String {
+        return """
 		INSERT INTO Settings (is_tunnel_enabled,
 		        is_tunnel_on_mobile_data_enabled,
 		        trusted_network_ssids,
@@ -24,12 +24,14 @@ object Queries {
 		        'false',
 		        'false',
 		        'false')
-		""".trimIndent()
-	}
+		"""
+            .trimIndent()
+    }
 
-	fun createTunnelConfig(): String {
-		return """
+    fun createTunnelConfig(): String {
+        return """
 		INSERT INTO TunnelConfig (name, wg_quick) VALUES ('test', 'test')
-		""".trimIndent()
-	}
+		"""
+            .trimIndent()
+    }
 }

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

@@ -1,36 +1,24 @@
 package com.zaneschepke.wireguardautotunnel.data.dao
 
-import androidx.room.Dao
-import androidx.room.Delete
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import androidx.room.*
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
 import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface SettingsDao {
-	@Insert(onConflict = OnConflictStrategy.REPLACE)
-	suspend fun save(t: Settings)
+    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun save(t: Settings)
 
-	@Insert(onConflict = OnConflictStrategy.REPLACE)
-	suspend fun saveAll(t: List<Settings>)
+    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun saveAll(t: List<Settings>)
 
-	@Query("SELECT * FROM settings WHERE id=:id")
-	suspend fun getById(id: Long): Settings?
+    @Query("SELECT * FROM settings WHERE id=:id") suspend fun getById(id: Long): Settings?
 
-	@Query("SELECT * FROM settings")
-	suspend fun getAll(): List<Settings>
+    @Query("SELECT * FROM settings") suspend fun getAll(): List<Settings>
 
-	@Query("SELECT * FROM settings LIMIT 1")
-	fun getSettingsFlow(): Flow<Settings>
+    @Query("SELECT * FROM settings LIMIT 1") fun getSettingsFlow(): Flow<Settings>
 
-	@Query("SELECT * FROM settings")
-	fun getAllFlow(): Flow<MutableList<Settings>>
+    @Query("SELECT * FROM settings") fun getAllFlow(): Flow<MutableList<Settings>>
 
-	@Delete
-	suspend fun delete(t: Settings)
+    @Delete suspend fun delete(t: Settings)
 
-	@Query("SELECT COUNT('id') FROM settings")
-	suspend fun count(): Long
+    @Query("SELECT COUNT('id') FROM settings") suspend fun count(): Long
 }

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

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

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/entity/Asset.kt

@@ -0,0 +1,10 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Asset(
+    val name: String,
+    @SerialName("browser_download_url") val browserDownloadUrl: String,
+)

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

@@ -0,0 +1,26 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
+
+data class GeneralState(
+    val isLocationDisclosureShown: Boolean = LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+    val isBatteryOptimizationDisableShown: Boolean = BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+    val isPinLockEnabled: Boolean = PIN_LOCK_ENABLED_DEFAULT,
+    val expandedTunnelIds: List<Int> = emptyList(),
+    val isLocalLogsEnabled: Boolean = IS_LOGS_ENABLED_DEFAULT,
+    val isRemoteControlEnabled: Boolean = IS_REMOTE_CONTROL_ENABLED,
+    val showDetailedPingStats: Boolean = SHOW_DETAILED_PING_STATS_DEFAULT,
+    val remoteKey: String? = null,
+    val locale: String? = null,
+    val theme: Theme = Theme.AUTOMATIC,
+) {
+
+    companion object {
+        const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
+        const val BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT = false
+        const val PIN_LOCK_ENABLED_DEFAULT = false
+        const val IS_LOGS_ENABLED_DEFAULT = false
+        const val IS_REMOTE_CONTROL_ENABLED = false
+        const val SHOW_DETAILED_PING_STATS_DEFAULT = false
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/entity/GitHubRelease.kt

@@ -0,0 +1,12 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class GitHubRelease(
+    @SerialName("tag_name") val tagName: String,
+    val name: String?,
+    val body: String?,
+    val assets: List<Asset>,
+)

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

@@ -0,0 +1,67 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity
+data class Settings(
+    @PrimaryKey(autoGenerate = true) val id: Int = 0,
+    @ColumnInfo(name = "is_tunnel_enabled") val isAutoTunnelEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled")
+    val isTunnelOnMobileDataEnabled: Boolean = false,
+    @ColumnInfo(name = "trusted_network_ssids") val trustedNetworkSSIDs: List<String> = emptyList(),
+    @ColumnInfo(name = "is_always_on_vpn_enabled") val isAlwaysOnVpnEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled")
+    val isTunnelOnEthernetEnabled: Boolean = false,
+    @ColumnInfo(name = "is_shortcuts_enabled", defaultValue = "false")
+    val isShortcutsEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_wifi_enabled", defaultValue = "false")
+    val isTunnelOnWifiEnabled: Boolean = false,
+    @ColumnInfo(name = "is_kernel_enabled", defaultValue = "false")
+    val isKernelEnabled: Boolean = false,
+    @ColumnInfo(name = "is_restore_on_boot_enabled", defaultValue = "false")
+    val isRestoreOnBootEnabled: Boolean = false,
+    @ColumnInfo(name = "is_multi_tunnel_enabled", defaultValue = "false")
+    val isMultiTunnelEnabled: Boolean = false,
+    @ColumnInfo(name = "is_ping_enabled", defaultValue = "false")
+    val isPingEnabled: Boolean = false,
+    @ColumnInfo(name = "is_amnezia_enabled", defaultValue = "false")
+    val isAmneziaEnabled: Boolean = false,
+    @ColumnInfo(name = "is_wildcards_enabled", defaultValue = "false")
+    val isWildcardsEnabled: Boolean = false,
+    @ColumnInfo(name = "is_stop_on_no_internet_enabled", defaultValue = "false")
+    val isStopOnNoInternetEnabled: Boolean = false,
+    @ColumnInfo(name = "is_vpn_kill_switch_enabled", defaultValue = "false")
+    val isVpnKillSwitchEnabled: Boolean = false,
+    @ColumnInfo(name = "is_kernel_kill_switch_enabled", defaultValue = "false")
+    val isKernelKillSwitchEnabled: Boolean = false,
+    @ColumnInfo(name = "is_lan_on_kill_switch_enabled", defaultValue = "false")
+    val isLanOnKillSwitchEnabled: Boolean = false,
+    @ColumnInfo(name = "debounce_delay_seconds", defaultValue = "3")
+    val debounceDelaySeconds: Int = 3,
+    @ColumnInfo(name = "is_disable_kill_switch_on_trusted_enabled", defaultValue = "false")
+    val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_unsecure_enabled", defaultValue = "false")
+    val isTunnelOnUnsecureEnabled: Boolean = false,
+    @ColumnInfo(name = "wifi_detection_method", defaultValue = "0")
+    val wifiDetectionMethod: WifiDetectionMethod = WifiDetectionMethod.fromValue(0),
+    @ColumnInfo(name = "is_ping_monitoring_enabled", defaultValue = "true")
+    val isPingMonitoringEnabled: Boolean = true,
+    @ColumnInfo(name = "tunnel_ping_interval_sec", defaultValue = "30")
+    val tunnelPingIntervalSeconds: Int = 30,
+    @ColumnInfo(name = "tunnel_ping_attempts", defaultValue = "3") val tunnelPingAttempts: Int = 3,
+    @ColumnInfo(name = "tunnel_ping_timeout_sec") val tunnelPingTimeoutSeconds: Int? = null,
+) {
+    enum class WifiDetectionMethod(val value: Int) {
+        DEFAULT(0),
+        LEGACY(1),
+        ROOT(2),
+        SHIZUKU(3);
+
+        companion object {
+            fun fromValue(value: Int): WifiDetectionMethod =
+                entries.find { it.value == value } ?: DEFAULT
+        }
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.zaneschepke.wireguardautotunnel.data.entity
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(indices = [Index(value = ["name"], unique = true)])
+data class TunnelConfig(
+    @PrimaryKey(autoGenerate = true) val id: Int = 0,
+    @ColumnInfo(name = "name") val name: String,
+    @ColumnInfo(name = "wg_quick") val wgQuick: String,
+    @ColumnInfo(name = "tunnel_networks", defaultValue = "")
+    val tunnelNetworks: List<String> = listOf(),
+    @ColumnInfo(name = "is_mobile_data_tunnel", defaultValue = "false")
+    val isMobileDataTunnel: Boolean = false,
+    @ColumnInfo(name = "is_primary_tunnel", defaultValue = "false")
+    val isPrimaryTunnel: Boolean = false,
+    @ColumnInfo(name = "am_quick", defaultValue = "") val amQuick: String = AM_QUICK_DEFAULT,
+    @ColumnInfo(name = "is_Active", defaultValue = "false") val isActive: Boolean = false,
+    @ColumnInfo(name = "restart_on_ping_failure", defaultValue = "false")
+    val restartOnPingFailure: Boolean = false,
+    @ColumnInfo(name = "ping_target", defaultValue = "null") var pingTarget: String? = null,
+    @ColumnInfo(name = "is_ethernet_tunnel", defaultValue = "false")
+    val isEthernetTunnel: Boolean = false,
+    @ColumnInfo(name = "is_ipv4_preferred", defaultValue = "true")
+    val isIpv4Preferred: Boolean = true,
+    @ColumnInfo(name = "position", defaultValue = "0") val position: Int = 0,
+    @ColumnInfo(name = "auto_tunnel_apps", defaultValue = "[]")
+    val autoTunnelApps: List<String> = listOf(),
+) {
+
+    companion object {
+        const val AM_QUICK_DEFAULT = ""
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/mapper/GeneralStateMapper.kt

@@ -0,0 +1,39 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.wireguardautotunnel.data.entity.GeneralState
+import com.zaneschepke.wireguardautotunnel.domain.model.AppState
+
+object GeneralStateMapper {
+    fun toAppState(generalState: GeneralState): AppState =
+        with(generalState) {
+            AppState(
+                isLocationDisclosureShown,
+                isBatteryOptimizationDisableShown,
+                isPinLockEnabled,
+                expandedTunnelIds,
+                isLocalLogsEnabled,
+                isRemoteControlEnabled,
+                showDetailedPingStats,
+                remoteKey,
+                locale,
+                theme,
+            )
+        }
+
+    fun toGeneralState(appState: AppState): GeneralState {
+        return with(appState) {
+            GeneralState(
+                isLocationDisclosureShown,
+                isBatteryOptimizationDisableShown,
+                isPinLockEnabled,
+                expandedTunnelIds,
+                isLocalLogsEnabled,
+                isRemoteControlEnabled,
+                showDetailedPingStats,
+                remoteKey,
+                locale,
+                theme,
+            )
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/mapper/GitHubReleaseMapper.kt

@@ -0,0 +1,19 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.wireguardautotunnel.data.entity.GitHubRelease
+import com.zaneschepke.wireguardautotunnel.domain.model.AppUpdate
+
+object GitHubReleaseMapper {
+    fun toAppUpdate(gitHubRelease: GitHubRelease, newVersion: String): AppUpdate {
+        with(gitHubRelease) {
+            val apkAsset = assets.firstOrNull { it.name.endsWith(".apk") }
+            return AppUpdate(
+                version = newVersion,
+                title = name ?: "Update $tagName",
+                releaseNotes = body ?: "No release notes provided",
+                apkUrl = apkAsset?.browserDownloadUrl,
+                apkFileName = apkAsset?.name,
+            )
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/mapper/SettingsMapper.kt

@@ -0,0 +1,71 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
+
+object SettingsMapper {
+    fun toAppSettings(settings: Settings): AppSettings {
+        return AppSettings(
+            id = settings.id,
+            isAutoTunnelEnabled = settings.isAutoTunnelEnabled,
+            isTunnelOnMobileDataEnabled = settings.isTunnelOnMobileDataEnabled,
+            trustedNetworkSSIDs = settings.trustedNetworkSSIDs,
+            isAlwaysOnVpnEnabled = settings.isAlwaysOnVpnEnabled,
+            isTunnelOnEthernetEnabled = settings.isTunnelOnEthernetEnabled,
+            isShortcutsEnabled = settings.isShortcutsEnabled,
+            isTunnelOnWifiEnabled = settings.isTunnelOnWifiEnabled,
+            isKernelEnabled = settings.isKernelEnabled,
+            isRestoreOnBootEnabled = settings.isRestoreOnBootEnabled,
+            isMultiTunnelEnabled = settings.isMultiTunnelEnabled,
+            isPingEnabled = settings.isPingEnabled,
+            isAmneziaEnabled = settings.isAmneziaEnabled,
+            isWildcardsEnabled = settings.isWildcardsEnabled,
+            isStopOnNoInternetEnabled = settings.isStopOnNoInternetEnabled,
+            isVpnKillSwitchEnabled = settings.isVpnKillSwitchEnabled,
+            isKernelKillSwitchEnabled = settings.isKernelKillSwitchEnabled,
+            isLanOnKillSwitchEnabled = settings.isLanOnKillSwitchEnabled,
+            debounceDelaySeconds = settings.debounceDelaySeconds,
+            isDisableKillSwitchOnTrustedEnabled = settings.isDisableKillSwitchOnTrustedEnabled,
+            isTunnelOnUnsecureEnabled = settings.isTunnelOnUnsecureEnabled,
+            wifiDetectionMethod =
+                AndroidNetworkMonitor.WifiDetectionMethod.fromValue(
+                    settings.wifiDetectionMethod.value
+                ),
+            tunnelPingIntervalSeconds = settings.tunnelPingIntervalSeconds,
+            tunnelPingAttempts = settings.tunnelPingAttempts,
+            tunnelPingTimeoutSeconds = settings.tunnelPingTimeoutSeconds,
+        )
+    }
+
+    fun toSettings(appSettings: AppSettings): Settings {
+        return Settings(
+            id = appSettings.id,
+            isAutoTunnelEnabled = appSettings.isAutoTunnelEnabled,
+            isTunnelOnMobileDataEnabled = appSettings.isTunnelOnMobileDataEnabled,
+            trustedNetworkSSIDs = appSettings.trustedNetworkSSIDs,
+            isAlwaysOnVpnEnabled = appSettings.isAlwaysOnVpnEnabled,
+            isTunnelOnEthernetEnabled = appSettings.isTunnelOnEthernetEnabled,
+            isShortcutsEnabled = appSettings.isShortcutsEnabled,
+            isTunnelOnWifiEnabled = appSettings.isTunnelOnWifiEnabled,
+            isKernelEnabled = appSettings.isKernelEnabled,
+            isRestoreOnBootEnabled = appSettings.isRestoreOnBootEnabled,
+            isMultiTunnelEnabled = appSettings.isMultiTunnelEnabled,
+            isPingEnabled = appSettings.isPingEnabled,
+            isAmneziaEnabled = appSettings.isAmneziaEnabled,
+            isWildcardsEnabled = appSettings.isWildcardsEnabled,
+            isStopOnNoInternetEnabled = appSettings.isStopOnNoInternetEnabled,
+            isVpnKillSwitchEnabled = appSettings.isVpnKillSwitchEnabled,
+            isKernelKillSwitchEnabled = appSettings.isKernelKillSwitchEnabled,
+            isLanOnKillSwitchEnabled = appSettings.isLanOnKillSwitchEnabled,
+            debounceDelaySeconds = appSettings.debounceDelaySeconds,
+            isDisableKillSwitchOnTrustedEnabled = appSettings.isDisableKillSwitchOnTrustedEnabled,
+            isTunnelOnUnsecureEnabled = appSettings.isTunnelOnUnsecureEnabled,
+            wifiDetectionMethod =
+                Settings.WifiDetectionMethod.fromValue(appSettings.wifiDetectionMethod.value),
+            tunnelPingIntervalSeconds = appSettings.tunnelPingIntervalSeconds,
+            tunnelPingAttempts = appSettings.tunnelPingAttempts,
+            tunnelPingTimeoutSeconds = appSettings.tunnelPingTimeoutSeconds,
+        )
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/mapper/TunnelConfigMapper.kt

@@ -0,0 +1,46 @@
+package com.zaneschepke.wireguardautotunnel.data.mapper
+
+import com.zaneschepke.wireguardautotunnel.data.entity.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
+
+object TunnelConfigMapper {
+    fun toTunnelConf(tunnelConfig: TunnelConfig): TunnelConf {
+        return with(tunnelConfig) {
+            TunnelConf(
+                id,
+                name,
+                wgQuick,
+                tunnelNetworks,
+                isMobileDataTunnel,
+                isPrimaryTunnel,
+                amQuick,
+                isActive,
+                pingTarget,
+                restartOnPingFailure,
+                isEthernetTunnel,
+                isIpv4Preferred,
+                position,
+            )
+        }
+    }
+
+    fun toTunnelConfig(tunnelConf: TunnelConf): TunnelConfig {
+        return with(tunnelConf) {
+            TunnelConfig(
+                id,
+                tunName,
+                wgQuick,
+                tunnelNetworks,
+                isMobileDataTunnel,
+                isPrimaryTunnel,
+                amQuick,
+                isActive,
+                restartOnPingFailure,
+                pingTarget,
+                isEthernetTunnel,
+                isIpv4Preferred,
+                position,
+            )
+        }
+    }
+}

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

@@ -1,46 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppState
-import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
-
-data class GeneralState(
-	val isLocationDisclosureShown: Boolean = LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-	val isBatteryOptimizationDisableShown: Boolean = BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-	val isPinLockEnabled: Boolean = PIN_LOCK_ENABLED_DEFAULT,
-	val isTunnelStatsExpanded: Boolean = IS_TUNNEL_STATS_EXPANDED,
-	val isLocalLogsEnabled: Boolean = IS_LOGS_ENABLED_DEFAULT,
-	val locale: String? = null,
-	val theme: Theme = Theme.AUTOMATIC,
-) {
-
-	fun toAppState(): AppState = AppState(
-		isLocationDisclosureShown,
-		isBatteryOptimizationDisableShown,
-		isPinLockEnabled,
-		isTunnelStatsExpanded,
-		isLocationDisclosureShown,
-		locale,
-		theme,
-	)
-
-	companion object {
-		fun from(appState: AppState): GeneralState {
-			return with(appState) {
-				GeneralState(
-					isLocationDisclosureShown,
-					isBatteryOptimizationDisableShown,
-					isPinLockEnabled,
-					isTunnelStatsExpanded,
-					isLocationDisclosureShown,
-					locale,
-					theme,
-				)
-			}
-		}
-		const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
-		const val BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT = false
-		const val PIN_LOCK_ENABLED_DEFAULT = false
-		const val IS_TUNNEL_STATS_EXPANDED = false
-		const val IS_LOGS_ENABLED_DEFAULT = false
-	}
-}

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

@@ -1,118 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings
-
-@Entity
-data class Settings(
-	@PrimaryKey(autoGenerate = true) val id: Int = 0,
-	@ColumnInfo(name = "is_tunnel_enabled") val isAutoTunnelEnabled: Boolean = false,
-	@ColumnInfo(name = "is_tunnel_on_mobile_data_enabled")
-	val isTunnelOnMobileDataEnabled: Boolean = false,
-	@ColumnInfo(name = "trusted_network_ssids")
-	val trustedNetworkSSIDs: MutableList<String> = mutableListOf(),
-	@ColumnInfo(name = "is_always_on_vpn_enabled") val isAlwaysOnVpnEnabled: Boolean = false,
-	@ColumnInfo(name = "is_tunnel_on_ethernet_enabled")
-	val isTunnelOnEthernetEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_shortcuts_enabled",
-		defaultValue = "false",
-	)
-	val isShortcutsEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_tunnel_on_wifi_enabled",
-		defaultValue = "false",
-	)
-	val isTunnelOnWifiEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_kernel_enabled",
-		defaultValue = "false",
-	)
-	val isKernelEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_restore_on_boot_enabled",
-		defaultValue = "false",
-	)
-	val isRestoreOnBootEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_multi_tunnel_enabled",
-		defaultValue = "false",
-	)
-	val isMultiTunnelEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_ping_enabled",
-		defaultValue = "false",
-	)
-	val isPingEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_amnezia_enabled",
-		defaultValue = "false",
-	)
-	val isAmneziaEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_wildcards_enabled",
-		defaultValue = "false",
-	)
-	val isWildcardsEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_wifi_by_shell_enabled",
-		defaultValue = "false",
-	)
-	val isWifiNameByShellEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_stop_on_no_internet_enabled",
-		defaultValue = "false",
-	)
-	val isStopOnNoInternetEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_vpn_kill_switch_enabled",
-		defaultValue = "false",
-	)
-	val isVpnKillSwitchEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_kernel_kill_switch_enabled",
-		defaultValue = "false",
-	)
-	val isKernelKillSwitchEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "is_lan_on_kill_switch_enabled",
-		defaultValue = "false",
-	)
-	val isLanOnKillSwitchEnabled: Boolean = false,
-	@ColumnInfo(
-		name = "debounce_delay_seconds",
-		defaultValue = "3",
-	)
-	val debounceDelaySeconds: Int = 3,
-	@ColumnInfo(
-		name = "is_disable_kill_switch_on_trusted_enabled",
-		defaultValue = "false",
-	)
-	val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
-) {
-
-	fun toAppSettings(): AppSettings {
-		return AppSettings(
-			id, isAutoTunnelEnabled, isTunnelOnMobileDataEnabled, trustedNetworkSSIDs, isAlwaysOnVpnEnabled, isTunnelOnEthernetEnabled,
-			isShortcutsEnabled, isTunnelOnWifiEnabled, isKernelEnabled, isRestoreOnBootEnabled, isMultiTunnelEnabled, isPingEnabled,
-			isAmneziaEnabled, isWildcardsEnabled, isWifiNameByShellEnabled, isStopOnNoInternetEnabled, isVpnKillSwitchEnabled,
-			isKernelKillSwitchEnabled, isLanOnKillSwitchEnabled, debounceDelaySeconds, isDisableKillSwitchOnTrustedEnabled,
-		)
-	}
-
-	companion object {
-		fun from(appSettings: AppSettings): Settings {
-			return with(appSettings) {
-				Settings(
-					id, isAutoTunnelEnabled, isTunnelOnMobileDataEnabled, trustedNetworkSSIDs.toMutableList(), isAlwaysOnVpnEnabled,
-					isTunnelOnEthernetEnabled, isShortcutsEnabled, isTunnelOnWifiEnabled, isKernelEnabled, isRestoreOnBootEnabled,
-					isMultiTunnelEnabled, isPingEnabled, isAmneziaEnabled, isWildcardsEnabled, isWifiNameByShellEnabled,
-					isStopOnNoInternetEnabled, isVpnKillSwitchEnabled, isKernelKillSwitchEnabled, isLanOnKillSwitchEnabled,
-					debounceDelaySeconds, isDisableKillSwitchOnTrustedEnabled,
-				)
-			}
-		}
-	}
-}

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

@@ -1,93 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
-
-@Entity(indices = [Index(value = ["name"], unique = true)])
-data class TunnelConfig(
-	@PrimaryKey(autoGenerate = true) val id: Int = 0,
-	@ColumnInfo(name = "name") val name: String,
-	@ColumnInfo(name = "wg_quick") val wgQuick: String,
-	@ColumnInfo(
-		name = "tunnel_networks",
-		defaultValue = "",
-	)
-	val tunnelNetworks: MutableList<String> = mutableListOf(),
-	@ColumnInfo(
-		name = "is_mobile_data_tunnel",
-		defaultValue = "false",
-	)
-	val isMobileDataTunnel: Boolean = false,
-	@ColumnInfo(
-		name = "is_primary_tunnel",
-		defaultValue = "false",
-	)
-	val isPrimaryTunnel: Boolean = false,
-	@ColumnInfo(
-		name = "am_quick",
-		defaultValue = "",
-	)
-	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,
-	@ColumnInfo(
-		name = "is_ethernet_tunnel",
-		defaultValue = "false",
-	)
-	var isEthernetTunnel: Boolean = false,
-	@ColumnInfo(
-		name = "is_ipv4_preferred",
-		defaultValue = "true",
-	)
-	var isIpv4Preferred: Boolean = true,
-) {
-
-	fun toTunnel(): TunnelConf {
-		return TunnelConf(
-			id, name, wgQuick, tunnelNetworks, isMobileDataTunnel,
-			isPrimaryTunnel, amQuick, isActive, isPingEnabled, pingInterval,
-			pingCooldown, pingIp, isEthernetTunnel, isIpv4Preferred,
-		)
-	}
-
-	companion object {
-
-		const val AM_QUICK_DEFAULT = ""
-
-		fun from(tunnelConf: TunnelConf): TunnelConfig {
-			return with(tunnelConf) {
-				return TunnelConfig(
-					id, tunName, wgQuick, tunnelNetworks.toMutableList(), isMobileDataTunnel,
-					isPrimaryTunnel, amQuick, isActive, isPingEnabled, pingInterval,
-					pingCooldown, pingIp, isEthernetTunnel, isIpv4Preferred,
-				)
-			}
-		}
-	}
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/network/GitHubApi.kt

@@ -0,0 +1,9 @@
+package com.zaneschepke.wireguardautotunnel.data.network
+
+import com.zaneschepke.wireguardautotunnel.data.entity.GitHubRelease
+
+interface GitHubApi {
+    suspend fun getLatestRelease(owner: String, repo: String): Result<GitHubRelease>
+
+    suspend fun getNightlyRelease(owner: String, repo: String): Result<GitHubRelease>
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/network/KtorClient.kt

@@ -0,0 +1,28 @@
+package com.zaneschepke.wireguardautotunnel.data.network
+
+import io.ktor.client.*
+import io.ktor.client.engine.okhttp.*
+import io.ktor.client.plugins.*
+import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.serialization.kotlinx.json.*
+import kotlinx.serialization.json.Json
+
+object KtorClient {
+    fun create(): HttpClient {
+        return HttpClient(OkHttp) {
+            install(ContentNegotiation) {
+                json(
+                    Json {
+                        ignoreUnknownKeys = true
+                        isLenient = true
+                    }
+                )
+            }
+            install(HttpTimeout) {
+                requestTimeoutMillis = 15000
+                connectTimeoutMillis = 15000
+                socketTimeoutMillis = 15000
+            }
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/network/KtorGitHubApi.kt

@@ -0,0 +1,56 @@
+package com.zaneschepke.wireguardautotunnel.data.network
+
+import com.zaneschepke.wireguardautotunnel.data.entity.GitHubRelease
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.plugins.*
+import io.ktor.client.request.*
+import io.ktor.http.*
+
+class KtorGitHubApi(private val client: HttpClient) : GitHubApi {
+    override suspend fun getLatestRelease(owner: String, repo: String): Result<GitHubRelease> {
+        return try {
+            val response: GitHubRelease =
+                client.get("https://api.github.com/repos/$owner/$repo/releases/latest").body()
+            Result.success(response)
+        } catch (e: ClientRequestException) {
+            when (e.response.status) {
+                HttpStatusCode.Forbidden -> Result.failure(Exception("Rate limit exceeded"))
+                HttpStatusCode.NotFound ->
+                    Result.failure(Exception("Repository or release not found"))
+                else -> Result.failure(e)
+            }
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+    override suspend fun getNightlyRelease(owner: String, repo: String): Result<GitHubRelease> {
+        return try {
+            // Fetch all releases
+            val releases: List<GitHubRelease> =
+                client.get("https://api.github.com/repos/$owner/$repo/releases").body()
+
+            // Find the first release with "nightly" in the tag_name (case-insensitive)
+            val nightlyRelease =
+                releases.firstOrNull { release ->
+                    release.tagName.contains("nightly", ignoreCase = true)
+                }
+
+            if (nightlyRelease != null) {
+                Result.success(nightlyRelease)
+            } else {
+                Result.failure(Exception("No release with 'nightly' tag found"))
+            }
+        } catch (e: ClientRequestException) {
+            when (e.response.status) {
+                HttpStatusCode.Forbidden -> Result.failure(Exception("Rate limit exceeded"))
+                HttpStatusCode.NotFound ->
+                    Result.failure(Exception("Repository or release not found"))
+                else -> Result.failure(e)
+            }
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+}

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

@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
@@ -10,19 +10,19 @@ import javax.inject.Inject
 class AppDataRoomRepository
 @Inject
 constructor(
-	override val settings: AppSettingRepository,
-	override val tunnels: TunnelRepository,
-	override val appState: AppStateRepository,
+    override val settings: AppSettingRepository,
+    override val tunnels: TunnelRepository,
+    override val appState: AppStateRepository,
 ) : AppDataRepository {
 
-	override suspend fun getPrimaryOrFirstTunnel(): TunnelConf? {
-		return tunnels.findPrimary().firstOrNull() ?: tunnels.getAll().firstOrNull()
-	}
+    override suspend fun getPrimaryOrFirstTunnel(): TunnelConf? {
+        return tunnels.findPrimary().firstOrNull() ?: tunnels.getAll().firstOrNull()
+    }
 
-	override suspend fun getStartTunnelConfig(): TunnelConf? {
-		tunnels.getActive().let {
-			if (it.isNotEmpty()) return it.first()
-			return getPrimaryOrFirstTunnel()
-		}
-	}
+    override suspend fun getStartTunnelConfig(): TunnelConf? {
+        tunnels.getActive().let {
+            if (it.isNotEmpty()) return it.first()
+            return getPrimaryOrFirstTunnel()
+        }
+    }
 }

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

@@ -1,106 +1,170 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.DataStoreManager
-import com.zaneschepke.wireguardautotunnel.data.model.GeneralState
+import com.zaneschepke.wireguardautotunnel.data.entity.GeneralState
+import com.zaneschepke.wireguardautotunnel.data.mapper.GeneralStateMapper
+import com.zaneschepke.wireguardautotunnel.domain.model.AppState
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
 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,
-) :
-	AppStateRepository {
-	override suspend fun isLocationDisclosureShown(): Boolean {
-		return dataStoreManager.getFromStore(DataStoreManager.locationDisclosureShown)
-			?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
-	}
+class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager) :
+    AppStateRepository {
+    override suspend fun isLocationDisclosureShown(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.locationDisclosureShown)
+            ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
+    }
 
-	override suspend fun setLocationDisclosureShown(shown: Boolean) {
-		dataStoreManager.saveToDataStore(DataStoreManager.locationDisclosureShown, shown)
-	}
+    override suspend fun setLocationDisclosureShown(shown: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.locationDisclosureShown, shown)
+    }
 
-	override suspend fun isPinLockEnabled(): Boolean {
-		return dataStoreManager.getFromStore(DataStoreManager.pinLockEnabled)
-			?: GeneralState.PIN_LOCK_ENABLED_DEFAULT
-	}
+    override suspend fun isPinLockEnabled(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.pinLockEnabled)
+            ?: GeneralState.PIN_LOCK_ENABLED_DEFAULT
+    }
 
-	override suspend fun setPinLockEnabled(enabled: Boolean) {
-		dataStoreManager.saveToDataStore(DataStoreManager.pinLockEnabled, enabled)
-	}
+    override suspend fun setPinLockEnabled(enabled: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.pinLockEnabled, enabled)
+    }
 
-	override suspend fun isBatteryOptimizationDisableShown(): Boolean {
-		return dataStoreManager.getFromStore(DataStoreManager.batteryDisableShown)
-			?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
-	}
+    override suspend fun isBatteryOptimizationDisableShown(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.batteryDisableShown)
+            ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
+    }
 
-	override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
-		dataStoreManager.saveToDataStore(DataStoreManager.batteryDisableShown, shown)
-	}
+    override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.batteryDisableShown, shown)
+    }
 
-	override suspend fun isTunnelStatsExpanded(): Boolean {
-		return dataStoreManager.getFromStore(DataStoreManager.tunnelStatsExpanded)
-			?: GeneralState.IS_TUNNEL_STATS_EXPANDED
-	}
+    override suspend fun setTunnelExpanded(id: Int) {
+        val ids =
+            dataStoreManager
+                .getFromStore(DataStoreManager.expandedTunnelIds)
+                ?.split(",")
+                ?.mapNotNull { it.toIntOrNull() } ?: emptyList()
 
-	override suspend fun setTunnelStatsExpanded(expanded: Boolean) {
-		dataStoreManager.saveToDataStore(DataStoreManager.tunnelStatsExpanded, expanded)
-	}
+        if (ids.contains(id)) return
 
-	override suspend fun setTheme(theme: Theme) {
-		dataStoreManager.saveToDataStore(DataStoreManager.theme, theme.name)
-	}
+        val updatedList = ids.toMutableList().apply { add(id) }
+        dataStoreManager.saveToDataStore(
+            DataStoreManager.expandedTunnelIds,
+            updatedList.joinToString(","),
+        )
+    }
 
-	override suspend fun getTheme(): Theme {
-		return dataStoreManager.getFromStore(DataStoreManager.theme)?.let {
-			try {
-				Theme.valueOf(it)
-			} catch (_: IllegalArgumentException) {
-				Theme.AUTOMATIC
-			}
-		} ?: Theme.AUTOMATIC
-	}
+    override suspend fun removeTunnelExpanded(id: Int) {
+        val ids =
+            dataStoreManager
+                .getFromStore(DataStoreManager.expandedTunnelIds)
+                ?.split(",")
+                ?.mapNotNull { it.toIntOrNull() } ?: emptyList()
 
-	override suspend fun isLocalLogsEnabled(): Boolean {
-		return dataStoreManager.getFromStore(DataStoreManager.isLocalLogsEnabled) ?: GeneralState.IS_LOGS_ENABLED_DEFAULT
-	}
+        if (ids.isEmpty() || !ids.contains(id)) return
 
-	override suspend fun setLocalLogsEnabled(enabled: Boolean) {
-		dataStoreManager.saveToDataStore(DataStoreManager.isLocalLogsEnabled, enabled)
-	}
+        val updatedList = ids.toMutableList().apply { remove(id) }
+        dataStoreManager.saveToDataStore(
+            DataStoreManager.expandedTunnelIds,
+            updatedList.joinToString(","),
+        )
+    }
 
-	override suspend fun setLocale(localeTag: String) {
-		dataStoreManager.saveToDataStore(DataStoreManager.locale, localeTag)
-	}
+    override suspend fun setTheme(theme: Theme) {
+        dataStoreManager.saveToDataStore(DataStoreManager.theme, theme.name)
+    }
 
-	override suspend fun getLocale(): String? {
-		return dataStoreManager.getFromStore(DataStoreManager.locale)
-	}
+    override suspend fun getTheme(): Theme {
+        return dataStoreManager.getFromStore(DataStoreManager.theme)?.let {
+            try {
+                Theme.valueOf(it)
+            } catch (_: IllegalArgumentException) {
+                Theme.AUTOMATIC
+            }
+        } ?: Theme.AUTOMATIC
+    }
 
-	override val flow: Flow<GeneralState> =
-		dataStoreManager.preferencesFlow.map { prefs ->
-			prefs?.let { pref ->
-				try {
-					GeneralState(
-						isLocationDisclosureShown =
-						pref[DataStoreManager.locationDisclosureShown]
-							?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-						isBatteryOptimizationDisableShown =
-						pref[DataStoreManager.batteryDisableShown]
-							?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-						isPinLockEnabled =
-						pref[DataStoreManager.pinLockEnabled]
-							?: GeneralState.PIN_LOCK_ENABLED_DEFAULT,
-						isTunnelStatsExpanded = pref[DataStoreManager.tunnelStatsExpanded] ?: GeneralState.IS_TUNNEL_STATS_EXPANDED,
-						isLocalLogsEnabled = pref[DataStoreManager.isLocalLogsEnabled] ?: GeneralState.IS_LOGS_ENABLED_DEFAULT,
-						locale = pref[DataStoreManager.locale],
-						theme = getTheme(),
-					)
-				} catch (e: IllegalArgumentException) {
-					Timber.e(e)
-					GeneralState()
-				}
-			} ?: GeneralState()
-		}
+    override suspend fun isLocalLogsEnabled(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.isLocalLogsEnabled)
+            ?: GeneralState.IS_LOGS_ENABLED_DEFAULT
+    }
+
+    override suspend fun setLocalLogsEnabled(enabled: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.isLocalLogsEnabled, enabled)
+    }
+
+    override suspend fun setLocale(localeTag: String) {
+        dataStoreManager.saveToDataStore(DataStoreManager.locale, localeTag)
+    }
+
+    override suspend fun getLocale(): String? {
+        return dataStoreManager.getFromStore(DataStoreManager.locale)
+    }
+
+    override suspend fun setIsRemoteControlEnabled(enabled: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.isRemoteControlEnabled, enabled)
+    }
+
+    override suspend fun isRemoteControlEnabled(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.isRemoteControlEnabled)
+            ?: GeneralState.IS_REMOTE_CONTROL_ENABLED
+    }
+
+    override suspend fun setRemoteKey(key: String) {
+        dataStoreManager.saveToDataStore(DataStoreManager.remoteKey, key)
+    }
+
+    override suspend fun getRemoteKey(): String? {
+        return dataStoreManager.getFromStore(DataStoreManager.remoteKey)
+    }
+
+    override suspend fun setShowDetailedPingStats(showDetailedPing: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.showDetailedPingStats, showDetailedPing)
+    }
+
+    override suspend fun getShowDetailedPing(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.showDetailedPingStats)
+            ?: GeneralState.SHOW_DETAILED_PING_STATS_DEFAULT
+    }
+
+    override val flow: Flow<AppState> =
+        dataStoreManager.preferencesFlow
+            .map { prefs ->
+                prefs?.let { pref ->
+                    try {
+                        GeneralState(
+                            isLocationDisclosureShown =
+                                pref[DataStoreManager.locationDisclosureShown]
+                                    ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+                            isBatteryOptimizationDisableShown =
+                                pref[DataStoreManager.batteryDisableShown]
+                                    ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+                            isPinLockEnabled =
+                                pref[DataStoreManager.pinLockEnabled]
+                                    ?: GeneralState.PIN_LOCK_ENABLED_DEFAULT,
+                            expandedTunnelIds =
+                                pref[DataStoreManager.expandedTunnelIds]?.split(",")?.mapNotNull {
+                                    it.toIntOrNull()
+                                } ?: emptyList(),
+                            isLocalLogsEnabled =
+                                pref[DataStoreManager.isLocalLogsEnabled]
+                                    ?: GeneralState.IS_LOGS_ENABLED_DEFAULT,
+                            isRemoteControlEnabled =
+                                pref[DataStoreManager.isRemoteControlEnabled]
+                                    ?: GeneralState.IS_REMOTE_CONTROL_ENABLED,
+                            showDetailedPingStats =
+                                pref[DataStoreManager.showDetailedPingStats]
+                                    ?: GeneralState.SHOW_DETAILED_PING_STATS_DEFAULT,
+                            remoteKey = pref[DataStoreManager.remoteKey],
+                            locale = pref[DataStoreManager.locale],
+                            theme = getTheme(),
+                        )
+                    } catch (e: IllegalArgumentException) {
+                        Timber.e(e)
+                        GeneralState()
+                    }
+                } ?: GeneralState()
+            }
+            .map(GeneralStateMapper::toAppState)
 }

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

@@ -0,0 +1,104 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import android.content.Context
+import com.zaneschepke.wireguardautotunnel.BuildConfig
+import com.zaneschepke.wireguardautotunnel.data.mapper.GitHubReleaseMapper
+import com.zaneschepke.wireguardautotunnel.data.network.GitHubApi
+import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.domain.model.AppUpdate
+import com.zaneschepke.wireguardautotunnel.domain.repository.UpdateRepository
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.NumberUtils
+import io.ktor.client.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import io.ktor.utils.io.*
+import java.io.File
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+
+class GitHubUpdateRepository(
+    private val gitHubApi: GitHubApi,
+    private val httpClient: HttpClient,
+    private val githubOwner: String,
+    private val githubRepo: String,
+    private val context: Context,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+) : UpdateRepository {
+    override suspend fun checkForUpdate(currentVersion: String): Result<AppUpdate?> =
+        withContext(ioDispatcher) {
+            Timber.i("Checking for update")
+            val isNightly = BuildConfig.VERSION_NAME.contains("nightly")
+            val release =
+                if (isNightly) {
+                    gitHubApi.getNightlyRelease(githubOwner, githubRepo).onFailure(Timber::e)
+                } else {
+                    gitHubApi.getLatestRelease(githubOwner, githubRepo).onFailure(Timber::e)
+                }
+            release.map { release ->
+                val apkAsset =
+                    release.assets.find { asset ->
+                        asset.name.startsWith("wgtunnel-${Constants.STANDALONE_FLAVOR}-v") &&
+                            asset.name.endsWith(".apk")
+                    }
+                val newVersion =
+                    apkAsset
+                        ?.name
+                        ?.removePrefix("wgtunnel-${Constants.STANDALONE_FLAVOR}-v")
+                        ?.removeSuffix(".apk") ?: return@map null
+
+                Timber.i("Latest version: $newVersion, current version: $currentVersion")
+                if (isNightly && newVersion != currentVersion)
+                    return@map GitHubReleaseMapper.toAppUpdate(release, newVersion)
+                if (NumberUtils.compareVersions(newVersion, currentVersion) > 0) {
+                    GitHubReleaseMapper.toAppUpdate(release, newVersion)
+                } else {
+                    null
+                }
+            }
+        }
+
+    override suspend fun downloadApk(
+        apkUrl: String,
+        fileName: String,
+        onProgress: (Float) -> Unit,
+    ): Result<File> =
+        withContext(ioDispatcher) {
+            try {
+                // clean up old files
+                context.getExternalFilesDir(null)?.listFiles()?.forEach { file ->
+                    if (file.extension == "apk") file.delete()
+                }
+
+                val response: HttpResponse = httpClient.get(apkUrl)
+
+                val apkFile = File(context.getExternalFilesDir(null), fileName)
+
+                val channel: ByteReadChannel = response.bodyAsChannel()
+                val totalBytes: Long = response.contentLength() ?: -1L
+                var bytesCopied = 0L
+
+                apkFile.outputStream().use { output ->
+                    val buffer = ByteArray(8 * 1024)
+
+                    while (!channel.isClosedForRead) {
+                        val bytesRead = channel.readAvailable(buffer)
+                        if (bytesRead <= 0) break
+                        output.write(buffer, 0, bytesRead)
+                        bytesCopied += bytesRead
+
+                        if (totalBytes > 0) {
+                            val progress = bytesCopied.toFloat() / totalBytes
+                            onProgress(progress.coerceIn(0f, 1f))
+                        }
+                    }
+                }
+
+                Result.success(apkFile)
+            } catch (e: Exception) {
+                Result.failure(e)
+            }
+        }
+}

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

@@ -1,9 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.dao.SettingsDao
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.entity.Settings
+import com.zaneschepke.wireguardautotunnel.data.mapper.SettingsMapper
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.AppSettings
+import com.zaneschepke.wireguardautotunnel.domain.model.AppSettings
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.flowOn
@@ -11,21 +12,20 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.withContext
 
 class RoomSettingsRepository(
-	private val settingsDoa: SettingsDao,
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    private val settingsDoa: SettingsDao,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : AppSettingRepository {
 
-	override suspend fun save(appSettings: AppSettings) {
-		withContext(ioDispatcher) {
-			settingsDoa.save(Settings.from(appSettings))
-		}
-	}
+    override suspend fun save(appSettings: AppSettings) {
+        withContext(ioDispatcher) { settingsDoa.save(SettingsMapper.toSettings(appSettings)) }
+    }
 
-	override val flow = settingsDoa.getSettingsFlow().flowOn(ioDispatcher).map { it.toAppSettings() }
+    override val flow =
+        settingsDoa.getSettingsFlow().flowOn(ioDispatcher).map(SettingsMapper::toAppSettings)
 
-	override suspend fun get(): AppSettings {
-		return withContext(ioDispatcher) {
-			(settingsDoa.getAll().firstOrNull() ?: Settings()).toAppSettings()
-		}
-	}
+    override suspend fun get(): AppSettings {
+        return withContext(ioDispatcher) {
+            SettingsMapper.toAppSettings(settingsDoa.getAll().firstOrNull() ?: Settings())
+        }
+    }
 }

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

@@ -1,9 +1,9 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.dao.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.mapper.TunnelConfigMapper
 import com.zaneschepke.wireguardautotunnel.di.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
 import com.zaneschepke.wireguardautotunnel.util.extensions.Tunnels
 import kotlinx.coroutines.CoroutineDispatcher
@@ -12,102 +12,97 @@ import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.withContext
 
 class RoomTunnelRepository(
-	private val tunnelConfigDao: TunnelConfigDao,
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    private val tunnelConfigDao: TunnelConfigDao,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : TunnelRepository {
 
-	override val flow = tunnelConfigDao.getAllFlow().flowOn(ioDispatcher).map { it.map { it.toTunnel() } }
+    override val flow =
+        tunnelConfigDao.getAllFlow().flowOn(ioDispatcher).map {
+            it.map(TunnelConfigMapper::toTunnelConf)
+        }
 
-	override suspend fun getAll(): Tunnels {
-		return withContext(ioDispatcher) {
-			tunnelConfigDao.getAll().map { it.toTunnel() }
-		}
-	}
+    override suspend fun getAll(): Tunnels {
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getAll().map(TunnelConfigMapper::toTunnelConf)
+        }
+    }
 
-	override suspend fun save(tunnelConf: TunnelConf) {
-		withContext(ioDispatcher) {
-			tunnelConfigDao.save(TunnelConfig.from(tunnelConf))
-		}
-	}
+    override suspend fun save(tunnelConf: TunnelConf) {
+        withContext(ioDispatcher) {
+            tunnelConfigDao.save(TunnelConfigMapper.toTunnelConfig(tunnelConf))
+        }
+    }
 
-	override suspend fun saveAll(tunnelConfs: List<TunnelConf>) {
-		withContext(ioDispatcher) {
-			tunnelConfigDao.saveAll(tunnelConfs.map(TunnelConfig::from))
-		}
-	}
+    override suspend fun saveAll(tunnelConfList: List<TunnelConf>) {
+        withContext(ioDispatcher) {
+            tunnelConfigDao.saveAll(tunnelConfList.map(TunnelConfigMapper::toTunnelConfig))
+        }
+    }
 
-	override suspend fun updatePrimaryTunnel(tunnelConf: TunnelConf?) {
-		withContext(ioDispatcher) {
-			tunnelConfigDao.resetPrimaryTunnel()
-			tunnelConf?.let {
-				save(
-					it.copy(
-						isPrimaryTunnel = true,
-					),
-				)
-			}
-		}
-	}
+    override suspend fun updatePrimaryTunnel(tunnelConf: TunnelConf?) {
+        withContext(ioDispatcher) {
+            tunnelConfigDao.resetPrimaryTunnel()
+            tunnelConf?.let { save(it.copy(isPrimaryTunnel = true)) }
+        }
+    }
 
-	override suspend fun updateMobileDataTunnel(tunnelConf: TunnelConf?) {
-		withContext(ioDispatcher) {
-			tunnelConfigDao.resetMobileDataTunnel()
-			tunnelConf?.let {
-				save(
-					it.copy(
-						isMobileDataTunnel = true,
-					),
-				)
-			}
-		}
-	}
+    override suspend fun updateMobileDataTunnel(tunnelConf: TunnelConf?) {
+        withContext(ioDispatcher) {
+            tunnelConfigDao.resetMobileDataTunnel()
+            tunnelConf?.let { save(it.copy(isMobileDataTunnel = true)) }
+        }
+    }
 
-	override suspend fun updateEthernetTunnel(tunnelConf: TunnelConf?) {
-		withContext(ioDispatcher) {
-			tunnelConfigDao.resetEthernetTunnel()
-			tunnelConf?.let {
-				save(
-					it.copy(
-						isEthernetTunnel = true,
-					),
-				)
-			}
-		}
-	}
+    override suspend fun updateEthernetTunnel(tunnelConf: TunnelConf?) {
+        withContext(ioDispatcher) {
+            tunnelConfigDao.resetEthernetTunnel()
+            tunnelConf?.let { save(it.copy(isEthernetTunnel = true)) }
+        }
+    }
 
-	override suspend fun delete(tunnelConf: TunnelConf) {
-		withContext(ioDispatcher) {
-			tunnelConfigDao.delete(TunnelConfig.from(tunnelConf))
-		}
-	}
+    override suspend fun delete(tunnelConf: TunnelConf) {
+        withContext(ioDispatcher) {
+            tunnelConfigDao.delete(TunnelConfigMapper.toTunnelConfig(tunnelConf))
+        }
+    }
 
-	override suspend fun getById(id: Int): TunnelConf? {
-		return withContext(ioDispatcher) { tunnelConfigDao.getById(id.toLong())?.toTunnel() }
-	}
+    override suspend fun getById(id: Int): TunnelConf? {
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getById(id.toLong())?.let(TunnelConfigMapper::toTunnelConf)
+        }
+    }
 
-	override suspend fun getActive(): Tunnels {
-		return withContext(ioDispatcher) {
-			tunnelConfigDao.getActive().map { it.toTunnel() }
-		}
-	}
+    override suspend fun getActive(): Tunnels {
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getActive().map(TunnelConfigMapper::toTunnelConf)
+        }
+    }
 
-	override suspend fun count(): Int {
-		return withContext(ioDispatcher) { tunnelConfigDao.count().toInt() }
-	}
+    override suspend fun count(): Int {
+        return withContext(ioDispatcher) { tunnelConfigDao.count().toInt() }
+    }
 
-	override suspend fun findByTunnelName(name: String): TunnelConf? {
-		return withContext(ioDispatcher) { tunnelConfigDao.getByName(name)?.toTunnel() }
-	}
+    override suspend fun findByTunnelName(name: String): TunnelConf? {
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.getByName(name)?.let(TunnelConfigMapper::toTunnelConf)
+        }
+    }
 
-	override suspend fun findByTunnelNetworksName(name: String): Tunnels {
-		return withContext(ioDispatcher) { tunnelConfigDao.findByTunnelNetworkName(name).map { it.toTunnel() } }
-	}
+    override suspend fun findByTunnelNetworksName(name: String): Tunnels {
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.findByTunnelNetworkName(name).map(TunnelConfigMapper::toTunnelConf)
+        }
+    }
 
-	override suspend fun findByMobileDataTunnel(): Tunnels {
-		return withContext(ioDispatcher) { tunnelConfigDao.findByMobileDataTunnel().map { it.toTunnel() } }
-	}
+    override suspend fun findByMobileDataTunnel(): Tunnels {
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.findByMobileDataTunnel().map(TunnelConfigMapper::toTunnelConf)
+        }
+    }
 
-	override suspend fun findPrimary(): Tunnels {
-		return withContext(ioDispatcher) { tunnelConfigDao.findByPrimary().map { it.toTunnel() } }
-	}
+    override suspend fun findPrimary(): Tunnels {
+        return withContext(ioDispatcher) {
+            tunnelConfigDao.findByPrimary().map(TunnelConfigMapper::toTunnelConf)
+        }
+    }
 }

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

@@ -4,43 +4,65 @@ import android.content.Context
 import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.logcatter.LogcatReader
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
+import com.zaneschepke.wireguardautotunnel.core.notification.NotificationMonitor
 import com.zaneschepke.wireguardautotunnel.core.notification.WireGuardNotification
 import com.zaneschepke.wireguardautotunnel.core.shortcut.DynamicShortcutManager
 import com.zaneschepke.wireguardautotunnel.core.shortcut.ShortcutManager
+import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
+import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
-import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
 class AppModule {
-	@Singleton
-	@ApplicationScope
-	@Provides
-	fun providesApplicationScope(@DefaultDispatcher defaultDispatcher: CoroutineDispatcher): CoroutineScope =
-		CoroutineScope(SupervisorJob() + defaultDispatcher)
+    @Singleton
+    @ApplicationScope
+    @Provides
+    fun providesApplicationScope(
+        @DefaultDispatcher defaultDispatcher: CoroutineDispatcher
+    ): CoroutineScope = CoroutineScope(SupervisorJob() + defaultDispatcher)
 
-	@Singleton
-	@Provides
-	fun provideLogCollect(@ApplicationContext context: Context): LogReader {
-		return LogcatReader.init(storageDir = context.filesDir.absolutePath)
-	}
+    @Singleton
+    @Provides
+    fun provideLogCollect(@ApplicationContext context: Context): LogReader {
+        return LogcatReader.init(storageDir = context.filesDir.absolutePath)
+    }
 
-	@Singleton
-	@Provides
-	fun provideNotificationService(@ApplicationContext context: Context): NotificationManager {
-		return WireGuardNotification(context)
-	}
+    @Singleton
+    @Provides
+    fun provideNotificationService(@ApplicationContext context: Context): NotificationManager {
+        return WireGuardNotification(context)
+    }
 
-	@Singleton
-	@Provides
-	fun provideShortcutManager(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): ShortcutManager {
-		return DynamicShortcutManager(context, ioDispatcher)
-	}
+    @Singleton
+    @Provides
+    fun provideShortcutManager(
+        @ApplicationContext context: Context,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+    ): ShortcutManager {
+        return DynamicShortcutManager(context, ioDispatcher)
+    }
+
+    @Singleton
+    @Provides
+    fun provideNetworkUtils(@IoDispatcher ioDispatcher: CoroutineDispatcher): NetworkUtils {
+        return NetworkUtils(ioDispatcher)
+    }
+
+    @Singleton
+    @Provides
+    fun provideNotificationMonitor(
+        tunnelManager: TunnelManager,
+        notificationManager: NotificationManager,
+    ): NotificationMonitor {
+        return NotificationMonitor(tunnelManager, notificationManager)
+    }
 }

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

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

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

@@ -2,26 +2,14 @@ package com.zaneschepke.wireguardautotunnel.di
 
 import javax.inject.Qualifier
 
-@Retention(AnnotationRetention.RUNTIME)
-@Qualifier
-annotation class DefaultDispatcher
+@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class DefaultDispatcher
 
-@Retention(AnnotationRetention.RUNTIME)
-@Qualifier
-annotation class IoDispatcher
+@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class IoDispatcher
 
-@Retention(AnnotationRetention.RUNTIME)
-@Qualifier
-annotation class MainDispatcher
+@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class MainDispatcher
 
-@Retention(AnnotationRetention.BINARY)
-@Qualifier
-annotation class MainImmediateDispatcher
+@Retention(AnnotationRetention.BINARY) @Qualifier annotation class MainImmediateDispatcher
 
-@Retention(AnnotationRetention.RUNTIME)
-@Qualifier
-annotation class ApplicationScope
+@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class ApplicationScope
 
-@Retention(AnnotationRetention.RUNTIME)
-@Qualifier
-annotation class ServiceScope
+@Retention(AnnotationRetention.RUNTIME) @Qualifier annotation class ServiceScope

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

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

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

@@ -8,81 +8,118 @@ import com.zaneschepke.wireguardautotunnel.data.DataStoreManager
 import com.zaneschepke.wireguardautotunnel.data.DatabaseCallback
 import com.zaneschepke.wireguardautotunnel.data.dao.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.dao.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRoomRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.DataStoreAppStateRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.RoomSettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.RoomTunnelRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.domain.repository.TunnelRepository
+import com.zaneschepke.wireguardautotunnel.data.network.GitHubApi
+import com.zaneschepke.wireguardautotunnel.data.network.KtorClient
+import com.zaneschepke.wireguardautotunnel.data.network.KtorGitHubApi
+import com.zaneschepke.wireguardautotunnel.data.repository.*
+import com.zaneschepke.wireguardautotunnel.domain.repository.*
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
-import kotlinx.coroutines.CoroutineDispatcher
+import io.ktor.client.*
 import javax.inject.Singleton
+import kotlinx.coroutines.CoroutineDispatcher
 
 @Module
 @InstallIn(SingletonComponent::class)
 class RepositoryModule {
-	@Provides
-	@Singleton
-	fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
-		return Room.databaseBuilder(
-			context,
-			AppDatabase::class.java,
-			context.getString(R.string.db_name),
-		)
-			.fallbackToDestructiveMigration()
-			.addCallback(DatabaseCallback())
-			.build()
-	}
+    @Provides
+    @Singleton
+    fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
+        return Room.databaseBuilder(
+                context,
+                AppDatabase::class.java,
+                context.getString(R.string.db_name),
+            )
+            .fallbackToDestructiveMigration(true)
+            .addCallback(DatabaseCallback())
+            .build()
+    }
 
-	@Singleton
-	@Provides
-	fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
-		return appDatabase.settingDao()
-	}
+    @Singleton
+    @Provides
+    fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
+        return appDatabase.settingDao()
+    }
 
-	@Singleton
-	@Provides
-	fun provideTunnelConfigDoa(appDatabase: AppDatabase): TunnelConfigDao {
-		return appDatabase.tunnelConfigDoa()
-	}
+    @Singleton
+    @Provides
+    fun provideTunnelConfigDoa(appDatabase: AppDatabase): TunnelConfigDao {
+        return appDatabase.tunnelConfigDoa()
+    }
 
-	@Singleton
-	@Provides
-	fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): TunnelRepository {
-		return RoomTunnelRepository(tunnelConfigDao, ioDispatcher)
-	}
+    @Singleton
+    @Provides
+    fun provideTunnelConfigRepository(
+        tunnelConfigDao: TunnelConfigDao,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+    ): TunnelRepository {
+        return RoomTunnelRepository(tunnelConfigDao, ioDispatcher)
+    }
 
-	@Singleton
-	@Provides
-	fun provideSettingsRepository(settingsDao: SettingsDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): AppSettingRepository {
-		return RoomSettingsRepository(settingsDao, ioDispatcher)
-	}
+    @Singleton
+    @Provides
+    fun provideSettingsRepository(
+        settingsDao: SettingsDao,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+    ): AppSettingRepository {
+        return RoomSettingsRepository(settingsDao, ioDispatcher)
+    }
 
-	@Singleton
-	@Provides
-	fun providePreferencesDataStore(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): DataStoreManager {
-		return DataStoreManager(context, ioDispatcher)
-	}
+    @Singleton
+    @Provides
+    fun providePreferencesDataStore(
+        @ApplicationContext context: Context,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+    ): DataStoreManager {
+        return DataStoreManager(context, ioDispatcher)
+    }
 
-	@Provides
-	@Singleton
-	fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
-		return DataStoreAppStateRepository(dataStoreManager)
-	}
+    @Provides
+    @Singleton
+    fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
+        return DataStoreAppStateRepository(dataStoreManager)
+    }
 
-	@Provides
-	@Singleton
-	fun provideAppDataRepository(
-		settingsRepository: AppSettingRepository,
-		tunnelRepository: TunnelRepository,
-		appStateRepository: AppStateRepository,
-	): AppDataRepository {
-		return AppDataRoomRepository(settingsRepository, tunnelRepository, appStateRepository)
-	}
+    @Provides
+    @Singleton
+    fun provideAppDataRepository(
+        settingsRepository: AppSettingRepository,
+        tunnelRepository: TunnelRepository,
+        appStateRepository: AppStateRepository,
+    ): AppDataRepository {
+        return AppDataRoomRepository(settingsRepository, tunnelRepository, appStateRepository)
+    }
+
+    @Provides
+    @Singleton
+    fun provideHttpClient(): HttpClient {
+        return KtorClient.create()
+    }
+
+    @Provides
+    @Singleton
+    fun provideGitHubApi(client: HttpClient): GitHubApi {
+        return KtorGitHubApi(client)
+    }
+
+    @Provides
+    @Singleton
+    fun provideUpdateRepository(
+        gitHubApi: GitHubApi,
+        client: HttpClient,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+        @ApplicationContext context: Context,
+    ): UpdateRepository {
+        return GitHubUpdateRepository(
+            gitHubApi,
+            client,
+            "wgtunnel",
+            "wgtunnel",
+            context,
+            ioDispatcher,
+        )
+    }
 }

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

@@ -4,115 +4,170 @@ import android.content.Context
 import com.wireguard.android.backend.WgQuickBackend
 import com.wireguard.android.util.RootShell
 import com.wireguard.android.util.ToolsInstaller
+import com.zaneschepke.logcatter.LogReader
 import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
 import com.zaneschepke.networkmonitor.NetworkMonitor
 import com.zaneschepke.wireguardautotunnel.core.notification.NotificationManager
 import com.zaneschepke.wireguardautotunnel.core.service.ServiceManager
-import com.zaneschepke.wireguardautotunnel.core.tunnel.KernelTunnel
-import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelManager
-import com.zaneschepke.wireguardautotunnel.core.tunnel.TunnelProvider
-import com.zaneschepke.wireguardautotunnel.core.tunnel.UserspaceTunnel
+import com.zaneschepke.wireguardautotunnel.core.tunnel.*
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.domain.repository.AppSettingRepository
+import com.zaneschepke.wireguardautotunnel.util.network.NetworkUtils
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChangedBy
+import kotlinx.coroutines.flow.map
 import org.amnezia.awg.backend.Backend
 import org.amnezia.awg.backend.GoBackend
 import org.amnezia.awg.backend.RootTunnelActionHandler
-import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
 class TunnelModule {
 
-	@Provides
-	@Singleton
-	@TunnelShell
-	fun provideTunnelRootShell(@ApplicationContext context: Context): RootShell {
-		return RootShell(context)
-	}
+    @Provides
+    @Singleton
+    @TunnelShell
+    fun provideTunnelRootShell(@ApplicationContext context: Context): RootShell {
+        return RootShell(context)
+    }
 
-	@Provides
-	@Singleton
-	@AppShell
-	fun provideAppRootShell(@ApplicationContext context: Context): RootShell {
-		return RootShell(context)
-	}
+    @Provides
+    @Singleton
+    @AppShell
+    fun provideAppRootShell(@ApplicationContext context: Context): RootShell {
+        return RootShell(context)
+    }
 
-	@Provides
-	@Singleton
-	fun provideAmneziaBackend(@ApplicationContext context: Context): Backend {
-		return GoBackend(context, RootTunnelActionHandler(org.amnezia.awg.util.RootShell(context)))
-	}
+    @Provides
+    @Singleton
+    fun provideAmneziaBackend(@ApplicationContext context: Context): Backend {
+        return GoBackend(context, RootTunnelActionHandler(org.amnezia.awg.util.RootShell(context)))
+    }
 
-	@Provides
-	@Singleton
-	fun provideKernelBackend(@ApplicationContext context: Context, @TunnelShell shell: RootShell): com.wireguard.android.backend.Backend {
-		return WgQuickBackend(context, shell, ToolsInstaller(context, shell), com.wireguard.android.backend.RootTunnelActionHandler(shell)).also {
-			it.setMultipleTunnels(true)
-		}
-	}
+    @Provides
+    @Singleton
+    fun provideKernelBackend(
+        @ApplicationContext context: Context,
+        @TunnelShell shell: RootShell,
+    ): com.wireguard.android.backend.Backend {
+        return WgQuickBackend(
+                context,
+                shell,
+                ToolsInstaller(context, shell),
+                com.wireguard.android.backend.RootTunnelActionHandler(shell),
+            )
+            .also { it.setMultipleTunnels(true) }
+    }
 
-	@Provides
-	@Singleton
-	@Kernel
-	fun provideKernelProvider(
-		@IoDispatcher ioDispatcher: CoroutineDispatcher,
-		@ApplicationScope applicationScope: CoroutineScope,
-		serviceManager: ServiceManager,
-		appDataRepository: AppDataRepository,
-		notificationManager: NotificationManager,
-		backend: com.wireguard.android.backend.Backend,
-	): TunnelProvider {
-		return KernelTunnel(ioDispatcher, applicationScope, serviceManager, appDataRepository, notificationManager, backend)
-	}
+    @Provides
+    @Singleton
+    @Kernel
+    fun provideKernelProvider(
+        @ApplicationScope applicationScope: CoroutineScope,
+        serviceManager: ServiceManager,
+        appDataRepository: AppDataRepository,
+        backend: com.wireguard.android.backend.Backend,
+    ): TunnelProvider {
+        return KernelTunnel(applicationScope, serviceManager, appDataRepository, backend)
+    }
 
-	@Provides
-	@Singleton
-	@Userspace
-	fun provideUserspaceProvider(
-		@IoDispatcher ioDispatcher: CoroutineDispatcher,
-		@ApplicationScope applicationScope: CoroutineScope,
-		serviceManager: ServiceManager,
-		appDataRepository: AppDataRepository,
-		notificationManager: NotificationManager,
-		backend: Backend,
-	): TunnelProvider {
-		return UserspaceTunnel(ioDispatcher, applicationScope, serviceManager, appDataRepository, notificationManager, backend)
-	}
+    @Provides
+    @Singleton
+    @Userspace
+    fun provideUserspaceProvider(
+        @ApplicationScope applicationScope: CoroutineScope,
+        serviceManager: ServiceManager,
+        appDataRepository: AppDataRepository,
+        backend: Backend,
+    ): TunnelProvider {
+        return UserspaceTunnel(applicationScope, serviceManager, appDataRepository, backend)
+    }
 
-	@Provides
-	@Singleton
-	fun provideTunnelManager(
-		@Kernel kernelTunnel: TunnelProvider,
-		@Userspace userspaceTunnel: TunnelProvider,
-		appDataRepository: AppDataRepository,
-		@IoDispatcher ioDispatcher: CoroutineDispatcher,
-		@ApplicationScope applicationScope: CoroutineScope,
-	): TunnelManager {
-		return TunnelManager(kernelTunnel, userspaceTunnel, appDataRepository, applicationScope, ioDispatcher)
-	}
+    @Provides
+    @Singleton
+    fun provideTunnelManager(
+        @Kernel kernelTunnel: TunnelProvider,
+        @Userspace userspaceTunnel: TunnelProvider,
+        appDataRepository: AppDataRepository,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+        @ApplicationScope applicationScope: CoroutineScope,
+        notificationManager: NotificationManager,
+    ): TunnelManager {
+        return TunnelManager(
+            kernelTunnel,
+            userspaceTunnel,
+            appDataRepository,
+            applicationScope,
+            ioDispatcher,
+        )
+    }
 
-	@Provides
-	@Singleton
-	fun provideNetworkMonitor(@ApplicationContext context: Context, settingsRepository: AppSettingRepository): NetworkMonitor {
-		return AndroidNetworkMonitor(context) { runBlocking { settingsRepository.get().isWifiNameByShellEnabled } }
-	}
+    @Provides
+    @Singleton
+    fun provideNetworkMonitor(
+        @ApplicationContext context: Context,
+        settingsRepository: AppSettingRepository,
+        @ApplicationScope applicationScope: CoroutineScope,
+        @AppShell appShell: RootShell,
+    ): NetworkMonitor {
+        return AndroidNetworkMonitor(
+            context,
+            object : AndroidNetworkMonitor.ConfigurationListener {
+                override val detectionMethod: Flow<AndroidNetworkMonitor.WifiDetectionMethod>
+                    get() =
+                        settingsRepository.flow
+                            .distinctUntilChangedBy { it.wifiDetectionMethod }
+                            .map { it.wifiDetectionMethod }
 
-	@Singleton
-	@Provides
-	fun provideServiceManager(
-		@ApplicationContext context: Context,
-		@IoDispatcher ioDispatcher: CoroutineDispatcher,
-		@ApplicationScope applicationScope: CoroutineScope,
-		appDataRepository: AppDataRepository,
-	): ServiceManager {
-		return ServiceManager(context, ioDispatcher, applicationScope, appDataRepository)
-	}
+                override val rootShell: RootShell
+                    get() = appShell
+            },
+            applicationScope,
+        )
+    }
+
+    @Singleton
+    @Provides
+    fun provideServiceManager(
+        @ApplicationContext context: Context,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher,
+        @MainDispatcher mainCoroutineDispatcher: CoroutineDispatcher,
+        @ApplicationScope applicationScope: CoroutineScope,
+        appDataRepository: AppDataRepository,
+    ): ServiceManager {
+        return ServiceManager(
+            context,
+            ioDispatcher,
+            applicationScope,
+            mainCoroutineDispatcher,
+            appDataRepository,
+        )
+    }
+
+    @Singleton
+    @Provides
+    fun provideTunnelMonitor(
+        @ApplicationContext context: Context,
+        tunnelManager: TunnelManager,
+        networkMonitor: NetworkMonitor,
+        networkUtils: NetworkUtils,
+        logReader: LogReader,
+        appDataRepository: AppDataRepository,
+    ): TunnelMonitor {
+        return TunnelMonitor(
+            appDataRepository,
+            tunnelManager,
+            networkMonitor,
+            networkUtils,
+            logReader,
+        )
+    }
 }

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

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

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/entity/AppSettings.kt

@@ -1,29 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.entity
-
-data class AppSettings(
-	val id: Int = 0,
-	val isAutoTunnelEnabled: Boolean = false,
-	val isTunnelOnMobileDataEnabled: Boolean = false,
-	val trustedNetworkSSIDs: List<String> = emptyList(),
-	val isAlwaysOnVpnEnabled: Boolean = false,
-	val isTunnelOnEthernetEnabled: Boolean = false,
-	val isShortcutsEnabled: Boolean = false,
-	val isTunnelOnWifiEnabled: Boolean = false,
-	val isKernelEnabled: Boolean = false,
-	val isRestoreOnBootEnabled: Boolean = false,
-	val isMultiTunnelEnabled: Boolean = false,
-	val isPingEnabled: Boolean = false,
-	val isAmneziaEnabled: Boolean = false,
-	val isWildcardsEnabled: Boolean = false,
-	val isWifiNameByShellEnabled: Boolean = false,
-	val isStopOnNoInternetEnabled: Boolean = false,
-	val isVpnKillSwitchEnabled: Boolean = false,
-	val isKernelKillSwitchEnabled: Boolean = false,
-	val isLanOnKillSwitchEnabled: Boolean = false,
-	val debounceDelaySeconds: Int = 3,
-	val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
-) {
-	fun debounceDelayMillis(): Long {
-		return debounceDelaySeconds * 1000L
-	}
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/entity/AppState.kt

@@ -1,13 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.entity
-
-import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
-
-data class AppState(
-	val isLocationDisclosureShown: Boolean,
-	val isBatteryOptimizationDisableShown: Boolean,
-	val isPinLockEnabled: Boolean,
-	val isTunnelStatsExpanded: Boolean,
-	val isLocalLogsEnabled: Boolean,
-	val locale: String?,
-	val theme: Theme,
-)

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/entity/TunnelConf.kt

@@ -1,178 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.entity
-
-import com.wireguard.android.backend.Tunnel
-import com.wireguard.config.Config
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.extensions.defaultName
-import com.zaneschepke.wireguardautotunnel.util.extensions.extractNameAndNumber
-import com.zaneschepke.wireguardautotunnel.util.extensions.hasNumberInParentheses
-import com.zaneschepke.wireguardautotunnel.util.extensions.isReachable
-import com.zaneschepke.wireguardautotunnel.util.extensions.toWgQuickString
-import kotlinx.coroutines.withContext
-import timber.log.Timber
-import java.io.InputStream
-import java.net.InetAddress
-import java.nio.charset.StandardCharsets
-import kotlin.coroutines.CoroutineContext
-
-data class TunnelConf(
-	val id: Int = 0,
-	val tunName: String,
-	val wgQuick: String,
-	val tunnelNetworks: List<String> = emptyList(),
-	val isMobileDataTunnel: Boolean = false,
-	val isPrimaryTunnel: Boolean = false,
-	val amQuick: String,
-	val isActive: Boolean = false,
-	val isPingEnabled: Boolean = false,
-	val pingInterval: Long? = null,
-	val pingCooldown: Long? = null,
-	val pingIp: String? = null,
-	val isEthernetTunnel: Boolean = false,
-	val isIpv4Preferred: Boolean = true,
-	@Transient
-	private var stateChangeCallback: ((Any) -> Unit)? = null,
-	@Transient
-	private var tunnelStatsCallback: (() -> Unit)? = null,
-	@Transient
-	private var bounceTunnelCallback: ((TunnelConf) -> Unit)? = null,
-) : Tunnel, org.amnezia.awg.backend.Tunnel {
-
-	fun setStateChangeCallback(callback: (Any) -> Unit) {
-		stateChangeCallback = callback
-	}
-
-	fun setTunnelStatsCallback(callback: (() -> Unit)) {
-		tunnelStatsCallback = callback
-	}
-
-	fun setBounceTunnelCallback(callback: (TunnelConf) -> Unit) {
-		bounceTunnelCallback = callback
-	}
-
-	fun copyWithCallback(
-		id: Int = this.id,
-		tunName: String = this.tunName,
-		wgQuick: String = this.wgQuick,
-		tunnelNetworks: List<String> = this.tunnelNetworks,
-		isMobileDataTunnel: Boolean = this.isMobileDataTunnel,
-		isPrimaryTunnel: Boolean = this.isPrimaryTunnel,
-		amQuick: String = this.amQuick,
-		isActive: Boolean = this.isActive,
-		isPingEnabled: Boolean = this.isPingEnabled,
-		pingInterval: Long? = this.pingInterval,
-		pingCooldown: Long? = this.pingCooldown,
-		pingIp: String? = this.pingIp,
-		isEthernetTunnel: Boolean = this.isEthernetTunnel,
-		isIpv4Preferred: Boolean = this.isIpv4Preferred,
-	): TunnelConf {
-		return TunnelConf(
-			id, tunName, wgQuick, tunnelNetworks, isMobileDataTunnel, isPrimaryTunnel,
-			amQuick, isActive, isPingEnabled, pingInterval, pingCooldown, pingIp,
-			isEthernetTunnel, isIpv4Preferred,
-		).apply {
-			stateChangeCallback = this@TunnelConf.stateChangeCallback
-			tunnelStatsCallback = this@TunnelConf.tunnelStatsCallback
-			bounceTunnelCallback = this@TunnelConf.bounceTunnelCallback
-		}
-	}
-
-	fun onUpdateStatistics() {
-		tunnelStatsCallback?.invoke()
-	}
-
-	fun bounceTunnel(tunnelConf: TunnelConf) {
-		bounceTunnelCallback?.invoke(tunnelConf)
-	}
-
-	fun toAmConfig(): org.amnezia.awg.config.Config {
-		return configFromAmQuick(amQuick.ifBlank { wgQuick })
-	}
-
-	fun toWgConfig(): Config {
-		return configFromWgQuick(wgQuick)
-	}
-
-	override fun getName(): String = tunName
-
-	override fun isIpv4ResolutionPreferred(): Boolean = isIpv4Preferred
-
-	override fun onStateChange(newState: org.amnezia.awg.backend.Tunnel.State) {
-		stateChangeCallback?.invoke(newState)
-	}
-
-	override fun onStateChange(newState: Tunnel.State) {
-		stateChangeCallback?.invoke(newState)
-	}
-
-	fun isTunnelConfigChanged(updatedConf: TunnelConf): Boolean {
-		return updatedConf.wgQuick != wgQuick || updatedConf.amQuick != amQuick || updatedConf.name != name
-	}
-
-	fun generateUniqueName(tunnelNames: List<String>): String {
-		var tunnelName = this.tunName
-		var num = 1
-		while (tunnelNames.any { it == tunnelName }) {
-			tunnelName = if (!tunnelName.hasNumberInParentheses()) {
-				"$name($num)"
-			} else {
-				val pair = tunnelName.extractNameAndNumber()
-				"${pair?.first}($num)"
-			}
-			num++
-		}
-		return tunnelName
-	}
-
-	suspend fun isTunnelPingable(context: CoroutineContext): Boolean {
-		return withContext(context) {
-			val config = toWgConfig()
-			if (pingIp != null) {
-				return@withContext InetAddress.getByName(pingIp)
-					.isReachable(Constants.PING_TIMEOUT.toInt()).also {
-						Timber.i("Ping reachable $pingIp: $it")
-					}
-			}
-			config.peers.map { peer ->
-				peer.isReachable()
-			}.all { true }.also {
-				Timber.i("Ping of all peers reachable: $it")
-			}
-		}
-	}
-
-	companion object {
-		fun configFromWgQuick(wgQuick: String): Config {
-			val inputStream: InputStream = wgQuick.byteInputStream()
-			return inputStream.bufferedReader(StandardCharsets.UTF_8).use {
-				Config.parse(it)
-			}
-		}
-
-		fun configFromAmQuick(amQuick: String): org.amnezia.awg.config.Config {
-			val inputStream: InputStream = amQuick.byteInputStream()
-			return inputStream.bufferedReader(StandardCharsets.UTF_8).use {
-				org.amnezia.awg.config.Config.parse(it)
-			}
-		}
-
-		fun tunnelConfigFromAmConfig(config: org.amnezia.awg.config.Config, name: String? = null): TunnelConf {
-			val amQuick = config.toAwgQuickString(true)
-			val wgQuick = config.toWgQuickString()
-			return TunnelConf(tunName = name ?: config.defaultName(), wgQuick = wgQuick, amQuick = amQuick)
-		}
-
-		private const val IPV6_ALL_NETWORKS = "::/0"
-		private const val IPV4_ALL_NETWORKS = "0.0.0.0/0"
-		val ALL_IPS = listOf(IPV4_ALL_NETWORKS, IPV6_ALL_NETWORKS)
-		private val IPV4_PUBLIC_NETWORKS = listOf(
-			"0.0.0.0/5", "8.0.0.0/7", "11.0.0.0/8", "12.0.0.0/6", "16.0.0.0/4", "32.0.0.0/3",
-			"64.0.0.0/2", "128.0.0.0/3", "160.0.0.0/5", "168.0.0.0/6", "172.0.0.0/12",
-			"172.32.0.0/11", "172.64.0.0/10", "172.128.0.0/9", "173.0.0.0/8", "174.0.0.0/7",
-			"176.0.0.0/4", "192.0.0.0/9", "192.128.0.0/11", "192.160.0.0/13", "192.169.0.0/16",
-			"192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10",
-			"193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6", "200.0.0.0/5", "208.0.0.0/4",
-		)
-		val LAN_BYPASS_ALLOWED_IPS = listOf(IPV6_ALL_NETWORKS) + IPV4_PUBLIC_NETWORKS
-	}
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/enums/BackendError.kt

@@ -1,8 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.domain.enums
-
-sealed class BackendError() {
-	data object DNS : BackendError()
-	data object Unauthorized : BackendError()
-	data object Config : BackendError()
-	data object Unknown : BackendError()
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/enums/BackendState.kt

@@ -1,7 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.domain.enums
 
 enum class BackendState {
-	KILL_SWITCH_ACTIVE,
-	SERVICE_ACTIVE,
-	INACTIVE,
+    KILL_SWITCH_ACTIVE,
+    SERVICE_ACTIVE,
+    INACTIVE,
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/enums/ConfigType.kt

@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.domain.enums
 
 enum class ConfigType {
-	AMNEZIA,
-	WG,
+    AM,
+    WG,
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/enums/HandshakeStatus.kt

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

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/enums/NotificationAction.kt

@@ -4,14 +4,13 @@ import android.content.Context
 import com.zaneschepke.wireguardautotunnel.R
 
 enum class NotificationAction {
-	TUNNEL_OFF,
-	AUTO_TUNNEL_OFF,
-	;
+    TUNNEL_OFF,
+    AUTO_TUNNEL_OFF;
 
-	fun title(context: Context): String {
-		return when (this) {
-			TUNNEL_OFF -> context.getString(R.string.stop)
-			AUTO_TUNNEL_OFF -> context.getString(R.string.stop)
-		}
-	}
+    fun title(context: Context): String {
+        return when (this) {
+            TUNNEL_OFF -> context.getString(R.string.stop)
+            AUTO_TUNNEL_OFF -> context.getString(R.string.stop)
+        }
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/enums/TunnelStatus.kt

@@ -1,17 +1,36 @@
 package com.zaneschepke.wireguardautotunnel.domain.enums
 
-enum class TunnelStatus {
-	UP,
-	DOWN,
-	STARTING,
-	STOPPING,
-	;
+sealed class TunnelStatus {
 
-	fun isDown(): Boolean {
-		return this == DOWN
-	}
+    data object Up : TunnelStatus()
 
-	fun isUp(): Boolean {
-		return this == UP
-	}
+    data object Down : TunnelStatus()
+
+    data class Stopping(val reason: StopReason) : TunnelStatus()
+
+    data object Starting : TunnelStatus()
+
+    sealed class StopReason {
+        data object User : StopReason()
+
+        data class Ping(val previouslyResolvedEndpoints: Map<String, String?>) : StopReason()
+
+        data object ConfigChanged : StopReason()
+    }
+
+    fun isDown(): Boolean {
+        return this == Down
+    }
+
+    fun isUp(): Boolean {
+        return this == Up
+    }
+
+    fun isUpOrStarting(): Boolean {
+        return this == Up || this == Starting
+    }
+
+    fun isDownOrStopping(): Boolean {
+        return this == Down || this is Stopping
+    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/events/AutoTunnelEvent.kt

@@ -1,9 +1,18 @@
 package com.zaneschepke.wireguardautotunnel.domain.events
 
-import com.zaneschepke.wireguardautotunnel.domain.entity.TunnelConf
+import com.zaneschepke.wireguardautotunnel.domain.model.TunnelConf
 
 sealed class AutoTunnelEvent {
-	data class Start(val tunnelConf: TunnelConf? = null) : AutoTunnelEvent()
-	data object Stop : AutoTunnelEvent()
-	data object DoNothing : AutoTunnelEvent()
+    data class Start(val tunnelConf: TunnelConf? = null) : AutoTunnelEvent()
+
+    data class Bounce(val configsPeerKeyResolvedMap: List<Pair<TunnelConf, Map<String, String?>>>) :
+        AutoTunnelEvent()
+
+    data object Stop : AutoTunnelEvent()
+
+    data object DoNothing : AutoTunnelEvent()
+
+    data class StartKillSwitch(val allowedIps: List<String>) : AutoTunnelEvent()
+
+    data object StopKillSwitch : AutoTunnelEvent()
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/events/BackendError.kt

@@ -0,0 +1,48 @@
+package com.zaneschepke.wireguardautotunnel.domain.events
+
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+
+sealed class BackendError : Exception() {
+    data object DNS : BackendError()
+
+    data object Unauthorized : BackendError()
+
+    data object Config : BackendError()
+
+    data object KernelModuleName : BackendError()
+
+    data object NotAuthorized : BackendError()
+
+    data object ServiceNotRunning : BackendError()
+
+    data object Unknown : BackendError()
+
+    data object TunnelNameTooLong : BackendError()
+
+    data class BounceFailed(val error: BackendError) : BackendError()
+
+    fun toStringRes() =
+        when (this) {
+            Config -> R.string.config_error
+            DNS -> R.string.dns_resolve_error
+            KernelModuleName -> R.string.kernel_name_error
+            NotAuthorized,
+            Unauthorized -> R.string.auth_error
+            ServiceNotRunning -> R.string.service_running_error
+            Unknown -> R.string.unknown_error
+            TunnelNameTooLong -> R.string.error_tunnel_name
+            is BounceFailed -> R.string.bounce_failed_template
+        }
+
+    fun toStringValue(): StringValue {
+        return when (val backendError = this) {
+            is BounceFailed ->
+                StringValue.StringResource(
+                    backendError.toStringRes(),
+                    backendError.error.toStringRes(),
+                )
+            else -> StringValue.StringResource(backendError.toStringRes())
+        }
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/events/BackendMessage.kt

@@ -0,0 +1,19 @@
+package com.zaneschepke.wireguardautotunnel.domain.events
+
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.util.StringValue
+
+sealed class BackendMessage {
+
+    data object BounceSuccess : BackendMessage()
+
+    data object BounceRecovery : BackendMessage()
+
+    fun toStringRes() =
+        when (this) {
+            BounceRecovery -> R.string.pinger_bounce_recovery
+            BounceSuccess -> R.string.pinger_bounce_successful
+        }
+
+    fun toStringValue() = StringValue.StringResource(this.toStringRes())
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/events/KillSwitchEvent.kt

@@ -1,7 +1,9 @@
 package com.zaneschepke.wireguardautotunnel.domain.events
 
 sealed class KillSwitchEvent {
-	data class Start(val allowedIps: List<String>) : KillSwitchEvent()
-	data object Stop : KillSwitchEvent()
-	data object DoNothing : KillSwitchEvent()
+    data class Start(val allowedIps: List<String>) : KillSwitchEvent()
+
+    data object Stop : KillSwitchEvent()
+
+    data object DoNothing : KillSwitchEvent()
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/model/AppSettings.kt

@@ -0,0 +1,44 @@
+package com.zaneschepke.wireguardautotunnel.domain.model
+
+import com.zaneschepke.networkmonitor.AndroidNetworkMonitor
+
+data class AppSettings(
+    val id: Int = 0,
+    val isAutoTunnelEnabled: Boolean = false,
+    val isTunnelOnMobileDataEnabled: Boolean = false,
+    val trustedNetworkSSIDs: List<String> = emptyList(),
+    val isAlwaysOnVpnEnabled: Boolean = false,
+    val isTunnelOnEthernetEnabled: Boolean = false,
+    val isShortcutsEnabled: Boolean = false,
+    val isTunnelOnWifiEnabled: Boolean = false,
+    val isKernelEnabled: Boolean = false,
+    val isRestoreOnBootEnabled: Boolean = false,
+    val isMultiTunnelEnabled: Boolean = false,
+    val isPingEnabled: Boolean = false,
+    val isAmneziaEnabled: Boolean = false,
+    val isWildcardsEnabled: Boolean = false,
+    val isStopOnNoInternetEnabled: Boolean = false,
+    val isVpnKillSwitchEnabled: Boolean = false,
+    val isKernelKillSwitchEnabled: Boolean = false,
+    val isLanOnKillSwitchEnabled: Boolean = false,
+    val debounceDelaySeconds: Int = 3,
+    val isDisableKillSwitchOnTrustedEnabled: Boolean = false,
+    val isTunnelOnUnsecureEnabled: Boolean = false,
+    val wifiDetectionMethod: AndroidNetworkMonitor.WifiDetectionMethod =
+        AndroidNetworkMonitor.WifiDetectionMethod.DEFAULT,
+    val tunnelPingIntervalSeconds: Int = 30,
+    val tunnelPingAttempts: Int = 3,
+    val tunnelPingTimeoutSeconds: Int? = null,
+) {
+    fun toAutoTunnelStateString(): String {
+        return """
+            TunnelOnWifi: $isTunnelOnWifiEnabled
+            TunnelOnMobileData: $isTunnelOnMobileDataEnabled
+            TunnelOnEthernet: $isTunnelOnEthernetEnabled
+            Wildcards: $isWildcardsEnabled
+            StopOnNoInternet: $isStopOnNoInternetEnabled
+            Trusted Networks: $trustedNetworkSSIDs
+        """
+            .trimIndent()
+    }
+}

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/model/AppState.kt

@@ -0,0 +1,16 @@
+package com.zaneschepke.wireguardautotunnel.domain.model
+
+import com.zaneschepke.wireguardautotunnel.ui.theme.Theme
+
+data class AppState(
+    val isLocationDisclosureShown: Boolean,
+    val isBatteryOptimizationDisableShown: Boolean,
+    val isPinLockEnabled: Boolean,
+    val expandedTunnelIds: List<Int>,
+    val isLocalLogsEnabled: Boolean,
+    val isRemoteControlEnabled: Boolean,
+    val showDetailedPingStats: Boolean,
+    val remoteKey: String?,
+    val locale: String?,
+    val theme: Theme,
+)

app/src/main/java/com/zaneschepke/wireguardautotunnel/domain/model/AppUpdate.kt

@@ -0,0 +1,9 @@
+package com.zaneschepke.wireguardautotunnel.domain.model
+
+data class AppUpdate(
+    val version: String,
+    val title: String,
+    val releaseNotes: String,
+    val apkUrl: String?,
+    val apkFileName: String?,
+)