chore: typo fix readme

increase auto tunnel delay to 3 seconds

optimize stats job by killing it when app is backgrounded

fix tunnel launch from background

add restart of services and tunnels after update

.editorconfig

@@ -0,0 +1,97 @@
+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/CODE_OF_CONDUCT.md

@@ -0,0 +1,22 @@
+# Contributor Code of Conduct
+
+## Pledge
+
+We as individuals involved in this project, pledge to participate in this
+community in a respectful, constructive, and civil manner as we work towards a common goal
+of delivering free, open source, and value adding software for all.
+
+## Standard
+
+The standard for this community is the Golden Rule.
+
+> “Do unto others as you would have them do unto you.”
+
+## Scope
+
+This Code of Conduct applies to all spaces related to WG Tunnel.
+
+## Incidents or Concerns
+
+For any incidents or concerns, reach out to Zane at
+<support@zaneschepke.com>.

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+ko_fi: zaneschepke
+liberapay: zaneschepke

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,33 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG] - Problem with app"
+labels: bug
+assignees: zaneschepke
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Smartphone (please complete the following information):**
+
+- Device: [e.g. Pixel 4a]
+- Android Version: [e.g. Android 13]
+- App Version [e.g. 3.3.3]
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots (Only if necessary)**
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEATURE] - New feature request"
+labels: enhancement
+assignees: zaneschepke
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/SUPPORT.md

@@ -0,0 +1,17 @@
+# Support
+
+If you are experiencing issues with the app, the following resources are available to help you.
+
+<ol>
+  <li>
+    See the app docs site <a href="https://zaneschepke.com/wgtunnel-docs/overview.html">here</a> (work in progress).
+  </li>
+  <li>
+    Chat with me and our community on Discord <a href="https://discord.gg/rbRRNh6H7V">here</a>, or open an issue on GitHub <a href="https://github.com/zaneschepke/wgtunnel/issues/new/choose">here</a>.
+  </li>
+  <li>
+    Send me an email <a href="mailto:zanecschepke@gmail.com">here</a>.
+  </li>
+</ol>
+
+Thank you for using WG Tunnel.

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: daily
+  - package-ecosystem: gradle
+    directory: /
+    schedule:
+      interval: daily

.github/workflows/ci.yml

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

.github/workflows/issue-workflow.yml

@@ -0,0 +1,20 @@
+name: Issue Updates Workflow
+
+on:
+  issues:
+    types: [ opened, closed, reopened ]
+
+
+jobs:
+
+  build:
+    name: Build
+    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/publish-workflow.yml

@@ -0,0 +1,21 @@
+name: Release Updates Workflow
+
+on:
+  release:
+    types: [ published ]
+
+
+jobs:
+
+  build:
+    name: Build
+    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/release.yml

@@ -0,0 +1,236 @@
+name: release-android
+
+on:
+  schedule:
+    - cron: "4 3 * * *"
+  workflow_dispatch:
+    inputs:
+      track:
+        type: choice
+        description: "Google play release track"
+        options:
+          - none
+          - internal
+          - alpha
+          - beta
+          - production
+        default: alpha
+        required: true
+      release_type:
+        type: choice
+        description: "GitHub release type"
+        options:
+          - none
+          - prerelease
+          - nightly
+          - release
+        default: release
+        required: true
+      tag_name:
+        description: "Tag name for release"
+        required: false
+        default: nightly
+
+jobs:
+  build:
+    name: Build Signed APK
+    if: ${{ inputs.release_type != 'none' }}
+    runs-on: ubuntu-latest
+
+    env:
+      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
+      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
+      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
+      KEY_STORE_FILE: 'android_keystore.jks'
+      KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
+      GH_USER: ${{ secrets.GH_USER }}
+      # GH needed for gh cli
+      GH_TOKEN: ${{ secrets.GH_TOKEN }}
+      GH_REPO: ${{ github.repository }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: gradle
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      - name: Install system dependencies
+        run: |
+          sudo apt update && sudo apt install -y gh apksigner
+
+      # Here we need to decode keystore.jks from base64 string and place it
+      # in the folder specified in the release signing configuration
+      - name: Decode Keystore
+        id: decode_keystore
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: ${{ env.KEY_STORE_FILE }}
+          fileDir: ${{ env.KEY_STORE_LOCATION }}
+          encodedString: ${{ secrets.KEYSTORE }}
+
+      # create keystore path for gradle to read
+      - name: Create keystore path env var
+        run: |
+          store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
+          echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
+
+      - name: Create service_account.json
+        id: createServiceAccount
+        run: echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
+
+      # Build and sign APK ("-x test" argument is used to skip tests)
+      # add fdroid flavor for apk upload
+      - name: Build Fdroid Release APK
+        if: ${{ inputs.release_type != '' && inputs.release_type == 'release' }}
+        run: ./gradlew :app:assembleFdroidRelease -x test
+
+      - name: Build Fdroid Prerelease APK
+        if: ${{ inputs.release_type != '' && inputs.release_type == 'prerelease' }}
+        run: ./gradlew :app:assembleFdroidPrerelease -x test
+
+      - name: Build Fdroid Nightly APK
+        if: ${{ inputs.release_type == '' || inputs.release_type == 'nightly' }}
+        run: ./gradlew :app:assembleFdroidNightly -x test
+
+      - if: ${{ inputs.release_type == '' || inputs.release_type == 'nightly' }}
+        run: echo "APK_PATH=$(find . -regex '^.*/build/outputs/apk/fdroid/nightly/.*\.apk$' -type f | head -1)" >> $GITHUB_ENV
+      - if: ${{ inputs.release_type != '' && inputs.release_type == 'release' }}
+        run: echo "APK_PATH=$(find . -regex '^.*/build/outputs/apk/fdroid/release/.*\.apk$' -type f | head -1)" >> $GITHUB_ENV
+      - if: ${{ inputs.release_type != '' && inputs.release_type == 'prerelease' }}
+        run: echo "APK_PATH=$(find . -regex '^.*/build/outputs/apk/fdroid/prerelease/.*\.apk$' -type f | head -1)" >> $GITHUB_ENV
+
+      - name: Get version code
+        if: ${{ inputs.release_type == 'release' }}
+        run: |
+          version_code=$(grep "VERSION_CODE" buildSrc/src/main/kotlin/Constants.kt | awk '{print $5}' | tr -d '\n')
+          echo "VERSION_CODE=$version_code" >> $GITHUB_ENV
+
+      # Save the APK after the Build job is complete to publish it as a Github release in the next job
+      - name: Upload APK
+        uses: actions/upload-artifact@v4.3.6
+        with:
+          name: wgtunnel
+          path: ${{ env.APK_PATH }}
+
+      - name: Download APK from build
+        uses: actions/download-artifact@v4
+        with:
+          name: wgtunnel
+
+      - name: Repository Dispatch for my F-Droid repo
+        uses: peter-evans/repository-dispatch@v3
+        if: ${{ inputs.release_type == 'release' }}
+        with:
+          token: ${{ secrets.PAT }}
+          repository: zaneschepke/fdroid
+          event-type: fdroid-update
+
+      # Setup TAG_NAME, which is used as a general "name"
+      - if: github.event_name == 'workflow_dispatch'
+        run: echo "TAG_NAME=${{ github.event.inputs.tag_name }}" >> $GITHUB_ENV
+      - if: github.event_name == 'schedule'
+        run: echo "TAG_NAME=nightly" >> $GITHUB_ENV
+
+      - name: Set version release notes
+        if: ${{ inputs.release_type == 'release' }}
+        run: |
+          RELEASE_NOTES="$(cat ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt)"
+          echo "RELEASE_NOTES<<EOF" >> $GITHUB_ENV
+          echo "$RELEASE_NOTES" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: On nightly release notes
+        if: ${{ contains(env.TAG_NAME, 'nightly') }}
+        run: |
+          echo "RELEASE_NOTES=Nightly build for the latest development version of the app." >> $GITHUB_ENV
+          gh release delete nightly --yes || true
+
+      - name: On prerelease release notes
+        if: ${{ inputs.release_type == 'prerelease' }}
+        run: |
+          echo "RELEASE_NOTES=Testing version of app for specific feature." >> $GITHUB_ENV
+          gh release delete ${{ github.event.inputs.tag_name }} --yes || true
+
+      - name: Get checksum
+        id: checksum
+        run: echo "checksum=$(apksigner verify -print-certs ${{ env.APK_PATH }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
+
+
+      - name: Create Release with Fastlane changelog notes
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          body: |
+            ${{ env.RELEASE_NOTES }}
+
+            SHA256 fingerprint:
+            ```${{ steps.checksum.outputs.checksum }}```
+          tag_name: ${{ env.TAG_NAME }}
+          name: ${{ env.TAG_NAME }}
+          draft: false
+          prerelease: ${{ inputs.release_type == 'prerelease' || inputs.release_type == '' || inputs.release_type == 'nightly' }}
+          make_latest: ${{ inputs.release_type == 'release' }}
+          files: ${{ github.workspace }}/${{ env.APK_PATH }}
+
+  publish-play:
+    if: ${{ inputs.track != 'none' && inputs.track != '' }}
+    name: Publish to Google Play
+    runs-on: ubuntu-latest
+
+    env:
+      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
+      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
+      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
+      KEY_STORE_FILE: 'android_keystore.jks'
+      KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
+      GH_USER: ${{ secrets.GH_USER }}
+      GH_TOKEN: ${{ secrets.GH_TOKEN }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: gradle
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      # Here we need to decode keystore.jks from base64 string and place it
+      # in the folder specified in the release signing configuration
+      - name: Decode Keystore
+        id: decode_keystore
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: ${{ env.KEY_STORE_FILE }}
+          fileDir: ${{ env.KEY_STORE_LOCATION }}
+          encodedString: ${{ secrets.KEYSTORE }}
+
+      # create keystore path for gradle to read
+      - name: Create keystore path env var
+        run: |
+          store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
+          echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
+
+      - name: Create service_account.json
+        id: createServiceAccount
+        run: echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
+
+      - name: Deploy with fastlane
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2' # Not needed with a .ruby-version file
+          bundler-cache: true
+
+      - name: Distribute app to Prod track 🚀
+        run: (cd ${{ github.workspace }} && bundle install && bundle exec fastlane ${{ inputs.track }})
+

.gitignore

@@ -69,3 +69,6 @@ lint/tmp/
 # App Specific cases
 app/release/output.json
 .idea/codeStyles/
+# where we keep our signing secrets locally
+app/signing.properties
+/.kotlin/

Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "fastlane"

README.md

@@ -2,60 +2,109 @@
 WG Tunnel
 </h1>
 
-<span align="center">
+<div align="center">
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Discord Chat](https://img.shields.io/discord/1108285024631001111.svg)](https://discord.gg/rbRRNh6H7V)
+[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/rbRRNh6H7V)
+[![X Community](https://img.shields.io/badge/X-000000?style=for-the-badge&logo=x&logoColor=white)](https://twitter.com/i/communities/1780655267685736818)
+[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/wgtunnel)
 
-</span>
+</div>
 
-<span align="center">
+<div align="center">
 
 
 [![Google Play](https://img.shields.io/badge/Google_Play-414141?style=for-the-badge&logo=google-play&logoColor=white)](https://play.google.com/store/apps/details?id=com.zaneschepke.wireguardautotunnel)
+[![F-Droid](https://img.shields.io/static/v1?style=for-the-badge&message=F-Droid&color=1976D2&logo=F-Droid&logoColor=FFFFFF&label=)](https://f-droid.org/packages/com.zaneschepke.wireguardautotunnel/)
 
-</span>
 
-<span align="left">
+</div>
 
-This is an alternative Android Application for [WireGuard](https://www.wireguard.com/) with added features. Built using the [wireguard-android](https://github.com/WireGuard/wireguard-android) library and [Jetpack Compose](https://developer.android.com/jetpack/compose), this application was inspired by the official [WireGuard Android](https://github.com/WireGuard/wireguard-android) app.
 
-</span>
+<div align="left">
 
-<span align="center">
+This is an alternative Android Application for [WireGuard](https://www.wireguard.com/)
+and [AmneziaWG](https://docs.amnezia.org/documentation/amnezia-wg/) with added
+features. Built using the [wireguard-android](https://github.com/WireGuard/wireguard-android)
+library and [Jetpack Compose](https://developer.android.com/jetpack/compose), this application was
+inspired by the official [WireGuard Android](https://github.com/WireGuard/wireguard-android) app.
+
+</div>
+
+<div align="center">
 
 ## Screenshots
 
 <p float="center">
-  <img label="Main" style="padding-right:25px" src="asset/main_screen.png" width="200" />
-  <img label="Config" style="padding-left:25px" src="./asset/config_screen.png" width="200" />
-  <img label="Settings" style="padding-left:25px" src="./asset/settings_screen.png" width="200" />
-  <img label="Support" style="padding-left:25px" src="./asset/support_screen.png" width="200" />
+  <img label="Main" style="padding-right:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/main_screen.png" width="200" />
+  <img label="Config" style="padding-left:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/config_screen.png" width="200" />
+  <img label="Settings" style="padding-left:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/settings_screen.png" width="200" />
+  <img label="Support" style="padding-left:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/support_screen.png" width="200" />
 </p>
 
-<span align="left">
+<div align="left">
 
 ## Inspiration
 
-The inspiration for this app came from the inconvenience of constantly having to turn VPN off and on while on different networks. With there being no free solution to this problem, this app was created to meet that need.
+The original inspiration for this app came from the inconvenience of having to manually turn VPN off
+and on while on different networks. This app was created to offer a free solution to this problem.
 
 ## Features
 
-* Add tunnels via .conf file
-* Auto connect to VPN based on Wi-Fi SSID
-* Split tunneling by application
-* Configurable Trusted Network list 
-* Optional auto connect on mobile data
-* Automatic service restart after reboot
-* Service will stay running in background after app has been closed
+* Add tunnels via .conf file, zip, manual entry, or QR code
+* Auto connect to tunnels based on Wi-Fi SSID, ethernet, or mobile data
+* Split tunneling by application with search
+* WireGuard support for kernel and userspace modes
+* Amnezia support for userspace mode for DPI/censorship protection
+* Pre/Post Up/Down scripts support for all modes on a rooted device
+* Always-On VPN support
+* Export Amnezia and WireGuard tunnels to zip
+* Quick tile support for tunnel toggling, auto-tunneling
+* Static shortcuts support for tunnel toggling, auto-tunneling
+* Intent automation support for all tunnels
+* Automatic auto-tunneling service and/or tunnel restart after reboot or app update
+* Battery preservation measures
+* Restart tunnel on ping failure (beta)
 
+## Fdroid
+
+Want updates faster?
+
+Check out my personal [fdroid repository](https://github.com/zaneschepke/fdroid) to get updates the
+moment they are released.
+
+## Docs
+
+Information about features, behaviors, and answers to common questions can be found in the
+app [documentation](https://zaneschepke.com/wgtunnel-docs/overview.html).
+
+The repository for these docs can be found [here](https://github.com/zaneschepke/wgtunnel-docs).
+
+## Translation
+
+This app is using [Weblate](https://weblate.org) to assist with translations.
+
+Help translate WG Tunnel into your language
+at [Hosted Weblate](https://hosted.weblate.org/engage/wg-tunnel/).\
+[![Translation status](https://hosted.weblate.org/widgets/wg-tunnel/-/multi-auto.svg)](https://hosted.weblate.org/engage/wg-tunnel/)
 
 ## Building
-    
+
 ```
 $ git clone https://github.com/zaneschepke/wgtunnel
 $ cd wgtunnel
-$ ./gradlew assembleRelease
 ```
 
-</span>
+And then build the app:
+
+```
+$ ./gradlew assembleDebug
+```
+
+## Contributing
+
+Any contributions in the form of feedback, issues, code, or translations are welcome and much
+appreciated!
+
+Please read
+the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct)
+before contributing.

SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security issues to `support@zaneschepke.com`

app/build.gradle.kts

@@ -1,133 +1,210 @@
-val rExtra = rootProject.extra
-
 plugins {
-    id("com.android.application")
-    id("org.jetbrains.kotlin.android")
-    kotlin("kapt")
-    id("com.google.dagger.hilt.android")
-    id("com.google.gms.google-services")
-    id("com.google.firebase.crashlytics")
-    id("org.jetbrains.kotlin.plugin.serialization")
-    id("io.objectbox")
+	alias(libs.plugins.android.application)
+	alias(libs.plugins.kotlin.android)
+	alias(libs.plugins.hilt.android)
+	alias(libs.plugins.kotlinxSerialization)
+	alias(libs.plugins.ksp)
+	alias(libs.plugins.compose.compiler)
+	alias(libs.plugins.grgit)
 }
 
 android {
-    namespace = "com.zaneschepke.wireguardautotunnel"
-    compileSdk = 34
+	namespace = Constants.APP_ID
+	compileSdk = Constants.TARGET_SDK
 
-    val versionMajor = 2
-    val versionMinor = 1
-    val versionPatch = 4
-    val versionBuild = 0
+	androidResources {
+		generateLocaleConfig = true
+	}
 
-    defaultConfig {
-        applicationId = "com.zaneschepke.wireguardautotunnel"
-        minSdk = 29
-        targetSdk = 34
-        versionCode = versionMajor * 10000 + versionMinor * 1000 + versionPatch * 100 + versionBuild
-        versionName = "${versionMajor}.${versionMinor}.${versionPatch}"
+	defaultConfig {
+		applicationId = Constants.APP_ID
+		minSdk = Constants.MIN_SDK
+		targetSdk = Constants.TARGET_SDK
+		versionCode = determineVersionCode()
+		versionName = determineVersionName()
 
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        vectorDrawables {
-            useSupportLibrary = true
-        }
-    }
+		ksp { arg("room.schemaLocation", "$projectDir/schemas") }
 
-    buildTypes {
-        release {
-            isDebuggable = false
-            isMinifyEnabled = false
-            proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
-            )
-        }
-    }
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
-    }
-    kotlinOptions {
-        jvmTarget = "17"
-    }
-    buildFeatures {
-        compose = true
-    }
-    composeOptions {
-        kotlinCompilerExtensionVersion = "1.4.8"
-    }
-    packaging {
-        resources {
-            excludes += "/META-INF/{AL2.0,LGPL2.1}"
-        }
-    }
+		sourceSets {
+			getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
+		}
+
+		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)
+		}
+	}
+
+	buildTypes {
+		// don't strip
+		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)
+		}
+		debug { isDebuggable = true }
+
+		create(Constants.PRERELEASE) {
+			initWith(buildTypes.getByName(Constants.RELEASE))
+		}
+
+		create(Constants.NIGHTLY) {
+			initWith(buildTypes.getByName(Constants.RELEASE))
+		}
+
+		applicationVariants.all {
+			val variant = this
+			variant.outputs
+				.map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
+				.forEach { output ->
+					val outputFileName =
+						"${Constants.APP_NAME}-${variant.flavorName}-" +
+							"${variant.buildType.name}-${variant.versionName}.apk"
+					output.outputFileName = outputFileName
+				}
+		}
+	}
+	flavorDimensions.add(Constants.TYPE)
+	productFlavors {
+		create("fdroid") {
+			dimension = Constants.TYPE
+			proguardFile("fdroid-rules.pro")
+		}
+		create("general") {
+			dimension = Constants.TYPE
+		}
+	}
+	compileOptions {
+		sourceCompatibility = JavaVersion.VERSION_17
+		targetCompatibility = JavaVersion.VERSION_17
+		isCoreLibraryDesugaringEnabled = true
+	}
+	kotlinOptions { jvmTarget = Constants.JVM_TARGET }
+	buildFeatures {
+		compose = true
+		buildConfig = true
+	}
+	packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
+val generalImplementation by configurations
+
 dependencies {
-    implementation("androidx.core:core-ktx:1.10.1")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.1")
-    implementation("androidx.activity:activity-compose:1.7.2")
-    implementation(platform("androidx.compose:compose-bom:2023.03.00"))
-    implementation("androidx.compose.ui:ui")
-    implementation("androidx.compose.ui:ui-graphics")
-    implementation("androidx.compose.ui:ui-tooling-preview")
-    implementation("androidx.compose.material3:material3:1.1.1")
-    implementation("androidx.appcompat:appcompat:1.6.1")
 
-    testImplementation("junit:junit:4.13.2")
-    androidTestImplementation("androidx.test.ext:junit:1.1.5")
-    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
-    androidTestImplementation(platform("androidx.compose:compose-bom:2023.03.00"))
-    androidTestImplementation("androidx.compose.ui:ui-test-junit4")
-    debugImplementation("androidx.compose.ui:ui-tooling")
-    debugImplementation("androidx.compose.ui:ui-test-manifest")
+	implementation(project(":logcatter"))
 
-    //wireguard tunnel
-    implementation("com.wireguard.android:tunnel:1.0.20230427")
+	implementation(libs.androidx.core.ktx)
+	implementation(libs.androidx.lifecycle.runtime.ktx)
 
-    //logging
-    implementation("com.jakewharton.timber:timber:5.0.1")
+	// 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)
 
-    // compose navigation
-    implementation("androidx.navigation:navigation-compose:2.6.0")
-    implementation("androidx.hilt:hilt-navigation-compose:1.0.0")
+	// 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)
 
-    // hilt
-    implementation("com.google.dagger:hilt-android:${rExtra.get("hiltVersion")}")
-    kapt("com.google.dagger:hilt-android-compiler:${rExtra.get("hiltVersion")}")
+	// get tunnel lib from github packages or mavenLocal
+// 	implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
+	implementation(libs.tunnel)
+	implementation(libs.amneziawg.android)
+	coreLibraryDesugaring(libs.desugar.jdk.libs)
 
-    //accompanist
-    implementation("com.google.accompanist:accompanist-systemuicontroller:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-permissions:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-flowlayout:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-navigation-animation:${rExtra.get("accompanistVersion")}")
-    implementation("com.google.accompanist:accompanist-drawablepainter:${rExtra.get("accompanistVersion")}")
+	// logging
+	implementation(libs.timber)
 
-    //db
-    implementation("io.objectbox:objectbox-kotlin:${rExtra.get("objectBoxVersion")}")
+	// compose navigation
+	implementation(libs.androidx.navigation.compose)
+	implementation(libs.androidx.hilt.navigation.compose)
 
-    //lifecycle
-    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.6.1")
+	implementation(libs.zaneschepke.multifab)
 
-    //icons
-    implementation("androidx.compose.material:material-icons-extended:1.4.3")
+	// hilt
+	implementation(libs.hilt.android)
+	ksp(libs.hilt.android.compiler)
 
+	// accompanist
+	implementation(libs.accompanist.permissions)
+	implementation(libs.accompanist.flowlayout)
+	implementation(libs.accompanist.drawablepainter)
 
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1")
+	// storage
+	implementation(libs.androidx.room.runtime)
+	ksp(libs.androidx.room.compiler)
+	implementation(libs.androidx.room.ktx)
+	implementation(libs.androidx.datastore.preferences)
 
+	// lifecycle
+	implementation(libs.lifecycle.runtime.compose)
+	implementation(libs.androidx.lifecycle.runtime.ktx)
+	implementation(libs.androidx.lifecycle.process)
 
-    //firebase crashlytics
-    implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
-    implementation("com.google.firebase:firebase-crashlytics-ktx")
-    implementation("com.google.firebase:firebase-analytics-ktx")
+	// icons
+	implementation(libs.material.icons.extended)
+	// serialization
+	implementation(libs.kotlinx.serialization.json)
 
-    //barcode scanning
-    implementation("com.google.android.gms:play-services-code-scanner:16.0.0")
+	// barcode scanning
+	implementation(libs.zxing.android.embedded)
 
+	// bio
+	implementation(libs.androidx.biometric.ktx)
+	implementation(libs.pin.lock.compose)
 
+	// shortcuts
+	implementation(libs.androidx.core)
+	implementation(libs.androidx.core.google.shortcuts)
 
+	// splash
+	implementation(libs.androidx.core.splashscreen)
 }
 
-kapt {
-    correctErrorTypes = true
-}
+fun determineVersionCode(): Int {
+	return with(getBuildTaskName().lowercase()) {
+		when {
+			contains(Constants.NIGHTLY) -> Constants.VERSION_CODE + Constants.NIGHTLY_CODE
+			contains(Constants.PRERELEASE) -> Constants.VERSION_CODE + Constants.PRERELEASE_CODE
+			else -> Constants.VERSION_CODE
+		}
+	}
+}
+
+fun determineVersionName(): String {
+	return with(getBuildTaskName().lowercase()) {
+		when {
+			contains(Constants.NIGHTLY) || contains(Constants.PRERELEASE) ->
+				Constants.VERSION_NAME +
+					"-${grgitService.service.get().grgit.head().abbreviatedId}"
+			else -> Constants.VERSION_NAME
+		}
+	}
+}

app/fdroid-rules.pro

@@ -0,0 +1,5 @@
+-dontwarn com.google.errorprone.annotations.**
+
+-keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
+    <fields>;
+}

app/google-services.json

@@ -1,39 +0,0 @@
-{
-  "project_info": {
-    "project_number": "328300975830",
-    "project_id": "wireguard-auto-tunnel",
-    "storage_bucket": "wireguard-auto-tunnel.appspot.com"
-  },
-  "client": [
-    {
-      "client_info": {
-        "mobilesdk_app_id": "1:328300975830:android:82cd774598ccb7234b1b77",
-        "android_client_info": {
-          "package_name": "com.zaneschepke.wireguardautotunnel"
-        }
-      },
-      "oauth_client": [
-        {
-          "client_id": "328300975830-m72lc3hr69ddhdqh9ngr27rvc8o0jb2d.apps.googleusercontent.com",
-          "client_type": 3
-        }
-      ],
-      "api_key": [
-        {
-          "current_key": "AIzaSyBsSMY0LlckizXDnuYBy7nXWGSdl8zZedI"
-        }
-      ],
-      "services": {
-        "appinvite_service": {
-          "other_platform_oauth_client": [
-            {
-              "client_id": "328300975830-m72lc3hr69ddhdqh9ngr27rvc8o0jb2d.apps.googleusercontent.com",
-              "client_type": 3
-            }
-          ]
-        }
-      }
-    }
-  ],
-  "configuration_version": "1"
-}

app/objectbox-models/default.json

@@ -1,94 +0,0 @@
-{
-  "_note1": "KEEP THIS FILE! Check it into a version control system (VCS) like git.",
-  "_note2": "ObjectBox manages crucial IDs for your object model. See docs for details.",
-  "_note3": "If you have VCS merge conflicts, you must resolve them according to ObjectBox docs.",
-  "entities": [
-    {
-      "id": "1:2692736974585027589",
-      "lastPropertyId": "15:5057486545428188436",
-      "name": "TunnelConfig",
-      "properties": [
-        {
-          "id": "1:1985347930017457084",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "12:2409068226744965585",
-          "name": "name",
-          "indexId": "1:4811206443952699137",
-          "type": 9,
-          "flags": 34848
-        },
-        {
-          "id": "13:8987443291286312275",
-          "name": "wgQuick",
-          "type": 9
-        }
-      ],
-      "relations": []
-    },
-    {
-      "id": "2:8887605597748372702",
-      "lastPropertyId": "8:4981008812459251156",
-      "name": "Settings",
-      "properties": [
-        {
-          "id": "1:7485739868216068651",
-          "name": "id",
-          "type": 6,
-          "flags": 1
-        },
-        {
-          "id": "2:5814013113141456749",
-          "name": "isAutoTunnelEnabled",
-          "type": 1
-        },
-        {
-          "id": "4:5645665441196906014",
-          "name": "trustedNetworkSSIDs",
-          "type": 30
-        },
-        {
-          "id": "5:4989886999117763881",
-          "name": "isTunnelOnMobileDataEnabled",
-          "type": 1
-        },
-        {
-          "id": "6:3370284381040192129",
-          "name": "defaultTunnel",
-          "type": 9
-        }
-      ],
-      "relations": []
-    }
-  ],
-  "lastEntityId": "2:8887605597748372702",
-  "lastIndexId": "1:4811206443952699137",
-  "lastRelationId": "0:0",
-  "lastSequenceId": "0:0",
-  "modelVersion": 5,
-  "modelVersionParserMinimum": 5,
-  "retiredEntityUids": [],
-  "retiredIndexUids": [],
-  "retiredPropertyUids": [
-    1763475292291320186,
-    6483820955437198310,
-    8323071516033820771,
-    5904440563612311217,
-    1408037976996390989,
-    7737847485212546994,
-    8215616901775229364,
-    8021610768066328637,
-    6174306582797008721,
-    2175939938544485767,
-    7555225587864607050,
-    969146862000617878,
-    5057486545428188436,
-    2814640993034665120,
-    4981008812459251156
-  ],
-  "retiredRelationUids": [],
-  "version": 1
-}

app/objectbox-models/default.json.bak

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

app/proguard-rules.pro

@@ -18,4 +18,7 @@
 
 # If you keep the line number information, uncomment this to
 # hide the original source file name.
-#-renamesourcefileattribute SourceFile
+#-renamesourcefileattribute SourceFile
+-keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
+    <fields>;
+}

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

@@ -0,0 +1,112 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "ba86153e6fb0b823197b987239b03e64",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `default_tunnel` TEXT, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "defaultTunnel",
+            "columnName": "default_tunnel",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'ba86153e6fb0b823197b987239b03e64')"
+    ]
+  }
+}

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

@@ -0,0 +1,126 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "65b1c9efff61712231fa64d1f19f3915",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `default_tunnel` TEXT, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_battery_saver_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "defaultTunnel",
+            "columnName": "default_tunnel",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isBatterySaverEnabled",
+            "columnName": "is_battery_saver_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '65b1c9efff61712231fa64d1f19f3915')"
+    ]
+  }
+}

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

@@ -0,0 +1,133 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 3,
+    "identityHash": "6b30daba29bb95f8ddc4d26206329d4f",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `default_tunnel` TEXT, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_battery_saver_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "defaultTunnel",
+            "columnName": "default_tunnel",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isBatterySaverEnabled",
+            "columnName": "is_battery_saver_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnWifiEnabled",
+            "columnName": "is_tunnel_on_wifi_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6b30daba29bb95f8ddc4d26206329d4f')"
+    ]
+  }
+}

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

@@ -0,0 +1,154 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 4,
+    "identityHash": "aee55639422df8dadfe74c3bad204477",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `default_tunnel` TEXT, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_battery_saver_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_enabled` INTEGER NOT NULL DEFAULT false, `is_restore_on_boot_enabled` INTEGER NOT NULL DEFAULT false, `is_multi_tunnel_enabled` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "defaultTunnel",
+            "columnName": "default_tunnel",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isBatterySaverEnabled",
+            "columnName": "is_battery_saver_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnWifiEnabled",
+            "columnName": "is_tunnel_on_wifi_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelEnabled",
+            "columnName": "is_kernel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isRestoreOnBootEnabled",
+            "columnName": "is_restore_on_boot_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isMultiTunnelEnabled",
+            "columnName": "is_multi_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'aee55639422df8dadfe74c3bad204477')"
+    ]
+  }
+}

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

@@ -0,0 +1,161 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 5,
+    "identityHash": "bc15003a44746e18b9c260ec49737089",
+    "entities": [
+      {
+        "tableName": "Settings",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `is_tunnel_enabled` INTEGER NOT NULL, `is_tunnel_on_mobile_data_enabled` INTEGER NOT NULL, `trusted_network_ssids` TEXT NOT NULL, `default_tunnel` TEXT, `is_always_on_vpn_enabled` INTEGER NOT NULL, `is_tunnel_on_ethernet_enabled` INTEGER NOT NULL, `is_shortcuts_enabled` INTEGER NOT NULL DEFAULT false, `is_battery_saver_enabled` INTEGER NOT NULL DEFAULT false, `is_tunnel_on_wifi_enabled` INTEGER NOT NULL DEFAULT false, `is_kernel_enabled` INTEGER NOT NULL DEFAULT false, `is_restore_on_boot_enabled` INTEGER NOT NULL DEFAULT false, `is_multi_tunnel_enabled` INTEGER NOT NULL DEFAULT false, `is_auto_tunnel_paused` INTEGER NOT NULL DEFAULT false)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isAutoTunnelEnabled",
+            "columnName": "is_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnMobileDataEnabled",
+            "columnName": "is_tunnel_on_mobile_data_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "trustedNetworkSSIDs",
+            "columnName": "trusted_network_ssids",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "defaultTunnel",
+            "columnName": "default_tunnel",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "isAlwaysOnVpnEnabled",
+            "columnName": "is_always_on_vpn_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isTunnelOnEthernetEnabled",
+            "columnName": "is_tunnel_on_ethernet_enabled",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isShortcutsEnabled",
+            "columnName": "is_shortcuts_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isBatterySaverEnabled",
+            "columnName": "is_battery_saver_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isTunnelOnWifiEnabled",
+            "columnName": "is_tunnel_on_wifi_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isKernelEnabled",
+            "columnName": "is_kernel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isRestoreOnBootEnabled",
+            "columnName": "is_restore_on_boot_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isMultiTunnelEnabled",
+            "columnName": "is_multi_tunnel_enabled",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          },
+          {
+            "fieldPath": "isAutoTunnelPaused",
+            "columnName": "is_auto_tunnel_paused",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "false"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "TunnelConfig",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `wg_quick` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "wgQuick",
+            "columnName": "wg_quick",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_TunnelConfig_name",
+            "unique": true,
+            "columnNames": [
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_TunnelConfig_name` ON `${TABLE_NAME}` (`name`)"
+          }
+        ],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'bc15003a44746e18b9c260ec49737089')"
+    ]
+  }
+}

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

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

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

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

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

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

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

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

app/signing_template.properties

@@ -0,0 +1,4 @@
+SIGNING_STORE_PASSWORD=
+SIGNING_KEY_ALIAS=
+SIGNING_KEY_PASSWORD=
+KEY_STORE_PATH=/

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

@@ -1,13 +1,11 @@
 package com.zaneschepke.wireguardautotunnel
 
-import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.ext.junit.runners.AndroidJUnit4
-
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.junit.runner.RunWith
 
-import org.junit.Assert.*
-
 /**
  * Instrumented test, which will execute on an Android device.
  *
@@ -15,10 +13,10 @@ import org.junit.Assert.*
  */
 @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

@@ -0,0 +1,44 @@
+package com.zaneschepke.wireguardautotunnel
+
+import androidx.room.testing.MigrationTestHelper
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import com.zaneschepke.wireguardautotunnel.data.Queries
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.IOException
+
+@RunWith(AndroidJUnit4::class)
+class MigrationTest {
+	private val dbName = "migration-test"
+
+	@get:Rule
+	val helper: MigrationTestHelper =
+		MigrationTestHelper(
+			InstrumentationRegistry.getInstrumentation(),
+			AppDatabase::class.java,
+		)
+
+	@Test
+	@Throws(IOException::class)
+	fun 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.
+	}
+}

app/src/main/AndroidManifest.xml

@@ -1,81 +1,213 @@
 <?xml version="1.0" encoding="utf-8"?>
 <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.READ_EXTERNAL_STORAGE"
+    <uses-permission
+        android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="32" />
-    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"
-        android:maxSdkVersion="30" />
+    <uses-permission
+        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="32"
+        tools:ignore="ScopedStorage" />
+    <uses-permission
+        android:name="android.permission.ACCESS_WIFI_STATE"
+        android:maxSdkVersion="30"
+        tools:ignore="LeanbackUsesWifi" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
-    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
-    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING"/>
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+    <!--foreground service exempt android 14-->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED" />
+    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
+
     <!--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"/>
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <!--android tv support-->
+
+	<permission
+		android:name="${applicationId}.permission.CONTROL_TUNNELS"
+		android:icon="@mipmap/ic_launcher"
+		android:protectionLevel="dangerous" />
+
+    <uses-feature
+        android:name="android.software.leanback"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.touchscreen"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.location.gps"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.screen.portrait"
+        android:required="false" />
+
     <queries>
         <intent>
             <action android:name="android.intent.action.MAIN" />
         </intent>
     </queries>
     <application
-        android:allowBackup="true"
         android:name=".WireGuardAutoTunnel"
+        android:allowBackup="false"
+        android:banner="@drawable/ic_banner"
         android:dataExtractionRules="@xml/data_extraction_rules"
+        android:enableOnBackInvokedCallback="true"
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.WireguardAutoTunnel"
-        tools:targetApi="31">
+        android:theme="@style/Theme.AppSplashScreen"
+        tools:targetApi="tiramisu">
+        <activity
+            android:name=".ui.SplashActivity"
+            android:exported="true"
+            android:theme="@style/Theme.AppSplashScreen">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
+                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
+            </intent-filter>
+            <meta-data
+                android:name="android.app.shortcuts"
+                android:resource="@xml/shortcuts" />
+        </activity>
         <activity
             android:name=".ui.MainActivity"
             android:exported="true"
             android:theme="@style/Theme.WireguardAutoTunnel">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
         </activity>
+        <activity
+            android:name="com.journeyapps.barcodescanner.CaptureActivity"
+            android:screenOrientation="portrait"
+            tools:replace="screenOrientation" />
+
+        <activity
+            android:name=".service.shortcut.ShortcutsActivity"
+            android:enabled="true"
+            android:exported="true"
+			android:noHistory="true"
+			android:excludeFromRecents="true"
+			android:finishOnTaskLaunch="true"
+			android:launchMode="singleInstance"
+            android:theme="@android:style/Theme.NoDisplay" />
+
         <service
             android:name=".service.foreground.ForegroundService"
             android:enabled="true"
-            android:foregroundServiceType="remoteMessaging"
-            android:exported="false">
-        </service>
+            android:exported="false"
+            android:foregroundServiceType="systemExempted"
+            tools:node="merge" />
         <service
-            android:name=".service.foreground.WireGuardTunnelService"
-            android:enabled="true"
-            android:foregroundServiceType="remoteMessaging"
-            android:exported="false">
-        </service>
-        <service
-            android:name=".service.foreground.WireGuardConnectivityWatcherService"
-            android:enabled="true"
-            android:stopWithTask="false"
-            android:foregroundServiceType="location"
-            android:permission=""
-            android:exported="false">
-        </service>
-        <receiver android:enabled="true" android:name=".receiver.BootReceiver"
-            android:exported="true">
+            android:name=".service.tile.TunnelControlTile"
+            android:exported="true"
+            android:icon="@drawable/ic_launcher"
+            android:label="Tunnel control"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+            <meta-data
+                android:name="android.service.quicksettings.ACTIVE_TILE"
+                android:value="true" />
+            <meta-data
+                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
+                android:value="true" />
+
             <intent-filter>
-                <action android:name="android.intent.action.BOOT_COMPLETED"/>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
+        <service
+            android:name=".service.tile.AutoTunnelControlTile"
+            android:exported="true"
+            android:icon="@drawable/ic_launcher"
+            android:label="Auto-tunnel"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+            <meta-data
+                android:name="android.service.quicksettings.ACTIVE_TILE"
+                android:value="true" />
+            <meta-data
+                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
+                android:value="true" />
+
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
+		<service
+			android:name=".service.tunnel.AlwaysOnVpnService"
+			android:enabled="true"
+			android:exported="false"
+			android:foregroundServiceType="systemExempted"
+			android:permission="android.permission.BIND_VPN_SERVICE"
+			android:persistent="true"
+			tools:node="merge">
+			<intent-filter>
+				<action android:name="android.net.VpnService" />
+			</intent-filter>
+			<meta-data
+				android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
+				android:value="true" />
+		</service>
+        <service
+            android:name=".service.foreground.AutoTunnelService"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="systemExempted"
+            android:persistent="true"
+            android:stopWithTask="false"
+            tools:node="merge" />
+
+		<service
+			android:name=".service.foreground.TunnelBackgroundService"
+			android:exported="false"
+			android:foregroundServiceType="systemExempted"
+			android:permission="android.permission.BIND_VPN_SERVICE">
+			<intent-filter>
+				<action android:name="android.net.VpnService" />
+			</intent-filter>
+		</service>
+
+        <receiver
+            android:name=".receiver.BootReceiver"
+            android:enabled="true"
+            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.ACTION_BOOT_COMPLETED" />
+                <action android:name="android.intent.action.QUICKBOOT_POWERON" />
+                <action android:name="com.htc.intent.action.QUICKBOOT_POWERON" />
             </intent-filter>
         </receiver>
-        <receiver android:exported="false" android:name=".receiver.NotificationActionReceiver"/>
-        <meta-data
-            android:name="com.google.mlkit.vision.DEPENDENCIES"
-            android:value="barcode_ui"/>
-        <meta-data
-            android:name="firebase_crashlytics_collection_enabled"
-            android:value="true" />
+		<receiver
+			android:name=".receiver.BackgroundActionReceiver"
+			android:enabled="true"
+			android:exported="false"/>
+		<receiver
+			android:name=".receiver.AppUpdateReceiver"
+			android:exported="false">
+			<intent-filter>
+				<action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+			</intent-filter>
+		</receiver>
+		<receiver
+			android:name=".receiver.KernelReceiver"
+			android:exported="false"
+			android:permission="${applicationId}.permission.CONTROL_TUNNELS">
+			<intent-filter>
+				<action android:name="com.wireguard.android.action.REFRESH_TUNNEL_STATES" />
+			</intent-filter>
+		</receiver>
     </application>
-</manifest>
+</manifest>

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

@@ -1,25 +1,59 @@
 package com.zaneschepke.wireguardautotunnel
 
 import android.app.Application
-import com.google.firebase.crashlytics.FirebaseCrashlytics
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
+import android.os.StrictMode
+import android.os.StrictMode.ThreadPolicy
+import com.zaneschepke.logcatter.LocalLogCollector
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
+import com.zaneschepke.wireguardautotunnel.util.extensions.isRunningOnTv
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
 
-    @Inject
-    lateinit var settingsRepo : Repository<Settings>
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
 
-    override fun onCreate() {
-        super.onCreate()
-        if(BuildConfig.DEBUG) {
-            FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(false);
-            Timber.plant(Timber.DebugTree())
-        }
-        settingsRepo.init()
-    }
-}
+	@Inject
+	lateinit var localLogCollector: LocalLogCollector
+
+	@Inject
+	@IoDispatcher
+	lateinit var ioDispatcher: CoroutineDispatcher
+
+	override fun onCreate() {
+		super.onCreate()
+		instance = this
+		if (BuildConfig.DEBUG) {
+			Timber.plant(Timber.DebugTree())
+			StrictMode.setThreadPolicy(
+				ThreadPolicy.Builder()
+					.detectDiskReads()
+					.detectDiskWrites()
+					.detectNetwork()
+					.penaltyLog()
+					.build(),
+			)
+		} else {
+			Timber.plant(ReleaseTree())
+		}
+		if (!isRunningOnTv()) {
+			applicationScope.launch(ioDispatcher) {
+				localLogCollector.start()
+			}
+		}
+	}
+
+	companion object {
+		lateinit var instance: WireGuardAutoTunnel
+			private set
+	}
+}

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

@@ -0,0 +1,56 @@
+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.migration.AutoMigrationSpec
+import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+
+@Database(
+	entities = [Settings::class, TunnelConfig::class],
+	version = 9,
+	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),
+	],
+	exportSchema = true,
+)
+@TypeConverters(DatabaseListConverters::class)
+abstract class AppDatabase : RoomDatabase() {
+	abstract fun settingDao(): SettingsDao
+
+	abstract fun tunnelConfigDoa(): TunnelConfigDao
+}
+
+@DeleteColumn(
+	tableName = "Settings",
+	columnName = "default_tunnel",
+)
+@DeleteColumn(
+	tableName = "Settings",
+	columnName = "is_battery_saver_enabled",
+)
+class RemoveLegacySettingColumnsMigration : AutoMigrationSpec

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

@@ -0,0 +1,21 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.RoomDatabase
+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()
+		}
+	}
+}

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

@@ -0,0 +1,24 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.TypeConverter
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+class DatabaseListConverters {
+	@TypeConverter
+	fun listToString(value: MutableList<String>): String {
+		return Json.encodeToString(value)
+	}
+
+	@TypeConverter
+	fun stringToList(value: String): MutableList<String> {
+		if (value.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

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

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

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

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

@@ -0,0 +1,55 @@
+package com.zaneschepke.wireguardautotunnel.data
+
+import androidx.room.Dao
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import com.zaneschepke.wireguardautotunnel.data.domain.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 saveAll(t: TunnelConfigs)
+
+	@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 is_Active=1")
+	suspend fun getActive(): TunnelConfigs
+
+	@Query("SELECT * FROM TunnelConfig")
+	suspend fun getAll(): TunnelConfigs
+
+	@Delete
+	suspend fun delete(t: TunnelConfig)
+
+	@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("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("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")
+	fun getAllFlow(): Flow<MutableList<TunnelConfig>>
+}

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

@@ -0,0 +1,79 @@
+package com.zaneschepke.wireguardautotunnel.data.datastore
+
+import android.content.Context
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+import java.io.IOException
+
+class DataStoreManager(
+	private val context: Context,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+) {
+	companion object {
+		val LOCATION_DISCLOSURE_SHOWN = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
+		val BATTERY_OPTIMIZE_DISABLE_SHOWN = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
+		val LAST_ACTIVE_TUNNEL = intPreferencesKey("LAST_ACTIVE_TUNNEL")
+		val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
+		val IS_PIN_LOCK_ENABLED = booleanPreferencesKey("PIN_LOCK_ENABLED")
+	}
+
+	// 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.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.e(e)
+			} catch (e: Exception) {
+				Timber.e(e)
+			}
+		}
+	}
+
+	fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map { it[key] }
+
+	suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
+		return withContext(ioDispatcher) {
+			try {
+				context.dataStore.data.map { it[key] }.first()
+			} catch (e: IOException) {
+				Timber.e(e)
+				null
+			}
+		}
+	}
+
+	fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
+		context.dataStore.data.map { it[key] }.first()
+	}
+
+	val preferencesFlow: Flow<Preferences?> = context.dataStore.data
+}

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

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

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

@@ -0,0 +1,58 @@
+package com.zaneschepke.wireguardautotunnel.data.domain
+
+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: 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_auto_tunnel_paused",
+		defaultValue = "false",
+	)
+	val isAutoTunnelPaused: Boolean = false,
+	@ColumnInfo(
+		name = "is_ping_enabled",
+		defaultValue = "false",
+	)
+	val isPingEnabled: Boolean = false,
+	@ColumnInfo(
+		name = "is_amnezia_enabled",
+		defaultValue = "false",
+	)
+	val isAmneziaEnabled: Boolean = false,
+)

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

@@ -0,0 +1,62 @@
+package com.zaneschepke.wireguardautotunnel.data.domain
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import com.wireguard.config.Config
+import java.io.InputStream
+
+@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,
+) {
+	companion object {
+		fun findDefault(tunnels: List<TunnelConfig>): TunnelConfig? {
+			return tunnels.find { it.isPrimaryTunnel } ?: tunnels.firstOrNull()
+		}
+
+		fun configFromWgQuick(wgQuick: String): Config {
+			val inputStream: InputStream = wgQuick.byteInputStream()
+			return inputStream.bufferedReader(Charsets.UTF_8).use {
+				Config.parse(it)
+			}
+		}
+
+		fun configFromAmQuick(amQuick: String): org.amnezia.awg.config.Config {
+			val inputStream: InputStream = amQuick.byteInputStream()
+			return inputStream.bufferedReader(Charsets.UTF_8).use {
+				org.amnezia.awg.config.Config.parse(it)
+			}
+		}
+
+		const val AM_QUICK_DEFAULT = ""
+	}
+}

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

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

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

@@ -0,0 +1,22 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import javax.inject.Inject
+
+class AppDataRoomRepository
+@Inject
+constructor(
+	override val settings: SettingsRepository,
+	override val tunnels: TunnelConfigRepository,
+	override val appState: AppStateRepository,
+) : AppDataRepository {
+	override suspend fun getPrimaryOrFirstTunnel(): TunnelConfig? {
+		return tunnels.findPrimary().firstOrNull() ?: tunnels.getAll().firstOrNull()
+	}
+
+	override suspend fun getStartTunnelConfig(): TunnelConfig? {
+		return appState.getLastActiveTunnelId()?.let {
+			tunnels.getById(it)
+		} ?: getPrimaryOrFirstTunnel()
+	}
+}

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

@@ -0,0 +1,28 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import kotlinx.coroutines.flow.Flow
+
+interface AppStateRepository {
+	suspend fun isLocationDisclosureShown(): Boolean
+
+	suspend fun setLocationDisclosureShown(shown: Boolean)
+
+	suspend fun isPinLockEnabled(): Boolean
+
+	suspend fun setPinLockEnabled(enabled: Boolean)
+
+	suspend fun isBatteryOptimizationDisableShown(): Boolean
+
+	suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
+
+	suspend fun getLastActiveTunnelId(): Int?
+
+	suspend fun setLastActiveTunnelId(id: Int)
+
+	suspend fun getCurrentSsid(): String?
+
+	suspend fun setCurrentSsid(ssid: String)
+
+	val generalStateFlow: Flow<GeneralState>
+}

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

@@ -0,0 +1,88 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+
+class DataStoreAppStateRepository(
+	private val dataStoreManager: DataStoreManager,
+	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+) :
+	AppStateRepository {
+	override suspend fun isLocationDisclosureShown(): Boolean {
+		return withContext(ioDispatcher) {
+			dataStoreManager.getFromStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN)
+				?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
+		}
+	}
+
+	override suspend fun setLocationDisclosureShown(shown: Boolean) {
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown) }
+	}
+
+	override suspend fun isPinLockEnabled(): Boolean {
+		return withContext(ioDispatcher) {
+			dataStoreManager.getFromStore(DataStoreManager.IS_PIN_LOCK_ENABLED)
+				?: GeneralState.PIN_LOCK_ENABLED_DEFAULT
+		}
+	}
+
+	override suspend fun setPinLockEnabled(enabled: Boolean) {
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.IS_PIN_LOCK_ENABLED, enabled) }
+	}
+
+	override suspend fun isBatteryOptimizationDisableShown(): Boolean {
+		return withContext(ioDispatcher) {
+			dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
+				?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
+		}
+	}
+
+	override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN, shown) }
+	}
+
+	override suspend fun getLastActiveTunnelId(): Int? {
+		return withContext(ioDispatcher) { dataStoreManager.getFromStore(DataStoreManager.LAST_ACTIVE_TUNNEL) }
+	}
+
+	override suspend fun setLastActiveTunnelId(id: Int) {
+		return withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.LAST_ACTIVE_TUNNEL, id) }
+	}
+
+	override suspend fun getCurrentSsid(): String? {
+		return withContext(ioDispatcher) { dataStoreManager.getFromStore(DataStoreManager.CURRENT_SSID) }
+	}
+
+	override suspend fun setCurrentSsid(ssid: String) {
+		withContext(ioDispatcher) { dataStoreManager.saveToDataStore(DataStoreManager.CURRENT_SSID, ssid) }
+	}
+
+	override val generalStateFlow: Flow<GeneralState> =
+		dataStoreManager.preferencesFlow.map { prefs ->
+			prefs?.let { pref ->
+				try {
+					GeneralState(
+						isLocationDisclosureShown =
+						pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
+							?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+						isBatteryOptimizationDisableShown =
+						pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
+							?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+						isPinLockEnabled =
+						pref[DataStoreManager.IS_PIN_LOCK_ENABLED]
+							?: GeneralState.PIN_LOCK_ENABLED_DEFAULT,
+						lastActiveTunnelId = pref[DataStoreManager.LAST_ACTIVE_TUNNEL],
+					)
+				} catch (e: IllegalArgumentException) {
+					Timber.e(e)
+					GeneralState()
+				}
+			} ?: GeneralState()
+		}
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,40 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.module
-
-import android.content.Context
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.MyObjectBox
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import javax.inject.Singleton
-
-@Module
-@InstallIn(SingletonComponent::class)
-class BoxModule {
-
-    @Provides
-    @Singleton
-    fun provideBoxStore(@ApplicationContext context : Context) : BoxStore {
-        return MyObjectBox.builder()
-            .androidContext(context.applicationContext)
-            .build()
-    }
-
-    @Provides
-    @Singleton
-    fun provideBoxForSettings(store : BoxStore) : Box<Settings> {
-        return store.boxFor(Settings::class.java)
-    }
-
-    @Provides
-    @Singleton
-    fun provideBoxForTunnels(store : BoxStore) : Box<TunnelConfig> {
-        return store.boxFor(TunnelConfig::class.java)
-    }
-
-}

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

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

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

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

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

@@ -1,25 +1,88 @@
 package com.zaneschepke.wireguardautotunnel.module
 
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.repository.SettingsBox
-import com.zaneschepke.wireguardautotunnel.repository.TunnelBox
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import dagger.Binds
+import android.content.Context
+import androidx.room.Room
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import com.zaneschepke.wireguardautotunnel.data.DatabaseCallback
+import com.zaneschepke.wireguardautotunnel.data.SettingsDao
+import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
+import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRoomRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.DataStoreAppStateRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.RoomSettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.RoomTunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
 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 javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
-abstract class RepositoryModule {
+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()
+	}
 
-    @Binds
-    @Singleton
-    abstract fun provideSettingsRepository(settingsBox: SettingsBox) : Repository<Settings>
+	@Singleton
+	@Provides
+	fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
+		return appDatabase.settingDao()
+	}
 
-    @Binds
-    @Singleton
-    abstract fun provideTunnelRepository(tunnelBox: TunnelBox) : Repository<TunnelConfig>
-}
+	@Singleton
+	@Provides
+	fun provideTunnelConfigDoa(appDatabase: AppDatabase): TunnelConfigDao {
+		return appDatabase.tunnelConfigDoa()
+	}
+
+	@Singleton
+	@Provides
+	fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): TunnelConfigRepository {
+		return RoomTunnelConfigRepository(tunnelConfigDao, ioDispatcher)
+	}
+
+	@Singleton
+	@Provides
+	fun provideSettingsRepository(settingsDao: SettingsDao, @IoDispatcher ioDispatcher: CoroutineDispatcher): SettingsRepository {
+		return RoomSettingsRepository(settingsDao, ioDispatcher)
+	}
+
+	@Singleton
+	@Provides
+	fun providePreferencesDataStore(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): DataStoreManager {
+		return DataStoreManager(context, ioDispatcher)
+	}
+
+	@Provides
+	@Singleton
+	fun provideGeneralStateRepository(dataStoreManager: DataStoreManager, @IoDispatcher ioDispatcher: CoroutineDispatcher): AppStateRepository {
+		return DataStoreAppStateRepository(dataStoreManager, ioDispatcher)
+	}
+
+	@Provides
+	@Singleton
+	fun provideAppDataRepository(
+		settingsRepository: SettingsRepository,
+		tunnelConfigRepository: TunnelConfigRepository,
+		appStateRepository: AppStateRepository,
+	): AppDataRepository {
+		return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
+	}
+}

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

@@ -1,41 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.module
-
-import android.content.Context
-import com.google.mlkit.vision.barcode.common.Barcode
-import com.google.mlkit.vision.codescanner.GmsBarcodeScanner
-import com.google.mlkit.vision.codescanner.GmsBarcodeScannerOptions
-import com.google.mlkit.vision.codescanner.GmsBarcodeScanning
-import com.zaneschepke.wireguardautotunnel.service.barcode.CodeScanner
-import com.zaneschepke.wireguardautotunnel.service.barcode.QRScanner
-import dagger.Binds
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.components.ViewModelComponent
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.android.scopes.ViewModelScoped
-
-@Module
-@InstallIn(ViewModelComponent::class)
-class ScannerModule {
-
-    @ViewModelScoped
-    @Provides
-    fun provideBarCodeOptions() : GmsBarcodeScannerOptions {
-        return GmsBarcodeScannerOptions.Builder()
-            .setBarcodeFormats(Barcode.FORMAT_QR_CODE)
-            .build()
-    }
-
-    @ViewModelScoped
-    @Provides
-    fun provideBarCodeScanner(@ApplicationContext context: Context, options: GmsBarcodeScannerOptions) : GmsBarcodeScanner {
-        return GmsBarcodeScanning.getClient(context, options)
-    }
-
-    @ViewModelScoped
-    @Provides
-    fun provideQRScanner(gmsBarcodeScanner: GmsBarcodeScanner) : CodeScanner {
-        return QRScanner(gmsBarcodeScanner)
-    }
-}

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

@@ -1,7 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.module
 
-import com.zaneschepke.wireguardautotunnel.service.barcode.CodeScanner
-import com.zaneschepke.wireguardautotunnel.service.barcode.QRScanner
+import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
 import com.zaneschepke.wireguardautotunnel.service.network.WifiService
@@ -12,21 +11,23 @@ import dagger.Module
 import dagger.hilt.InstallIn
 import dagger.hilt.android.components.ServiceComponent
 import dagger.hilt.android.scopes.ServiceScoped
-import dagger.hilt.android.scopes.ViewModelScoped
 
 @Module
 @InstallIn(ServiceComponent::class)
 abstract class ServiceModule {
+	@Binds
+	@ServiceScoped
+	abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification): NotificationService
 
-    @Binds
-    @ServiceScoped
-    abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification) : NotificationService
+	@Binds
+	@ServiceScoped
+	abstract fun provideWifiService(wifiService: WifiService): NetworkService<WifiService>
 
-    @Binds
-    @ServiceScoped
-    abstract fun provideWifiService(wifiService: WifiService) : NetworkService<WifiService>
+	@Binds
+	@ServiceScoped
+	abstract fun provideMobileDataService(mobileDataService: MobileDataService): NetworkService<MobileDataService>
 
-    @Binds
-    @ServiceScoped
-    abstract fun provideMobileDataService(mobileDataService : MobileDataService) : NetworkService<MobileDataService>
-}
+	@Binds
+	@ServiceScoped
+	abstract fun provideEthernetService(ethernetService: EthernetService): NetworkService<EthernetService>
+}

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

@@ -3,29 +3,82 @@ package com.zaneschepke.wireguardautotunnel.module
 import android.content.Context
 import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.GoBackend
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
+import com.wireguard.android.backend.RootTunnelActionHandler
+import com.wireguard.android.backend.WgQuickBackend
+import com.wireguard.android.util.RootShell
+import com.wireguard.android.util.ToolsInstaller
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
 import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import javax.inject.Provider
 import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
 class TunnelModule {
+	@Provides
+	@Singleton
+	fun provideRootShell(@ApplicationContext context: Context): RootShell {
+		return RootShell(context)
+	}
 
-    @Provides
-    @Singleton
-    fun provideBackend(@ApplicationContext context : Context) : Backend {
-        return GoBackend(context)
-    }
+	@Provides
+	@Singleton
+	fun provideRootShellAm(@ApplicationContext context: Context): org.amnezia.awg.util.RootShell {
+		return org.amnezia.awg.util.RootShell(context)
+	}
 
-    @Provides
-    @Singleton
-    fun provideVpnService(backend: Backend) : VpnService {
-        return WireGuardTunnel(backend)
-    }
+	@Provides
+	@Singleton
+	@Userspace
+	fun provideUserspaceBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
+		return GoBackend(context, RootTunnelActionHandler(rootShell))
+	}
 
-}
+	@Provides
+	@Singleton
+	@Kernel
+	fun provideKernelBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
+		return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell), RootTunnelActionHandler(rootShell))
+	}
+
+	@Provides
+	@Singleton
+	fun provideAmneziaBackend(@ApplicationContext context: Context, rootShell: org.amnezia.awg.util.RootShell): org.amnezia.awg.backend.Backend {
+		return org.amnezia.awg.backend.GoBackend(context, org.amnezia.awg.backend.RootTunnelActionHandler(rootShell))
+	}
+
+	@Provides
+	@Singleton
+	fun provideVpnService(
+		amneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
+		@Userspace userspaceBackend: Provider<Backend>,
+		@Kernel kernelBackend: Provider<Backend>,
+		appDataRepository: AppDataRepository,
+		@ApplicationScope applicationScope: CoroutineScope,
+		@IoDispatcher ioDispatcher: CoroutineDispatcher,
+	): TunnelService {
+		return WireGuardTunnel(
+			amneziaBackend,
+			userspaceBackend,
+			kernelBackend,
+			appDataRepository,
+			applicationScope,
+			ioDispatcher,
+		)
+	}
+
+	@Provides
+	@Singleton
+	fun provideServiceManager(): ServiceManager {
+		return ServiceManager()
+	}
+}

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

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

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

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

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

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

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

@@ -3,46 +3,46 @@ package com.zaneschepke.wireguardautotunnel.receiver
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.foreground.Action
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceTracker
-import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardConnectivityWatcherService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.startTunnelBackground
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 @AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
 
-    @Inject
-    lateinit var settingsRepo : Repository<Settings>
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
 
-    override fun onReceive(context: Context, intent: Intent) {
-        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
-            CoroutineScope(SupervisorJob()).launch {
-                try {
-                    val settings = settingsRepo.getAll()
-                    if (!settings.isNullOrEmpty()) {
-                        val setting = settings.first()
-                        if (setting.isAutoTunnelEnabled && setting.defaultTunnel != null) {
-                            ServiceTracker.actionOnService(
-                                Action.START, context,
-                                WireGuardConnectivityWatcherService::class.java,
-                                mapOf(context.resources.getString(R.string.tunnel_extras_key) to
-                                setting.defaultTunnel!!)
-                            )
-                        }
-                    }
-                } finally {
-                    cancel()
-                }
-            }
-        }
-    }
-}
+	@Inject
+	lateinit var serviceManager: ServiceManager
+
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	override fun onReceive(context: Context, intent: Intent) {
+		if (Intent.ACTION_BOOT_COMPLETED != intent.action) return
+		applicationScope.launch {
+			val settings = appDataRepository.settings.getSettings()
+			if (settings.isRestoreOnBootEnabled) {
+				appDataRepository.getStartTunnelConfig()?.let {
+					context.startTunnelBackground(it.id)
+				}
+			}
+			if (settings.isAutoTunnelEnabled) {
+				Timber.i("Starting watcher service from boot")
+				serviceManager.startWatcherServiceForeground(context)
+			}
+		}
+	}
+}

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

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

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

@@ -1,56 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.receiver
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.foreground.Action
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceTracker
-import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class NotificationActionReceiver : BroadcastReceiver() {
-
-    @Inject
-    lateinit var settingsRepo : Repository<Settings>
-    override fun onReceive(context: Context, intent: Intent?) {
-        CoroutineScope(SupervisorJob()).launch {
-            try {
-                val settings = settingsRepo.getAll()
-                if (!settings.isNullOrEmpty()) {
-                    val setting = settings.first()
-                    if (setting.defaultTunnel != null) {
-                        ServiceTracker.actionOnService(
-                            Action.STOP, context,
-                            WireGuardTunnelService::class.java,
-                            mapOf(
-                                context.resources.getString(R.string.tunnel_extras_key) to
-                                        setting.defaultTunnel!!
-                            )
-                        )
-                        delay(1000)
-                        ServiceTracker.actionOnService(
-                            Action.START, context,
-                            WireGuardTunnelService::class.java,
-                            mapOf(
-                                context.resources.getString(R.string.tunnel_extras_key) to
-                                        setting.defaultTunnel!!
-                            )
-                        )
-                    }
-                }
-            } finally {
-                cancel()
-            }
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/repository/Repository.kt

@@ -1,16 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.repository
-
-import kotlinx.coroutines.flow.Flow
-
-interface Repository<T> {
-    suspend fun save(t : T)
-    suspend fun saveAll(t : List<T>)
-    suspend fun getById(id : Long) : T?
-    suspend fun getAll() : List<T>?
-    suspend fun delete(t : T) : Boolean?
-    suspend fun count() : Long?
-
-    val itemFlow : Flow<MutableList<T>>
-
-    fun init()
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/repository/SettingsBox.kt

@@ -1,63 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.repository
-
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import io.objectbox.kotlin.awaitCallInTx
-import io.objectbox.kotlin.toFlow
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-
-class SettingsBox @Inject constructor(private val box : Box<Settings>, private val boxStore : BoxStore) : Repository<Settings> {
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    override val itemFlow = box.query().build().subscribe().toFlow()
-
-    override fun init() {
-        CoroutineScope(Dispatchers.IO).launch {
-            if(getAll().isNullOrEmpty()) {
-                save(Settings())
-            }
-        }
-    }
-
-    override suspend fun save(t : Settings) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun saveAll(t : List<Settings>) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun getById(id: Long): Settings? {
-        return boxStore.awaitCallInTx {
-            box[id]
-        }
-    }
-
-    override suspend fun getAll(): List<Settings>? {
-        return boxStore.awaitCallInTx {
-            box.all
-        }
-    }
-
-    override suspend fun delete(t : Settings): Boolean? {
-        return boxStore.awaitCallInTx {
-            box.remove(t)
-        }
-    }
-
-    override suspend fun count() : Long? {
-        return boxStore.awaitCallInTx {
-            box.count()
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/repository/TunnelBox.kt

@@ -1,57 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.repository
-
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import io.objectbox.Box
-import io.objectbox.BoxStore
-import io.objectbox.kotlin.awaitCallInTx
-import io.objectbox.kotlin.toFlow
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import timber.log.Timber
-import javax.inject.Inject
-
-class TunnelBox @Inject constructor(private val box : Box<TunnelConfig>,private val boxStore : BoxStore) : Repository<TunnelConfig> {
-
-    @OptIn(ExperimentalCoroutinesApi::class)
-    override val itemFlow = box.query().build().subscribe().toFlow()
-    override fun init() {
-
-    }
-
-    override suspend fun save(t : TunnelConfig) {
-        Timber.d("Saving tunnel config")
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-
-    }
-
-    override suspend fun saveAll(t : List<TunnelConfig>) {
-        boxStore.awaitCallInTx {
-            box.put(t)
-        }
-    }
-
-    override suspend fun getById(id: Long): TunnelConfig? {
-       return boxStore.awaitCallInTx {
-            box[id]
-        }
-    }
-
-    override suspend fun getAll(): List<TunnelConfig>? {
-        return boxStore.awaitCallInTx {
-            box.all
-        }
-    }
-
-    override suspend fun delete(t : TunnelConfig): Boolean? {
-        return boxStore.awaitCallInTx {
-            box.remove(t)
-        }
-    }
-
-    override suspend fun count() : Long? {
-        return boxStore.awaitCallInTx {
-            box.count()
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/barcode/CodeScanner.kt

@@ -1,7 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.barcode
-
-import kotlinx.coroutines.flow.Flow
-
-interface CodeScanner {
-    fun scan() : Flow<String?>
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/barcode/QRScanner.kt

@@ -1,23 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.barcode
-
-import com.google.mlkit.vision.codescanner.GmsBarcodeScanner
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import timber.log.Timber
-import javax.inject.Inject
-
-class QRScanner @Inject constructor(private val gmsBarcodeScanner: GmsBarcodeScanner) : CodeScanner {
-    override fun scan(): Flow<String?> {
-        return callbackFlow {
-            gmsBarcodeScanner.startScan().addOnSuccessListener {
-                trySend(it.rawValue)
-            }.addOnFailureListener {
-                trySend(it.message)
-                Timber.e(it.message)
-            }
-            awaitClose {
-            }
-        }
-    }
-}

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

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

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

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

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

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

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

@@ -1,60 +1,57 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground
 
-import android.app.Service
 import android.content.Intent
 import android.os.Bundle
 import android.os.IBinder
+import androidx.lifecycle.LifecycleService
+import com.zaneschepke.wireguardautotunnel.util.Constants
 import timber.log.Timber
 
+open class ForegroundService : LifecycleService() {
+	private var isServiceStarted = false
 
-open class ForegroundService : Service() {
+	override fun onBind(intent: Intent): IBinder? {
+		super.onBind(intent)
+		// We don't provide binding, so return null
+		return null
+	}
 
-    private var isServiceStarted = false
+	override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+		super.onStartCommand(intent, flags, startId)
+		Timber.d("onStartCommand executed with startId: $startId")
+		if (intent != null) {
+			val action = intent.action
+			when (action) {
+				Action.START.name,
+				Action.START_FOREGROUND.name,
+				-> startService(intent.extras)
 
-    override fun onBind(intent: Intent): IBinder? {
-        // We don't provide binding, so return null
-        return null
-    }
+				Action.STOP.name, Action.STOP_FOREGROUND.name -> stopService()
+				Constants.ALWAYS_ON_VPN_ACTION -> {
+					Timber.i("Always-on VPN starting service")
+					startService(intent.extras)
+				}
 
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        Timber.d("onStartCommand executed with startId: $startId")
-        if (intent != null) {
-            val action = intent.action
-            Timber.d("using an intent with action $action")
-            when (action) {
-                Action.START.name -> startService(intent.extras)
-                Action.STOP.name -> stopService(intent.extras)
-                else -> Timber.d("This should never happen. No action in the received intent")
-            }
-        } else {
-            Timber.d(
-                "with a null intent. It has been probably restarted by the system."
-            )
-        }
-        // by returning this we make sure the service is restarted if the system kills the service
-        return START_STICKY
-    }
+				else -> Timber.d("This should never happen. No action in the received intent")
+			}
+		} else {
+			Timber.d(
+				"with a null intent. It has been probably restarted by the system.",
+			)
+		}
+		return START_STICKY
+	}
 
+	protected open fun startService(extras: Bundle?) {
+		if (isServiceStarted) return
+		Timber.d("Starting ${this.javaClass.simpleName}")
+		isServiceStarted = true
+	}
 
-    override fun onDestroy() {
-        super.onDestroy()
-        Timber.d("The service has been destroyed")
-    }
-
-    protected open fun startService(extras : Bundle?) {
-        if (isServiceStarted) return
-        Timber.d("Starting ${this.javaClass.simpleName}")
-        isServiceStarted = true
-    }
-
-    protected open fun stopService(extras : Bundle?) {
-        Timber.d("Stopping ${this.javaClass.simpleName}")
-        try {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-            stopSelf()
-        } catch (e: Exception) {
-            Timber.d("Service stopped without being started: ${e.message}")
-        }
-        isServiceStarted = false
-    }
-}
+	protected open fun stopService() {
+		Timber.d("Stopping ${this.javaClass.simpleName}")
+		stopForeground(STOP_FOREGROUND_REMOVE)
+		stopSelf()
+		isServiceStarted = false
+	}
+}

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

@@ -0,0 +1,69 @@
+package com.zaneschepke.wireguardautotunnel.service.foreground
+
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import timber.log.Timber
+
+class ServiceManager {
+	private fun <T : Service> actionOnService(action: Action, context: Context, cls: Class<T>, extras: Map<String, Int>? = null) {
+		val intent =
+			Intent(context, cls).also {
+				it.action = action.name
+				extras?.forEach { (k, v) -> it.putExtra(k, v) }
+			}
+		intent.component?.javaClass
+		try {
+			when (action) {
+				Action.START_FOREGROUND, Action.STOP_FOREGROUND ->
+					context.startForegroundService(
+						intent,
+					)
+
+				Action.START, Action.STOP -> context.startService(intent)
+			}
+		} catch (e: Exception) {
+			Timber.e(e.message)
+		}
+	}
+
+	fun startWatcherServiceForeground(context: Context) {
+		actionOnService(
+			Action.START_FOREGROUND,
+			context,
+			AutoTunnelService::class.java,
+		)
+	}
+
+	fun startWatcherService(context: Context) {
+		actionOnService(
+			Action.START,
+			context,
+			AutoTunnelService::class.java,
+		)
+	}
+
+	fun stopWatcherService(context: Context) {
+		actionOnService(
+			Action.STOP,
+			context,
+			AutoTunnelService::class.java,
+		)
+	}
+
+	fun startTunnelBackgroundService(context: Context) {
+		actionOnService(
+			Action.START_FOREGROUND,
+			context,
+			TunnelBackgroundService::class.java,
+		)
+	}
+
+	fun stopTunnelBackgroundService(context: Context) {
+		actionOnService(
+			Action.STOP,
+			context,
+			TunnelBackgroundService::class.java,
+		)
+	}
+}

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

@@ -1,6 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-enum class ServiceState {
-    STARTED,
-    STOPPED,
-}

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

@@ -1,56 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import android.app.ActivityManager
-import android.app.Application
-import android.app.Service
-import android.content.Context
-import android.content.Context.ACTIVITY_SERVICE
-import android.content.Intent
-import com.google.firebase.crashlytics.ktx.crashlytics
-import com.google.firebase.ktx.Firebase
-
-object ServiceTracker {
-    @Suppress("DEPRECATION")
-    private // Deprecated for third party Services.
-    fun <T> Context.isServiceRunning(service: Class<T>) =
-        (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
-            .getRunningServices(Integer.MAX_VALUE)
-            .any { it.service.className == service.name }
-
-    fun <T : Service> getServiceState(context: Context, cls : Class<T>): ServiceState {
-        val isServiceRunning = context.isServiceRunning(cls)
-        return if(isServiceRunning) ServiceState.STARTED else ServiceState.STOPPED
-    }
-
-    fun <T : Service> actionOnService(action: Action, application: Application, cls : Class<T>, extras : Map<String,String>? = null) {
-        if (getServiceState(application, cls) == ServiceState.STOPPED && action == Action.STOP) return
-        val intent = Intent(application, cls).also {
-            it.action = action.name
-            extras?.forEach {(k, v) ->
-                it.putExtra(k, v)
-            }
-        }
-        intent.component?.javaClass
-        try {
-            application.startService(intent)
-        } catch (e : Exception) {
-            e.message?.let { Firebase.crashlytics.log(it) }
-        }
-    }
-
-    fun <T : Service> actionOnService(action: Action, context: Context, cls : Class<T>, extras : Map<String,String>? = null) {
-        if (getServiceState(context, cls) == ServiceState.STOPPED && action == Action.STOP) return
-        val intent = Intent(context, cls).also {
-            it.action = action.name
-            extras?.forEach {(k, v) ->
-                it.putExtra(k, v)
-            }
-        }
-        intent.component?.javaClass
-        try {
-            context.startService(intent)
-        } catch (e : Exception) {
-            e.message?.let { Firebase.crashlytics.log(it) }
-        }
-    }
-}

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

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

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

@@ -1,236 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import android.app.AlarmManager
-import android.app.Application
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.os.Bundle
-import android.os.PowerManager
-import android.os.SystemClock
-import com.wireguard.android.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.repository.Repository
-import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
-import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
-import com.zaneschepke.wireguardautotunnel.service.network.NetworkStatus
-import com.zaneschepke.wireguardautotunnel.service.network.WifiService
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.Settings
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class WireGuardConnectivityWatcherService : ForegroundService() {
-
-    private val foregroundId = 122;
-
-    @Inject
-    lateinit var wifiService : NetworkService<WifiService>
-
-    @Inject
-    lateinit var mobileDataService : NetworkService<MobileDataService>
-
-    @Inject
-    lateinit var settingsRepo: Repository<Settings>
-
-    @Inject
-    lateinit var notificationService : NotificationService
-
-    @Inject
-    lateinit var vpnService : VpnService
-
-    private lateinit var watcherJob : Job;
-    private lateinit var setting : Settings
-    private lateinit var tunnelId: String
-
-    private var connecting = false
-    private var disconnecting = false
-    private var isWifiConnected = false
-    private var isMobileDataConnected = false
-
-    private var wakeLock: PowerManager.WakeLock? = null
-    private val tag = this.javaClass.name;
-
-
-    override fun startService(extras: Bundle?) {
-        super.startService(extras)
-        val tunnelId = extras?.getString(getString(R.string.tunnel_extras_key))
-        if (tunnelId != null) {
-            this.tunnelId = tunnelId
-        }
-        // we need this lock so our service gets not affected by Doze Mode
-        initWakeLock()
-        cancelWatcherJob()
-        launchWatcherNotification()
-        if(this::tunnelId.isInitialized) {
-            startWatcherJob()
-        } else {
-            stopService(extras)
-        }
-    }
-
-    override fun stopService(extras: Bundle?) {
-        super.stopService(extras)
-        wakeLock?.let {
-            if (it.isHeld) {
-                it.release()
-            }
-        }
-        cancelWatcherJob()
-        stopVPN()
-        stopSelf()
-    }
-
-    private fun launchWatcherNotification() {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.watcher_channel_id),
-            channelName = getString(R.string.watcher_channel_name),
-            description = getString(R.string.watcher_notification_text))
-        super.startForeground(foregroundId, notification)
-    }
-
-    //try to start task again if killed
-    override fun onTaskRemoved(rootIntent: Intent) {
-        Timber.d("Task Removed called")
-        val restartServiceIntent = Intent(rootIntent)
-        val restartServicePendingIntent: PendingIntent = PendingIntent.getService(this, 1, restartServiceIntent,
-            PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE);
-        applicationContext.getSystemService(Context.ALARM_SERVICE);
-        val alarmService: AlarmManager = applicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager;
-        alarmService.set(AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime() + 1000, restartServicePendingIntent);
-    }
-
-    private fun initWakeLock() {
-        wakeLock =
-            (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
-                newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
-                    acquire()
-                }
-            }
-    }
-
-    private fun cancelWatcherJob() {
-        if(this::watcherJob.isInitialized) {
-            watcherJob.cancel()
-        }
-    }
-
-    private fun startWatcherJob() {
-        watcherJob = CoroutineScope(SupervisorJob()).launch {
-            val settings = settingsRepo.getAll();
-            if(!settings.isNullOrEmpty()) {
-                setting = settings[0]
-            }
-            CoroutineScope(watcherJob).launch {
-                watchForWifiConnectivityChanges()
-            }
-            if(setting.isTunnelOnMobileDataEnabled) {
-                CoroutineScope(watcherJob).launch {
-                    watchForMobileDataConnectivityChanges()
-                }
-            }
-        }
-    }
-
-    private suspend fun watchForMobileDataConnectivityChanges() {
-        mobileDataService.networkStatus.collect {
-            when(it) {
-                is NetworkStatus.Available -> {
-                    Timber.d("Gained Mobile data connection")
-                    isMobileDataConnected = true
-                }
-                is NetworkStatus.CapabilitiesChanged -> {
-                    isMobileDataConnected = true
-                    Timber.d("Mobile data capabilities changed")
-                    if(!disconnecting && !connecting) {
-                        if(!isWifiConnected && setting.isTunnelOnMobileDataEnabled
-                            && vpnService.getState() == Tunnel.State.DOWN)
-                            startVPN()
-                    }
-                }
-                is NetworkStatus.Unavailable -> {
-                    isMobileDataConnected = false
-                    if(!disconnecting && !connecting) {
-                        if(!isWifiConnected && vpnService.getState() == Tunnel.State.UP) stopVPN()
-                    }
-                    Timber.d("Lost mobile data connection")
-                }
-            }
-        }
-    }
-
-    private suspend fun watchForWifiConnectivityChanges() {
-        wifiService.networkStatus.collect {
-                when (it) {
-                    is NetworkStatus.Available -> {
-                        Timber.d("Gained Wi-Fi connection")
-                        isWifiConnected = true
-                    }
-                    is NetworkStatus.CapabilitiesChanged -> {
-                        Timber.d("Wifi capabilities changed")
-                        isWifiConnected = true
-                        if (!connecting && !disconnecting) {
-                            Timber.d("Not connect and not disconnecting")
-                            val ssid = wifiService.getNetworkName(it.networkCapabilities);
-                            Timber.d("SSID: $ssid")
-                            if (!setting.trustedNetworkSSIDs.contains(ssid) && vpnService.getState() == Tunnel.State.DOWN) {
-                                Timber.d("Starting VPN Tunnel for untrusted network: $ssid")
-                                startVPN()
-                            } else if (!disconnecting && vpnService.getState() == Tunnel.State.UP && setting.trustedNetworkSSIDs.contains(
-                                    ssid
-                                )
-                            ) {
-                                Timber.d("Stopping VPN Tunnel for trusted network with ssid: $ssid")
-                                stopVPN()
-                            }
-                        }
-                    }
-                    is NetworkStatus.Unavailable -> {
-                        isWifiConnected = false
-                        Timber.d("Lost Wi-Fi connection")
-                        if(!connecting || !disconnecting) {
-                            if(setting.isTunnelOnMobileDataEnabled && vpnService.getState() == Tunnel.State.DOWN
-                                && isMobileDataConnected){
-                                Timber.d("Wifi not available so starting vpn for mobile data")
-                                startVPN()
-                            }
-                            if(!setting.isTunnelOnMobileDataEnabled && vpnService.getState() == Tunnel.State.UP) {
-                                Timber.d("Lost WiFi connection, disabling vpn")
-                                stopVPN()
-                            }
-                        }
-
-                    }
-                }
-            }
-        }
-    private fun startVPN() {
-        if(!connecting) {
-            connecting = true
-            ServiceTracker.actionOnService(
-                Action.START,
-                this.applicationContext as Application,
-                WireGuardTunnelService::class.java,
-                mapOf(getString(R.string.tunnel_extras_key) to tunnelId))
-            connecting = false
-        }
-    }
-    private fun stopVPN() {
-        if(!disconnecting) {
-            disconnecting = true
-            ServiceTracker.actionOnService(
-                Action.STOP,
-                this.applicationContext as Application,
-                WireGuardTunnelService::class.java
-            )
-            disconnecting = false
-        }
-    }
-}

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

@@ -1,125 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-import android.app.PendingIntent
-import android.content.Intent
-import android.os.Bundle
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
-import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
-import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import timber.log.Timber
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class WireGuardTunnelService : ForegroundService() {
-
-    private val foregroundId = 123;
-
-    @Inject
-    lateinit var vpnService : VpnService
-
-    @Inject
-    lateinit var notificationService : NotificationService
-
-    private lateinit var job : Job
-
-    private var tunnelName : String = ""
-
-    override fun startService(extras : Bundle?) {
-        super.startService(extras)
-        val tunnelConfigString = extras?.getString(getString(R.string.tunnel_extras_key))
-        cancelJob()
-        job = CoroutineScope(SupervisorJob()).launch {
-            if(tunnelConfigString != null) {
-                try {
-                    val tunnelConfig = TunnelConfig.from(tunnelConfigString)
-                    tunnelName = tunnelConfig.name
-                    vpnService.startTunnel(tunnelConfig)
-                } catch (e : Exception) {
-                    Timber.e("Problem starting tunnel: ${e.message}")
-                    stopService(extras)
-                }
-            } else {
-                Timber.e("Tunnel config null")
-            }
-        }
-        CoroutineScope(job).launch {
-            var didShowConnected = false
-            var didShowFailedHandshakeNotification = false
-            vpnService.handshakeStatus.collect {
-                when(it) {
-                    HandshakeStatus.NOT_STARTED -> {
-                    }
-                    HandshakeStatus.NEVER_CONNECTED -> {
-                        if(!didShowFailedHandshakeNotification) {
-                            launchVpnConnectionFailedNotification(getString(R.string.initial_connection_failure_message))
-                            didShowFailedHandshakeNotification = true
-                        }
-                    }
-                    HandshakeStatus.HEALTHY -> {
-                        if(!didShowConnected) {
-                            launchVpnConnectedNotification()
-                            didShowConnected = true
-                        }
-                    }
-                    HandshakeStatus.UNHEALTHY -> {
-                        if(!didShowFailedHandshakeNotification) {
-                            launchVpnConnectionFailedNotification(getString(R.string.lost_connection_failure_message))
-                            didShowFailedHandshakeNotification = true
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    override fun stopService(extras : Bundle?) {
-        super.stopService(extras)
-        CoroutineScope(Dispatchers.IO).launch() {
-            vpnService.stopTunnel()
-        }
-        cancelJob()
-        stopSelf()
-    }
-
-    private fun launchVpnConnectedNotification() {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.vpn_channel_id),
-            channelName = getString(R.string.vpn_channel_name),
-            title = getString(R.string.tunnel_start_title),
-            onGoing = false,
-            showTimestamp = true,
-            description = "${getString(R.string.tunnel_start_text)} $tunnelName"
-        )
-        super.startForeground(foregroundId, notification)
-    }
-
-    private fun launchVpnConnectionFailedNotification(message : String) {
-        val notification = notificationService.createNotification(
-            channelId = getString(R.string.vpn_channel_id),
-            channelName = getString(R.string.vpn_channel_name),
-            action = PendingIntent.getBroadcast(this,0,Intent(this, NotificationActionReceiver::class.java),PendingIntent.FLAG_IMMUTABLE),
-            actionText = getString(R.string.restart),
-            title = getString(R.string.vpn_connection_failed),
-            onGoing = false,
-            showTimestamp = true,
-            description = message
-        )
-        super.startForeground(foregroundId, notification)
-    }
-
-
-    private fun cancelJob() {
-        if(this::job.isInitialized) {
-            job.cancel()
-        }
-    }
-}

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

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

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

@@ -0,0 +1,13 @@
+package com.zaneschepke.wireguardautotunnel.service.network
+
+import android.content.Context
+import android.net.NetworkCapabilities
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+
+class EthernetService
+@Inject
+constructor(
+	@ApplicationContext context: Context,
+) :
+	BaseNetworkService<EthernetService>(context, NetworkCapabilities.TRANSPORT_ETHERNET)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,129 @@
+package com.zaneschepke.wireguardautotunnel.service.tile
+
+import android.os.Build
+import android.service.quicksettings.Tile
+import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleRegistry
+import androidx.lifecycle.lifecycleScope
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelService
+import com.zaneschepke.wireguardautotunnel.util.extensions.startTunnelBackground
+import com.zaneschepke.wireguardautotunnel.util.extensions.stopTunnelBackground
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+import javax.inject.Provider
+
+@AndroidEntryPoint
+class TunnelControlTile : TileService(), LifecycleOwner {
+	@Inject
+	lateinit var appDataRepository: AppDataRepository
+
+	@Inject
+	lateinit var tunnelService: Provider<TunnelService>
+
+	@Inject
+	@ApplicationScope
+	lateinit var applicationScope: CoroutineScope
+
+	private val lifecycleRegistry: LifecycleRegistry = LifecycleRegistry(this)
+
+	override fun onCreate() {
+		super.onCreate()
+		Timber.d("onCreate for tile service")
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE)
+	}
+
+	override fun onStopListening() {
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP)
+	}
+
+	override fun onDestroy() {
+		super.onDestroy()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+	}
+
+	override fun onStartListening() {
+		super.onStartListening()
+		lifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START)
+		lifecycleScope.launch {
+			if (appDataRepository.tunnels.getAll().isEmpty()) return@launch setUnavailable()
+			updateTileState()
+		}
+	}
+
+	private suspend fun updateTileState() {
+		val lastActive = appDataRepository.getStartTunnelConfig()
+		lastActive?.let {
+			updateTile(it)
+		}
+	}
+
+	override fun onClick() {
+		super.onClick()
+		unlockAndRun {
+			Timber.d("Click")
+			lifecycleScope.launch {
+				val context = this@TunnelControlTile
+				val lastActive = appDataRepository.getStartTunnelConfig()
+				lastActive?.let { tunnel ->
+					if (tunnel.isActive) return@launch context.stopTunnelBackground(tunnel.id)
+					context.startTunnelBackground(tunnel.id)
+				}
+			}
+		}
+	}
+
+	private fun setActive() {
+		kotlin.runCatching {
+			qsTile.state = Tile.STATE_ACTIVE
+			qsTile.updateTile()
+		}
+	}
+
+	private fun setInactive() {
+		kotlin.runCatching {
+			qsTile.state = Tile.STATE_INACTIVE
+			qsTile.updateTile()
+		}
+	}
+
+	private fun setUnavailable() {
+		kotlin.runCatching {
+			qsTile.state = Tile.STATE_UNAVAILABLE
+			setTileDescription("")
+			qsTile.updateTile()
+		}
+	}
+
+	private fun setTileDescription(description: String) {
+		kotlin.runCatching {
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+				qsTile.subtitle = description
+			}
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+				qsTile.stateDescription = description
+			}
+			qsTile.updateTile()
+		}
+	}
+
+	private fun updateTile(tunnelConfig: TunnelConfig?) {
+		kotlin.runCatching {
+			tunnelConfig?.let {
+				setTileDescription(it.name)
+				if (it.isActive) return setActive()
+				setInactive()
+			}
+		}
+	}
+
+	override val lifecycle: Lifecycle
+		get() = lifecycleRegistry
+}

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

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

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

@@ -1,14 +1,17 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel
 
 enum class HandshakeStatus {
-    HEALTHY,
-    UNHEALTHY,
-    NEVER_CONNECTED,
-    NOT_STARTED;
+	HEALTHY,
+	STALE,
+	UNKNOWN,
+	NOT_STARTED,
+	;
 
-    companion object {
-        private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 120
-        const val UNHEALTHY_TIME_LIMIT_SEC = WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + 60
-        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/service/tunnel/TunnelService.kt

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

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

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

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

@@ -1,18 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.tunnel
-
-import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Tunnel
-import com.wireguard.crypto.Key
-import com.zaneschepke.wireguardautotunnel.service.tunnel.model.TunnelConfig
-import kotlinx.coroutines.flow.SharedFlow
-
-interface VpnService : Tunnel {
-    suspend fun startTunnel(tunnelConfig : TunnelConfig) : Tunnel.State
-    suspend fun stopTunnel()
-    val state : SharedFlow<Tunnel.State>
-    val tunnelName : SharedFlow<String>
-    val statistics : SharedFlow<Statistics>
-    val lastHandshake : SharedFlow<Map<Key,Long>>
-    val handshakeStatus : SharedFlow<HandshakeStatus>
-    fun getState() : Tunnel.State
-}