update gradle checksum

Fixes a bug where mobile data tunneling was not working properly in certain scenarios.

Fixes an issue where the new floating action button was not working correctly on AndroidTV.

Improved local logging.

Additional refactors and optimizations.

.editorconfig

@@ -0,0 +1,85 @@
+[{*.kt,*.kts}]
+indent_style = space
+insert_final_newline = true
+max_line_length = 100
+indent_size = 4
+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_allow_trailing_comma = true
+ij_kotlin_allow_trailing_comma_on_call_site = true
+ij_kotlin_assignment_wrap = normal
+ij_kotlin_blank_lines_after_class_header = 0
+ij_kotlin_blank_lines_around_block_when_branches = 0
+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_call_parameters_wrap = on_every_item
+ij_kotlin_catch_on_new_line = false
+ij_kotlin_class_annotation_wrap = split_into_lines
+ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
+ij_kotlin_continuation_indent_for_chained_calls = true
+ij_kotlin_continuation_indent_for_expression_bodies = true
+ij_kotlin_continuation_indent_in_argument_lists = true
+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_method_parameters_wrap = on_every_item
+ij_kotlin_name_count_to_use_star_import = 9999
+ij_kotlin_name_count_to_use_star_import_for_members = 9999
+ij_kotlin_parameter_annotation_wrap = off
+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

.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

@@ -11,12 +11,14 @@ assignees: zaneschepke
 A clear and concise description of what the bug is.
 
 **Smartphone (please complete the following information):**
- - Device: [e.g. iPhone6]
- - Android Version: [e.g. iOS8.1]
- - App Version [e.g. 22]
+
+- 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 '....'

.github/SUPPORT.md

@@ -1,6 +1,6 @@
 # Support
 
-If you are experiencing issues with the app, the following resources are available to help you. 
+If you are experiencing issues with the app, the following resources are available to help you.
 
 <ol>
   <li>

.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/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/pre-release.yml

@@ -1,27 +1,30 @@
-# name of the workflow
-name: Android CI Tag Deployment
+name: Android CI Tag Deployment (Pre-release)
 
 on:
+  workflow_dispatch:
   push:
     tags:
-      - '*.*.*'
+      - '*.*.*-**'
 
 jobs:
   build:
     name: Build Signed APK
-    # change to macos because of hilt issues on ubuntu in gradle 8.3
+
     runs-on: ubuntu-latest
 
     env:
-      KEY_STORE_PATH: ${{ secrets.KEY_STORE_PATH }}
       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@v3
+      - uses: actions/checkout@v4
       - name: Set up JDK 17
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -35,10 +38,16 @@ jobs:
         id: decode_keystore
         uses: timheuer/base64-to-file@v1.2
         with:
-          fileName: 'android_keystore.jks'
-          fileDir: ${{ github.workspace }}/app/keystore/
+          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
@@ -52,36 +61,64 @@ jobs:
       - name: Get apk path
         id: apk-path
         run: echo "path=$(find . -regex '^.*/build/outputs/apk/fdroid/release/.*\.apk$' -type f | head -1)" >> $GITHUB_OUTPUT
-
+      - name: Get version code
+        run: |
+          version_code=$(grep "VERSION_CODE" buildSrc/src/main/kotlin/Constants.kt | awk '{print $5}' | tr -d '\n')
+          echo "VERSION_CODE=$version_code" >> $GITHUB_ENV
       # Save the APK after the Build job is complete to publish it as a Github release in the next job
       - name: Upload APK
-        uses: actions/upload-artifact@v3.1.2
+        uses: actions/upload-artifact@v4.3.3
         with:
           name: wgtunnel
           path: ${{ steps.apk-path.outputs.path }}
       - name: Download APK from build
-        uses: actions/download-artifact@v1
+        uses: actions/download-artifact@v4
         with:
           name: wgtunnel
       - name: Create Release with Fastlane changelog notes
         id: create_release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           # fix hardcode changelog file name
-          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/33100.txt
+          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt
           tag_name: ${{ github.ref_name }}
-          name: Release ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
           draft: false
-          prerelease: false
+          prerelease: true
           files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
+
+      - name: Install apksigner
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y apksigner
+
+      - name: Get checksum
+        id: checksum
+        run: echo "checksum=$(apksigner verify -print-certs ${{ steps.apk-path.outputs.path }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
+
+      - name: Append checksum
+        id: append_checksum
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          body: |
+            
+            SHA256 fingerprint:
+            ```${{ steps.checksum.outputs.checksum }}```
+          tag_name: ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
+          draft: false
+          prerelease: true
+          append_body: true
+
       - name: Deploy with fastlane
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: '3.2' # Not needed with a .ruby-version file
           bundler-cache: true
-
       - name: Distribute app to Beta track 🚀
         run: (cd ${{ github.workspace }} && bundle install && bundle exec fastlane beta)
 

.github/workflows/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,131 @@
+# name of the workflow
+name: Android CI Tag Deployment (Release)
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - '*.*.*'
+      - '!*.*.*-**'
+
+jobs:
+  build:
+    name: Build Signed APK
+
+    runs-on: ubuntu-latest
+
+    env:
+      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
+      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
+      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
+      KEY_STORE_FILE: 'android_keystore.jks'
+      KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
+      GH_USER: ${{ secrets.GH_USER }}
+      GH_TOKEN: ${{ secrets.GH_TOKEN }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: gradle
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      # Here we need to decode keystore.jks from base64 string and place it
+      # in the folder specified in the release signing configuration
+      - name: Decode Keystore
+        id: decode_keystore
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: ${{ env.KEY_STORE_FILE }}
+          fileDir: ${{ env.KEY_STORE_LOCATION }}
+          encodedString: ${{ secrets.KEYSTORE }}
+
+      # create keystore path for gradle to read
+      - name: Create keystore path env var
+        run: |
+          store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
+          echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
+
+      - name: Create service_account.json
+        id: createServiceAccount
+        run: echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
+
+      # Build and sign APK ("-x test" argument is used to skip tests)
+      # add fdroid flavor for apk upload
+      - name: Build Fdroid Release APK
+        run: ./gradlew :app:assembleFdroidRelease -x test
+
+      # get fdroid flavor release apk path
+      - name: Get apk path
+        id: apk-path
+        run: echo "path=$(find . -regex '^.*/build/outputs/apk/fdroid/release/.*\.apk$' -type f | head -1)" >> $GITHUB_OUTPUT
+      - name: Get version code
+        run: |
+          version_code=$(grep "VERSION_CODE" buildSrc/src/main/kotlin/Constants.kt | awk '{print $5}' | tr -d '\n')
+          echo "VERSION_CODE=$version_code" >> $GITHUB_ENV
+      # Save the APK after the Build job is complete to publish it as a Github release in the next job
+      - name: Upload APK
+        uses: actions/upload-artifact@v4.3.3
+        with:
+          name: wgtunnel
+          path: ${{ steps.apk-path.outputs.path }}
+      - name: Download APK from build
+        uses: actions/download-artifact@v4
+        with:
+          name: wgtunnel
+      - name: Repository Dispatch for my F-Droid repo
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.PAT }}
+          repository: zaneschepke/fdroid
+          event-type: fdroid-update
+      - name: Create Release with Fastlane changelog notes
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt
+          tag_name: ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
+          draft: false
+          prerelease: false
+          files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
+
+      - name: Install apksigner
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y apksigner
+
+      - name: Get checksum
+        id: checksum
+        run: echo "checksum=$(apksigner verify -print-certs ${{ steps.apk-path.outputs.path }} | grep -Po "(?<=SHA-256 digest:) .*" | tr -d "[:blank:]")" >> $GITHUB_OUTPUT
+
+      - name: Append checksum
+        id: append_checksum
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          body: |
+            
+            SHA256 fingerprint:
+            ```${{ steps.checksum.outputs.checksum }}```
+          tag_name: ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
+          draft: false
+          prerelease: false
+          append_body: true
+
+      - name: Deploy with fastlane
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.2' # Not needed with a .ruby-version file
+          bundler-cache: true
+      - name: Distribute app to Prod track 🚀
+        run: (cd ${{ github.workspace }} && bundle install && bundle exec fastlane production)
+

README.md

@@ -4,8 +4,9 @@ WG Tunnel
 
 <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)
 
 </div>
 
@@ -13,22 +14,19 @@ WG Tunnel
 
 
 [![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)
-[![Fire TV](https://img.shields.io/badge/fire%20tv-fc3b2d?style=for-the-badge&logo=amazon%20fire%20tv&logoColor=white)](https://www.amazon.com/gp/product/B0CFGGL7WK)
 [![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/)
 
 
-</div>
-
-<div align="center">
-
-[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/N4N8NMJN2)
-
 </div>
 
 
 <div align="left">
 
-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.
+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>
 
@@ -37,38 +35,70 @@ This is an alternative Android Application for [WireGuard](https://www.wireguard
 ## 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>
 
 <div align="left">
 
 ## Inspiration
 
-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. 
+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, zip, manual entry, or QR code
-* Auto connect to VPN based on Wi-Fi SSID
+* Auto connect to tunnels based on Wi-Fi SSID, ethernet, or mobile data
 * Split tunneling by application with search
-* Always-on VPN for Android support
-* Export tunnels to zip
-* Quick tile support for VPN toggling
-* Static shortcuts support for primary tunnel for automation integration
+* WireGuard support for kernel and userspace modes
+* Amnezia support for userspace mode for DPI/censorship protection
+* 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
-* Optional auto connect on mobile data, ethernet
-* Automatic service restart after reboot
-* Service will stay running in background after app has been closed
+* Automatic auto-tunneling service restart after reboot
+* Automatic tunnel restart after reboot
+* Battery preservation measures
+* Restart tunnel on ping failure (beta)
 
+## Docs
+
+Basic documentation of the feature and behaviors of this app can be
+found [here](https://zaneschepke.com/wgtunnel-docs/overview.html).
+
+The repository for these docs can be found [here](https://github.com/zaneschepke/wgtunnel-docs).
+
+## Contributing
+
+Any contributions in the form of feedback, issues, code, or translations are welcome and much
+appreciated!
+
+Please read
+the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct)
+before contributing.
+
+## Translation
+
+This app is using [Weblate](https://weblate.org) to assist with translations.
+
+Help translate WG Tunnel into your language
+at [Hosted Weblate](https://hosted.weblate.org/engage/wg-tunnel/).\
+[![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
+```
+
+And then build the app:
+
+```
 $ ./gradlew assembleDebug
 ```
 

SECURITY.md

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

app/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.hilt.android)
-    id("org.jetbrains.kotlin.plugin.serialization")
+    alias(libs.plugins.kotlinxSerialization)
     alias(libs.plugins.ksp)
 }
 
@@ -12,6 +12,10 @@ android {
     namespace = Constants.APP_ID
     compileSdk = Constants.TARGET_SDK
 
+    androidResources {
+        generateLocaleConfig = true
+    }
+
     defaultConfig {
         applicationId = Constants.APP_ID
         minSdk = Constants.MIN_SDK
@@ -19,20 +23,14 @@ android {
         versionCode = Constants.VERSION_CODE
         versionName = Constants.VERSION_NAME
 
-        ksp {
-            arg("room.schemaLocation", "$projectDir/schemas")
-        }
+        ksp { arg("room.schemaLocation", "$projectDir/schemas") }
 
         sourceSets {
             getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
         }
 
-        resourceConfigurations.addAll(listOf("en"))
-
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        vectorDrawables {
-            useSupportLibrary = true
-        }
+        vectorDrawables { useSupportLibrary = true }
     }
 
     signingConfigs {
@@ -47,32 +45,41 @@ android {
                     }
                 }
 
-            // try to get secrets from env first for pipeline build, then properties file for local build
-            storeFile = file(
-                System.getenv().getOrDefault(
-                    Constants.KEY_STORE_PATH_VAR,
-                    properties.getProperty(Constants.KEY_STORE_PATH_VAR)
+            // try to get secrets from env first for pipeline build, then properties file for local
+            // build
+            storeFile =
+                file(
+                    System.getenv()
+                        .getOrDefault(
+                            Constants.KEY_STORE_PATH_VAR,
+                            properties.getProperty(Constants.KEY_STORE_PATH_VAR),
+                        ),
                 )
-            )
-            storePassword = System.getenv().getOrDefault(
-                Constants.STORE_PASS_VAR,
-                properties.getProperty(Constants.STORE_PASS_VAR)
-            )
-            keyAlias = System.getenv().getOrDefault(
-                Constants.KEY_ALIAS_VAR,
-                properties.getProperty(Constants.KEY_ALIAS_VAR)
-            )
-            keyPassword = System.getenv().getOrDefault(
-                Constants.KEY_PASS_VAR,
-                properties.getProperty(Constants.KEY_PASS_VAR)
-            )
+            storePassword =
+                System.getenv()
+                    .getOrDefault(
+                        Constants.STORE_PASS_VAR,
+                        properties.getProperty(Constants.STORE_PASS_VAR),
+                    )
+            keyAlias =
+                System.getenv()
+                    .getOrDefault(
+                        Constants.KEY_ALIAS_VAR,
+                        properties.getProperty(Constants.KEY_ALIAS_VAR),
+                    )
+            keyPassword =
+                System.getenv()
+                    .getOrDefault(
+                        Constants.KEY_PASS_VAR,
+                        properties.getProperty(Constants.KEY_PASS_VAR),
+                    )
         }
     }
 
     buildTypes {
         // don't strip
         packaging.jniLibs.keepDebugSymbols.addAll(
-            listOf("libwg-go.so", "libwg-quick.so", "libwg.so")
+            listOf("libwg-go.so", "libwg-quick.so", "libwg.so"),
         )
 
         applicationVariants.all {
@@ -91,13 +98,11 @@ android {
             isShrinkResources = true
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
+                "proguard-rules.pro",
             )
             signingConfig = signingConfigs.getByName(Constants.RELEASE)
         }
-        debug {
-            isDebuggable = true
-        }
+        debug { isDebuggable = true }
     }
     flavorDimensions.add(Constants.TYPE)
     productFlavors {
@@ -108,8 +113,7 @@ android {
         create("general") {
             dimension = Constants.TYPE
             if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
-                apply(plugin = "com.google.gms.google-services")
-                apply(plugin = "com.google.firebase.crashlytics")
+                //any plugins general specific
             }
         }
     }
@@ -118,28 +122,25 @@ android {
         targetCompatibility = JavaVersion.VERSION_17
         isCoreLibraryDesugaringEnabled = true
     }
-    kotlinOptions {
-        jvmTarget = Constants.JVM_TARGET
-    }
+    kotlinOptions { jvmTarget = Constants.JVM_TARGET }
     buildFeatures {
         compose = true
         buildConfig = true
     }
-    composeOptions {
-        kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
-    }
-    packaging {
-        resources {
-            excludes += "/META-INF/{AL2.0,LGPL2.1}"
-        }
-    }
+    composeOptions { kotlinCompilerExtensionVersion = Constants.COMPOSE_COMPILER_EXTENSION_VERSION }
+    packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
 val generalImplementation by configurations
+
 dependencies {
+
+    implementation(project(":logcatter"))
+
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)
-    // optional - helpers for implementing LifecycleOwner in a Service
+
+    // helpers for implementing LifecycleOwner in a Service
     implementation(libs.androidx.lifecycle.service)
     implementation(libs.androidx.activity.compose)
     implementation(platform(libs.androidx.compose.bom))
@@ -160,23 +161,26 @@ dependencies {
     debugImplementation(libs.androidx.compose.ui.tooling)
     debugImplementation(libs.androidx.compose.manifest)
 
-    // wg
+    // get tunnel lib from github packages or mavenLocal
     implementation(libs.tunnel)
+    implementation(libs.amneziawg.android)
     coreLibraryDesugaring(libs.desugar.jdk.libs)
 
     // logging
     implementation(libs.timber)
 
+
     // compose navigation
     implementation(libs.androidx.navigation.compose)
     implementation(libs.androidx.hilt.navigation.compose)
 
+    implementation(libs.zaneschepke.multifab)
+
     // hilt
     implementation(libs.hilt.android)
     ksp(libs.hilt.android.compiler)
 
     // accompanist
-    implementation(libs.accompanist.systemuicontroller)
     implementation(libs.accompanist.permissions)
     implementation(libs.accompanist.flowlayout)
     implementation(libs.accompanist.drawablepainter)
@@ -197,17 +201,12 @@ dependencies {
     // serialization
     implementation(libs.kotlinx.serialization.json)
 
-    // firebase crashlytics
-    generalImplementation(platform(libs.firebase.bom))
-    generalImplementation(libs.google.firebase.crashlytics.ktx)
-    generalImplementation(libs.google.firebase.analytics.ktx)
-
     // barcode scanning
     implementation(libs.zxing.android.embedded)
-    implementation(libs.zxing.core)
 
     // bio
     implementation(libs.androidx.biometric.ktx)
+    implementation(libs.pin.lock.compose)
 
     // shortcuts
     implementation(libs.androidx.core)

app/fdroid-rules.pro

@@ -2,4 +2,4 @@
 
 -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/proguard-rules.pro

@@ -21,6 +21,4 @@
 #-renamesourcefileattribute SourceFile
 -keepclassmembers class * extends androidx.datastore.preferences.protobuf.GeneratedMessageLite {
     <fields>;
-}
-
-
+}

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/src/androidTest/java/com/zaneschepke/wireguardautotunnel/MigrationTest.kt

@@ -4,6 +4,7 @@ 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
@@ -14,47 +15,21 @@ class MigrationTest {
     private val dbName = "migration-test"
 
     @get:Rule
-    val helper: MigrationTestHelper = MigrationTestHelper(
-        InstrumentationRegistry.getInstrumentation(),
-        AppDatabase::class.java
-    )
+    val helper: MigrationTestHelper =
+        MigrationTestHelper(
+            InstrumentationRegistry.getInstrumentation(),
+            AppDatabase::class.java,
+        )
 
     @Test
     @Throws(IOException::class)
-    fun migrate4To5() {
-        helper.createDatabase(dbName, 4).apply {
+    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(
-                "INSERT INTO Settings (is_tunnel_enabled," +
-                        "is_tunnel_on_mobile_data_enabled," +
-                        "trusted_network_ssids," +
-                        "default_tunnel," +
-                        "is_always_on_vpn_enabled," +
-                        "is_tunnel_on_ethernet_enabled," +
-                        "is_shortcuts_enabled," +
-                        "is_battery_saver_enabled," +
-                        "is_tunnel_on_wifi_enabled," +
-                        "is_kernel_enabled," +
-                        "is_restore_on_boot_enabled," +
-                        "is_multi_tunnel_enabled)" +
-                        " VALUES " +
-                        "('false'," +
-                        "'false'," +
-                        "'[trustedSSID1,trustedSSID2]'," +
-                        "'defaultTunnel'," +
-                        "'false'," +
-                        "'false'," +
-                        "'false'," +
-                        "'false'," +
-                        "'false'," +
-                        "'false'," +
-                        "'false'," +
-                        "'false')"
-            )
-            execSQL(
-                "INSERT INTO TunnelConfig (name, wg_quick)" +
-                        " VALUES ('hello', 'hello')"
+                Queries.createTunnelConfig(),
             )
             // Prepare for the next version.
             close()
@@ -62,7 +37,7 @@ class MigrationTest {
 
         // Re-open the database with version 2 and provide
         // MIGRATION_1_2 as the migration process.
-        helper.runMigrationsAndValidate(dbName, 5, true)
+        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,56 +1,62 @@
 <?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.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="32"
         tools:ignore="ScopedStorage" />
-    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"
+    <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.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"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE"/>
+    <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-->
-    <uses-feature android:name="android.software.leanback"
+    <uses-feature
+        android:name="android.software.leanback"
         android:required="false" />
-    <uses-feature android:name="android.hardware.touchscreen"
+    <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" />
+        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:enableOnBackInvokedCallback="true"
         android:name=".WireGuardAutoTunnel"
+        android:allowBackup="true"
+        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:banner="@mipmap/ic_banner"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
@@ -62,11 +68,14 @@
             android:theme="@style/Theme.WireguardAutoTunnel">
             <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"/>
+
+                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
             </intent-filter>
-            <meta-data android:name="android.app.shortcuts"
+            <meta-data
+                android:name="android.app.shortcuts"
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
@@ -74,67 +83,94 @@
             android:screenOrientation="fullSensor"
             android:stateNotNeeded="true"
             android:theme="@style/zxing_CaptureTheme"
-            android:windowSoftInputMode="stateAlwaysHidden" />
+            android:windowSoftInputMode="stateAlwaysHidden"
+            tools:ignore="DiscouragedApi" />
         <activity
-            android:finishOnTaskLaunch="true"
+            android:name=".service.shortcut.ShortcutsActivity"
             android:enabled="true"
             android:exported="true"
-            android:theme="@android:style/Theme.NoDisplay"
-            android:name=".service.shortcut.ShortcutsActivity"/>
+            android:finishOnTaskLaunch="true"
+            android:theme="@android:style/Theme.NoDisplay" />
+
         <service
             android:name=".service.foreground.ForegroundService"
             android:enabled="true"
-            android:foregroundServiceType="systemExempted|specialUse"
-            tools:node="merge"
-            android:exported="false">
+            android:exported="false"
+            android:foregroundServiceType="systemExempted"
+            tools:node="merge" />
+        <service
+            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.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
         </service>
         <service
+            android:name=".service.tile.AutoTunnelControlTile"
             android:exported="true"
-            android:name=".service.tile.TunnelControlTile"
-            android:icon="@drawable/shield"
-            android:label="WG Tunnel"
+            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"
+            <meta-data
+                android:name="android.service.quicksettings.ACTIVE_TILE"
                 android:value="true" />
-            <meta-data android:name="android.service.quicksettings.TOGGLEABLE_TILE"
+            <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.foreground.WireGuardTunnelService"
-            android:permission="android.permission.BIND_VPN_SERVICE"
             android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="systemExempted"
+            android:permission="android.permission.BIND_VPN_SERVICE"
             android:persistent="true"
-            android:foregroundServiceType="systemExempted|specialUse"
-            tools:node="merge"
-            android:exported="false">
+            tools:node="merge">
             <intent-filter>
-                <action android:name="android.net.VpnService"/>
+                <action android:name="android.net.VpnService" />
             </intent-filter>
-            <meta-data android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
+            <meta-data
+                android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
                 android:value="true" />
         </service>
         <service
             android:name=".service.foreground.WireGuardConnectivityWatcherService"
             android:enabled="true"
-            android:stopWithTask="false"
+            android:exported="false"
+            android:foregroundServiceType="systemExempted"
             android:persistent="true"
-            android:foregroundServiceType="systemExempted|specialUse"
-            tools:node="merge"
-            android:exported="false">
-        </service>
-        <receiver android:enabled="true" android:name=".receiver.BootReceiver"
+            android:stopWithTask="false"
+            tools:node="merge" />
+
+        <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"/>
+        <receiver
+            android:name=".receiver.NotificationActionReceiver"
+            android:exported="false" />
     </application>
 </manifest>

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

@@ -3,62 +3,78 @@ package com.zaneschepke.wireguardautotunnel
 import android.app.Application
 import android.content.ComponentName
 import android.content.pm.PackageManager
+import android.os.StrictMode
+import android.os.StrictMode.ThreadPolicy
 import android.service.quicksettings.TileService
-import androidx.lifecycle.ProcessLifecycleOwner
-import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.logcatter.LocalLogCollector
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
 import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
+import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import java.io.IOException
+import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
-    @Inject
-    lateinit var settingsRepository: SettingsRepository
 
     @Inject
-    lateinit var dataStoreManager: DataStoreManager
+    lateinit var localLogCollector: LocalLogCollector
+
+    @Inject
+    @ApplicationScope
+    lateinit var applicationScope: CoroutineScope
+
+    @Inject
+    @IoDispatcher
+    lateinit var ioDispatcher: CoroutineDispatcher
 
     override fun onCreate() {
         super.onCreate()
         instance = this
-        if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree())
-        initSettings()
-        with(ProcessLifecycleOwner.get()) {
-            lifecycleScope.launch {
-                try {
-                    // load preferences into memory
-                    dataStoreManager.init()
-                    requestTileServiceStateUpdate()
-                } catch (e: IOException) {
-                    Timber.e("Failed to load preferences")
-                }
-            }
-        }
-    }
-
-    private fun initSettings() {
-        with(ProcessLifecycleOwner.get()) {
-            lifecycleScope.launch {
-                if (settingsRepository.getAll().isEmpty()) {
-                    settingsRepository.save(Settings())
-                }
-            }
+        if (BuildConfig.DEBUG) {
+            Timber.plant(Timber.DebugTree())
+            StrictMode.setThreadPolicy(
+                ThreadPolicy.Builder()
+                    .detectDiskReads()
+                    .detectDiskWrites()
+                    .detectNetwork()
+                    .penaltyLog()
+                    .build(),
+            )
+        } else Timber.plant(ReleaseTree())
+        applicationScope.launch(ioDispatcher) {
+            PinManager.initialize(this@WireGuardAutoTunnel)
+            if (!isRunningOnAndroidTv()) localLogCollector.start()
         }
     }
 
     companion object {
-        lateinit var instance: WireGuardAutoTunnel private set
+
+        lateinit var instance: WireGuardAutoTunnel
+            private set
+
         fun isRunningOnAndroidTv(): Boolean {
             return instance.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
         }
-        fun requestTileServiceStateUpdate() {
-            TileService.requestListeningState(instance, ComponentName(instance, TunnelControlTile::class.java))
+
+        fun requestTunnelTileServiceStateUpdate() {
+            TileService.requestListeningState(
+                instance,
+                ComponentName(instance, TunnelControlTile::class.java),
+            )
+        }
+
+        fun requestAutoTunnelTileServiceUpdate() {
+            TileService.requestListeningState(
+                instance,
+                ComponentName(instance, AutoTunnelControlTile::class.java),
+            )
         }
     }
 }

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

@@ -2,24 +2,40 @@ 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 com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+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 = 5,
-    autoMigrations = [
-        AutoMigration(from = 1, to = 2), AutoMigration(from = 2, to = 3), AutoMigration(
+    version = 8,
+    autoMigrations =
+    [
+        AutoMigration(from = 1, to = 2),
+        AutoMigration(from = 2, to = 3),
+        AutoMigration(
             from = 3,
-            to = 4
-        ),AutoMigration(
+            to = 4,
+        ),
+        AutoMigration(
             from = 4,
-            to = 5
-        )
+            to = 5,
+        ),
+        AutoMigration(
+            from = 5,
+            to = 6,
+        ),
+        AutoMigration(
+            from = 6,
+            to = 7,
+            spec = RemoveLegacySettingColumnsMigration::class,
+        ),
+        AutoMigration(7, 8),
     ],
-    exportSchema = true
+    exportSchema = true,
 )
 @TypeConverters(DatabaseListConverters::class)
 abstract class AppDatabase : RoomDatabase() {
@@ -27,3 +43,13 @@ abstract class AppDatabase : RoomDatabase() {
 
     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

@@ -12,7 +12,7 @@ class DatabaseListConverters {
 
     @TypeConverter
     fun stringToList(value: String): MutableList<String> {
-        if (value.isEmpty()) return mutableListOf()
+        if (value.isBlank() || value.isEmpty()) return mutableListOf()
         return try {
             Json.decodeFromString<MutableList<String>>(value)
         } catch (e: Exception) {

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

@@ -5,7 +5,7 @@ import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import kotlinx.coroutines.flow.Flow
 
 @Dao

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

@@ -5,7 +5,8 @@ import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 @Dao
@@ -14,13 +15,16 @@ interface TunnelConfigDao {
     suspend fun save(t: TunnelConfig)
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
-    suspend fun saveAll(t: List<TunnelConfig>)
+    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")
-    suspend fun getAll(): List<TunnelConfig>
+    suspend fun getAll(): TunnelConfigs
 
     @Delete
     suspend fun delete(t: TunnelConfig)
@@ -28,6 +32,21 @@ interface TunnelConfigDao {
     @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

@@ -1,39 +1,82 @@
 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) {
+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 TUNNEL_RUNNING_FROM_MANUAL_START =
+            booleanPreferencesKey("TUNNEL_RUNNING_FROM_MANUAL_START")
+        val ACTIVE_TUNNEL = intPreferencesKey("ACTIVE_TUNNEL")
+        val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
     }
 
     // preferences
     private val preferencesKey = "preferences"
-    private val Context.dataStore by preferencesDataStore(
-        name = preferencesKey
+    private val Context.dataStore by
+    preferencesDataStore(
+        name = preferencesKey,
     )
 
     suspend fun init() {
-        context.dataStore.data.first()
+        withContext(ioDispatcher) {
+            try {
+                context.dataStore.data.first()
+            } catch (e: IOException) {
+                Timber.e(e)
+            }
+        }
     }
 
-    suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) =
-        context.dataStore.edit {
-        it[key] = value
-    }
-    fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map {
-        it[key]
+    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)
+            }
+        }
     }
 
-    suspend fun <T> getFromStore(key: Preferences.Key<T>) = context.dataStore.data.first { it.contains(key) }[key]
 
-    val locationDisclosureFlow: Flow<Boolean?> = context.dataStore.data.map {
-        it[LOCATION_DISCLOSURE_SHOWN]
+    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 locationDisclosureShown: Boolean = LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+    val batteryOptimizationDisableShown: Boolean = BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+    val tunnelRunningFromManualStart: Boolean = TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
+    val activeTunnelId: Int? = null
+) {
+    companion object {
+        const val LOCATION_DISCLOSURE_SHOWN_DEFAULT = false
+        const val BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT = false
+        const val TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT = false
+    }
+}

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,53 @@
+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,
+) {
+    companion object {
+        fun configFromWgQuick(wgQuick: String): Config {
+            val inputStream: InputStream = wgQuick.byteInputStream()
+            return inputStream.bufferedReader(Charsets.UTF_8).use {
+                Config.parse(it)
+            }
+        }
+
+        fun configFromAmQuick(amQuick: String): org.amnezia.awg.config.Config {
+            val inputStream: InputStream = amQuick.byteInputStream()
+            return inputStream.bufferedReader(Charsets.UTF_8).use {
+                org.amnezia.awg.config.Config.parse(it)
+            }
+        }
+
+        const val AM_QUICK_DEFAULT = ""
+    }
+}

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

@@ -1,53 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-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") var isAutoTunnelEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled") var isTunnelOnMobileDataEnabled: Boolean = false,
-    @ColumnInfo(name = "trusted_network_ssids") var trustedNetworkSSIDs: MutableList<String> = mutableListOf(),
-    @ColumnInfo(name = "default_tunnel") var defaultTunnel: String? = null,
-    @ColumnInfo(name = "is_always_on_vpn_enabled") var isAlwaysOnVpnEnabled: Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled") var isTunnelOnEthernetEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_shortcuts_enabled",
-        defaultValue = "false"
-    ) var isShortcutsEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_battery_saver_enabled",
-        defaultValue = "false"
-    ) var isBatterySaverEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_tunnel_on_wifi_enabled",
-        defaultValue = "false"
-    ) var isTunnelOnWifiEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_kernel_enabled",
-        defaultValue = "false"
-    ) var isKernelEnabled: Boolean = false,
-    @ColumnInfo(
-    name = "is_restore_on_boot_enabled",
-    defaultValue = "false"
-    ) var isRestoreOnBootEnabled: Boolean = false,
-    @ColumnInfo(
-    name = "is_multi_tunnel_enabled",
-    defaultValue = "false"
-    ) var isMultiTunnelEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_auto_tunnel_paused",
-        defaultValue = "false"
-    ) var isAutoTunnelPaused: Boolean = false,
-) {
-    fun isTunnelConfigDefault(tunnelConfig: TunnelConfig): Boolean {
-        return if (defaultTunnel != null) {
-            val defaultConfig = TunnelConfig.from(defaultTunnel!!)
-            (tunnelConfig.id == defaultConfig.id)
-        } else {
-            false
-        }
-    }
-}

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

@@ -1,34 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-import com.wireguard.config.Config
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
-import java.io.InputStream
-
-@Entity(indices = [Index(value = ["name"], unique = true)])
-@Serializable
-data class TunnelConfig(
-    @PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "name") var name: String,
-    @ColumnInfo(name = "wg_quick") var wgQuick: String
-) {
-    override fun toString(): String {
-        return Json.encodeToString(serializer(), this)
-    }
-
-    companion object {
-        fun from(string: String): TunnelConfig {
-            return Json.decodeFromString<TunnelConfig>(string)
-        }
-
-        fun configFromQuick(wgQuick: String): Config {
-            val inputStream: InputStream = wgQuick.byteInputStream()
-            val reader = inputStream.bufferedReader(Charsets.UTF_8)
-            return Config.parse(reader)
-        }
-    }
-}

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

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

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

@@ -0,0 +1,34 @@
+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 if (appState.isTunnelRunningFromManualStart()) {
+            appState.getActiveTunnelId()?.let {
+                tunnels.getById(it)
+            }
+        } else null
+    }
+
+    override suspend fun toggleWatcherServicePause() {
+        val settings = settings.getSettings()
+        if (settings.isAutoTunnelEnabled) {
+            val pauseAutoTunnel = !settings.isAutoTunnelPaused
+            this.settings.save(
+                settings.copy(
+                    isAutoTunnelPaused = pauseAutoTunnel,
+                ),
+            )
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+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 isBatteryOptimizationDisableShown(): Boolean
+    suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
+
+    suspend fun isTunnelRunningFromManualStart(): Boolean
+    suspend fun setTunnelRunningFromManualStart(id: Int)
+
+    suspend fun setManualStop()
+
+    suspend fun getActiveTunnelId(): 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,81 @@
+package com.zaneschepke.wireguardautotunnel.data.repository
+
+import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import timber.log.Timber
+
+class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager) :
+    AppStateRepository {
+    override suspend fun isLocationDisclosureShown(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN)
+            ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT
+    }
+
+    override suspend fun setLocationDisclosureShown(shown: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown)
+    }
+
+    override suspend fun isBatteryOptimizationDisableShown(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
+            ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
+    }
+
+    override suspend fun setBatteryOptimizationDisableShown(shown: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN, shown)
+    }
+
+    override suspend fun isTunnelRunningFromManualStart(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START)
+            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT
+    }
+
+    override suspend fun setTunnelRunningFromManualStart(id: Int) {
+        setTunnelRunningFromManualStart(true)
+        setActiveTunnelId(id)
+    }
+
+    override suspend fun setManualStop() {
+        setTunnelRunningFromManualStart(false)
+    }
+
+    private suspend fun setTunnelRunningFromManualStart(running: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START, running)
+    }
+
+    override suspend fun getActiveTunnelId(): Int? {
+        return dataStoreManager.getFromStore(DataStoreManager.ACTIVE_TUNNEL)
+    }
+
+    private suspend fun setActiveTunnelId(id: Int) {
+        dataStoreManager.saveToDataStore(DataStoreManager.ACTIVE_TUNNEL, id)
+    }
+
+    override suspend fun getCurrentSsid(): String? {
+        return dataStoreManager.getFromStore(DataStoreManager.CURRENT_SSID)
+    }
+
+    override suspend fun setCurrentSsid(ssid: String) {
+        dataStoreManager.saveToDataStore(DataStoreManager.CURRENT_SSID, ssid)
+    }
+
+    override val generalStateFlow: Flow<GeneralState> =
+        dataStoreManager.preferencesFlow.map { prefs ->
+            prefs?.let { pref ->
+                try {
+                    GeneralState(
+                        locationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
+                            ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
+                        batteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
+                            ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
+                        tunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
+                            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
+                    )
+                } catch (e: IllegalArgumentException) {
+                    Timber.e(e)
+                    GeneralState()
+                }
+            } ?: GeneralState()
+        }
+}

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

@@ -1,10 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.SettingsDao
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import kotlinx.coroutines.flow.Flow
 
-class SettingsRepositoryImpl(private val settingsDoa: SettingsDao) : SettingsRepository {
+class RoomSettingsRepository(private val settingsDoa: SettingsDao) : SettingsRepository {
 
     override suspend fun save(settings: Settings) {
         settingsDoa.save(settings)
@@ -21,4 +21,4 @@ class SettingsRepositoryImpl(private val settingsDoa: SettingsDao) : SettingsRep
     override suspend fun getAll(): List<Settings> {
         return settingsDoa.getAll()
     }
-}
+}

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

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

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

@@ -1,12 +1,14 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+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 save(settings: Settings)
 
-    suspend fun getSettings() : Settings
-    suspend fun getAll() : List<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

@@ -1,14 +1,32 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 interface TunnelConfigRepository {
 
-    fun getTunnelConfigsFlow() : Flow<TunnelConfigs>
-    suspend fun getAll() : TunnelConfigs
+    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 count() : Int
-}
+
+    suspend fun getById(id: Int): TunnelConfig?
+
+    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/data/repository/TunnelConfigRepositoryImpl.kt

@@ -1,28 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.repository
-
-import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
-import kotlinx.coroutines.flow.Flow
-
-class TunnelConfigRepositoryImpl(private val tunnelConfigDao: TunnelConfigDao) : TunnelConfigRepository {
-    override fun getTunnelConfigsFlow(): Flow<TunnelConfigs> {
-        return tunnelConfigDao.getAllFlow()
-    }
-
-    override suspend fun getAll(): TunnelConfigs {
-        return tunnelConfigDao.getAll()
-    }
-
-    override suspend fun save(tunnelConfig: TunnelConfig) {
-        tunnelConfigDao.save(tunnelConfig)
-    }
-
-    override suspend fun delete(tunnelConfig: TunnelConfig) {
-        tunnelConfigDao.delete(tunnelConfig)
-    }
-
-    override suspend fun count(): Int {
-        return tunnelConfigDao.count().toInt()
-    }
-}

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.LogcatHelper
+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 LogcatHelper.init(context = context)
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -1,24 +1,45 @@
 package com.zaneschepke.wireguardautotunnel.module
 
 import android.content.Context
+import androidx.room.Room
+import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import com.zaneschepke.wireguardautotunnel.data.DatabaseCallback
 import com.zaneschepke.wireguardautotunnel.data.SettingsDao
 import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
 import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+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.SettingsRepositoryImpl
 import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepositoryImpl
 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)
 class RepositoryModule {
+    @Provides
+    @Singleton
+    fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
+        return Room.databaseBuilder(
+            context,
+            AppDatabase::class.java,
+            context.getString(R.string.db_name),
+        )
+            .fallbackToDestructiveMigration()
+            .addCallback(DatabaseCallback())
+            .build()
+    }
+
     @Singleton
     @Provides
     fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
@@ -34,18 +55,39 @@ class RepositoryModule {
     @Singleton
     @Provides
     fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao): TunnelConfigRepository {
-        return TunnelConfigRepositoryImpl(tunnelConfigDao)
+        return RoomTunnelConfigRepository(tunnelConfigDao)
     }
 
     @Singleton
     @Provides
     fun provideSettingsRepository(settingsDao: SettingsDao): SettingsRepository {
-        return SettingsRepositoryImpl(settingsDao)
+        return RoomSettingsRepository(settingsDao)
     }
 
     @Singleton
     @Provides
-    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStoreManager {
-        return DataStoreManager(context)
+    fun providePreferencesDataStore(
+        @ApplicationContext context: Context,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher
+    ): DataStoreManager {
+        return DataStoreManager(context, ioDispatcher)
     }
+
+    @Provides
+    @Singleton
+    fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
+        return DataStoreAppStateRepository(dataStoreManager)
+    }
+
+    @Provides
+    @Singleton
+    fun provideAppDataRepository(
+        settingsRepository: SettingsRepository,
+        tunnelConfigRepository: TunnelConfigRepository,
+        appStateRepository: AppStateRepository
+    ): AppDataRepository {
+        return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
+    }
+
+
 }

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

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

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

@@ -6,7 +6,8 @@ import com.wireguard.android.backend.GoBackend
 import com.wireguard.android.backend.WgQuickBackend
 import com.wireguard.android.util.RootShell
 import com.wireguard.android.util.ToolsInstaller
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
@@ -14,6 +15,8 @@ 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.Singleton
 
 @Module
@@ -21,38 +24,56 @@ import javax.inject.Singleton
 class TunnelModule {
     @Provides
     @Singleton
-    fun provideRootShell(
-        @ApplicationContext context: Context
-    ): RootShell {
+    fun provideRootShell(@ApplicationContext context: Context): RootShell {
         return RootShell(context)
     }
 
     @Provides
     @Singleton
     @Userspace
-    fun provideUserspaceBackend(
-        @ApplicationContext context: Context
-    ): Backend {
+    fun provideUserspaceBackend(@ApplicationContext context: Context): Backend {
         return GoBackend(context)
     }
 
     @Provides
     @Singleton
     @Kernel
-    fun provideKernelBackend(
-        @ApplicationContext context: Context,
-        rootShell: RootShell
-    ): Backend {
+    fun provideKernelBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
         return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
     }
 
+    @Provides
+    @Singleton
+    fun provideAmneziaBackend(@ApplicationContext context: Context): org.amnezia.awg.backend.Backend {
+        return org.amnezia.awg.backend.GoBackend(context)
+    }
+
     @Provides
     @Singleton
     fun provideVpnService(
+        amneziaBackend: org.amnezia.awg.backend.Backend,
         @Userspace userspaceBackend: Backend,
         @Kernel kernelBackend: Backend,
-        settingsRepository : SettingsRepository
+        appDataRepository: AppDataRepository,
+        @ApplicationScope applicationScope: CoroutineScope,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher
     ): VpnService {
-        return WireGuardTunnel(userspaceBackend, kernelBackend, settingsRepository)
+        return WireGuardTunnel(
+            amneziaBackend,
+            userspaceBackend,
+            kernelBackend,
+            appDataRepository,
+            applicationScope,
+            ioDispatcher,
+        )
+    }
+
+    @Provides
+    @Singleton
+    fun provideServiceManager(
+        appDataRepository: AppDataRepository,
+        @IoDispatcher ioDispatcher: CoroutineDispatcher
+    ): ServiceManager {
+        return ServiceManager(appDataRepository, ioDispatcher)
     }
 }

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

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

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

@@ -3,23 +3,43 @@ package com.zaneschepke.wireguardautotunnel.receiver
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
+import timber.log.Timber
 import javax.inject.Inject
 
-
 @AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {
 
     @Inject
-    lateinit var settingsRepository: SettingsRepository
+    lateinit var appDataRepository: AppDataRepository
+
+    @Inject
+    lateinit var serviceManager: ServiceManager
+
     override fun onReceive(context: Context?, intent: Intent?) = goAsync {
         if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return@goAsync
-        if(settingsRepository.getSettings().isAutoTunnelEnabled) {
-            ServiceManager.startWatcherServiceForeground(context!!)
+        context?.run {
+            val settings = appDataRepository.settings.getSettings()
+            if (settings.isAutoTunnelEnabled) {
+                Timber.i("Starting watcher service from boot")
+                serviceManager.startWatcherServiceForeground(context)
+            }
+            if (appDataRepository.appState.isTunnelRunningFromManualStart()) {
+                appDataRepository.appState.getActiveTunnelId()?.let {
+                    Timber.i("Starting tunnel that was active before reboot")
+                    serviceManager.startVpnServiceForeground(
+                        context,
+                        appDataRepository.tunnels.getById(it)?.id,
+                    )
+                }
+            }
+            if (settings.isAlwaysOnVpnEnabled) {
+                Timber.i("Starting vpn service from boot AOVPN")
+                serviceManager.startVpnServiceForeground(context)
+            }
         }
     }
-
 }

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

@@ -10,6 +10,7 @@ import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
+import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -17,17 +18,17 @@ class NotificationActionReceiver : BroadcastReceiver() {
     @Inject
     lateinit var settingsRepository: SettingsRepository
 
-    override fun onReceive(
-        context: Context,
-        intent: Intent?
-    ) = goAsync {
+    @Inject
+    lateinit var serviceManager: ServiceManager
+
+    override fun onReceive(context: Context, intent: Intent?) = goAsync {
         try {
-            val settings = settingsRepository.getSettings()
-            if (settings.defaultTunnel != null) {
-                ServiceManager.stopVpnService(context)
-                delay(Constants.TOGGLE_TUNNEL_DELAY)
-                ServiceManager.startVpnService(context, settings.defaultTunnel.toString())
-            }
+            //TODO fix for manual start changes when enabled
+            serviceManager.stopVpnServiceForeground(context)
+            delay(Constants.TOGGLE_TUNNEL_DELAY)
+            serviceManager.startVpnServiceForeground(context)
+        } catch (e: Exception) {
+            Timber.e(e)
         } finally {
             cancel()
         }

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

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

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

@@ -4,6 +4,7 @@ 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() {
@@ -15,53 +16,41 @@ open class ForegroundService : LifecycleService() {
         return null
     }
 
-    override fun onStartCommand(
-        intent: Intent?,
-        flags: Int,
-        startId: Int
-    ): Int {
+    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
-            Timber.d("using an intent with action $action")
             when (action) {
-                Action.START.name, Action.START_FOREGROUND.name -> startService(intent.extras)
-                Action.STOP.name -> stopService(intent.extras)
-                "android.net.VpnService" -> {
-                    Timber.d("Always-on VPN starting service")
+                Action.START.name,
+                Action.START_FOREGROUND.name -> startService(intent.extras)
+
+                Action.STOP.name, Action.STOP_FOREGROUND.name -> stopService()
+                Constants.ALWAYS_ON_VPN_ACTION -> {
+                    Timber.i("Always-on VPN starting service")
                     startService(intent.extras)
                 }
+
                 else -> Timber.d("This should never happen. No action in the received intent")
             }
         } else {
             Timber.d(
-                "with a null intent. It has been probably restarted by the system."
+                "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
     }
 
-    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?) {
+    protected open fun stopService() {
         Timber.d("Stopping ${this.javaClass.simpleName}")
-        try {
-            stopForeground(STOP_FOREGROUND_REMOVE)
-            stopSelf()
-        } catch (e: Exception) {
-            Timber.d("Service stopped without being started: ${e.message}")
-        }
+        stopForeground(STOP_FOREGROUND_REMOVE)
+        stopSelf()
         isServiceStarted = false
     }
 }

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

@@ -1,92 +1,107 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground
 
-import android.app.ActivityManager
 import android.app.Service
 import android.content.Context
-import android.content.Context.ACTIVITY_SERVICE
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.util.Constants
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
 import timber.log.Timber
 
-object ServiceManager {
-    @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
-    }
+class ServiceManager(
+    private val appDataRepository: AppDataRepository,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+) {
 
     private fun <T : Service> actionOnService(
         action: Action,
         context: Context,
         cls: Class<T>,
-        extras: Map<String, String>? = null
+        extras: Map<String, Int>? = null
     ) {
-        if (getServiceState(context, cls) == ServiceState.STOPPED && action == Action.STOP) return
-        if (getServiceState(context, cls) == ServiceState.STARTED && action == Action.START) return
         val intent =
             Intent(context, cls).also {
                 it.action = action.name
-                extras?.forEach { (k, v) ->
-                    it.putExtra(k, v)
-                }
+                extras?.forEach { (k, v) -> it.putExtra(k, v) }
             }
         intent.component?.javaClass
         try {
             when (action) {
-                Action.START_FOREGROUND -> {
-                    context.startForegroundService(intent)
-                }
+                Action.START_FOREGROUND, Action.STOP_FOREGROUND -> context.startForegroundService(
+                    intent,
+                )
 
-                Action.START -> {
-                    context.startService(intent)
-                }
-
-                Action.STOP -> context.startService(intent)
+                Action.START, Action.STOP -> context.startService(intent)
             }
         } catch (e: Exception) {
             Timber.e(e.message)
         }
     }
 
-    fun startVpnService(
+    suspend fun startVpnService(
         context: Context,
-        tunnelConfig: String
+        tunnelId: Int? = null,
+        isManualStart: Boolean = false
     ) {
+        if (isManualStart) onManualStart(tunnelId)
         actionOnService(
             Action.START,
             context,
             WireGuardTunnelService::class.java,
-            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig)
+            tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
         )
     }
 
-    fun stopVpnService(context: Context) {
-        actionOnService(
-            Action.STOP,
-            context,
-            WireGuardTunnelService::class.java
-        )
+    suspend fun stopVpnServiceForeground(context: Context, isManualStop: Boolean = false) {
+        withContext(ioDispatcher) {
+            if (isManualStop) onManualStop()
+            Timber.i("Stopping vpn service")
+            actionOnService(
+                Action.STOP_FOREGROUND,
+                context,
+                WireGuardTunnelService::class.java,
+            )
+        }
     }
 
-    fun startVpnServiceForeground(
+    suspend fun stopVpnService(context: Context, isManualStop: Boolean = false) {
+        withContext(ioDispatcher) {
+            if (isManualStop) onManualStop()
+            Timber.i("Stopping vpn service")
+            actionOnService(
+                Action.STOP,
+                context,
+                WireGuardTunnelService::class.java,
+            )
+        }
+    }
+
+    private suspend fun onManualStop() {
+        appDataRepository.appState.setManualStop()
+    }
+
+    private suspend fun onManualStart(tunnelId: Int?) {
+        tunnelId?.let {
+            appDataRepository.appState.setTunnelRunningFromManualStart(it)
+        }
+    }
+
+    suspend fun startVpnServiceForeground(
         context: Context,
-        tunnelConfig: String
+        tunnelId: Int? = null,
+        isManualStart: Boolean = false
     ) {
-        actionOnService(
-            Action.START_FOREGROUND,
-            context,
-            WireGuardTunnelService::class.java,
-            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig)
-        )
+        withContext(ioDispatcher) {
+            if (isManualStart) onManualStart(tunnelId)
+            actionOnService(
+                Action.START_FOREGROUND,
+                context,
+                WireGuardTunnelService::class.java,
+                tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
+            )
+        }
     }
 
     fun startWatcherServiceForeground(
@@ -95,17 +110,15 @@ object ServiceManager {
         actionOnService(
             Action.START_FOREGROUND,
             context,
-            WireGuardConnectivityWatcherService::class.java
+            WireGuardConnectivityWatcherService::class.java,
         )
     }
 
-    fun startWatcherService(
-        context: Context
-    ) {
+    fun startWatcherService(context: Context) {
         actionOnService(
             Action.START,
             context,
-            WireGuardConnectivityWatcherService::class.java
+            WireGuardConnectivityWatcherService::class.java,
         )
     }
 
@@ -113,7 +126,7 @@ object ServiceManager {
         actionOnService(
             Action.STOP,
             context,
-            WireGuardConnectivityWatcherService::class.java
+            WireGuardConnectivityWatcherService::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/WatcherState.kt

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

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

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

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

@@ -6,21 +6,24 @@ import android.os.Bundle
 import androidx.core.app.ServiceCompat
 import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
 import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
 import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import timber.log.Timber
 import javax.inject.Inject
 
@@ -32,23 +35,28 @@ class WireGuardTunnelService : ForegroundService() {
     lateinit var vpnService: VpnService
 
     @Inject
-    lateinit var settingsRepository: SettingsRepository
-
-    @Inject
-    lateinit var tunnelConfigRepository: TunnelConfigRepository
+    lateinit var appDataRepository: AppDataRepository
 
     @Inject
     lateinit var notificationService: NotificationService
 
-    private lateinit var job: Job
+    @Inject
+    @MainImmediateDispatcher
+    lateinit var mainImmediateDispatcher: CoroutineDispatcher
+
+    @Inject
+    @IoDispatcher
+    lateinit var ioDispatcher: CoroutineDispatcher
+
+    private var job: Job? = null
 
-    private var tunnelName: String = ""
     private var didShowConnected = false
 
     override fun onCreate() {
         super.onCreate()
-        lifecycleScope.launch(Dispatchers.Main) {
-            if(tunnelConfigRepository.getAll().isNotEmpty()) {
+        lifecycleScope.launch(mainImmediateDispatcher) {
+            //TODO fix this to not launch if AOVPN
+            if (appDataRepository.tunnels.count() != 0) {
                 launchVpnNotification()
             }
         }
@@ -57,69 +65,76 @@ class WireGuardTunnelService : ForegroundService() {
     override fun startService(extras: Bundle?) {
         super.startService(extras)
         cancelJob()
-        val tunnelConfigString = extras?.getString(getString(R.string.tunnel_extras_key))
-        val tunnelConfig = tunnelConfigString?.let {
-            TunnelConfig.from(it)
-        }
-        tunnelName = tunnelConfig?.name ?: ""
-        job = lifecycleScope.launch(Dispatchers.IO) {
+        job =
+            lifecycleScope.launch {
                 launch {
-                    if (tunnelConfig != null) {
-                        try {
-                            tunnelName = tunnelConfig.name
-                            vpnService.startTunnel(tunnelConfig)
-                        } catch (e: Exception) {
-                            Timber.e("Problem starting tunnel: ${e.message}")
-                            stopService(extras)
-                        }
-                    } else {
-                        Timber.d("Tunnel config null, starting default tunnel or first")
-                        val settings = settingsRepository.getSettings()
-                        val tunnels = tunnelConfigRepository.getAll()
-                        if (settings.isAlwaysOnVpnEnabled) {
-                            val tunnel = if(settings.defaultTunnel != null) {
-                                TunnelConfig.from(settings.defaultTunnel!!)
-                            } else if(tunnels.isNotEmpty()) {
-                                tunnels.first()
-                            } else {
-                                null
-                            }
-                            if(tunnel != null) {
-                                tunnelName = tunnel.name
-                                vpnService.startTunnel(tunnel)
-                            }
-
-                        }
+                    val tunnelId = extras?.getInt(Constants.TUNNEL_EXTRA_KEY)
+                    if (vpnService.getState() == TunnelState.UP) {
+                        vpnService.stopTunnel()
                     }
+                    vpnService.startTunnel(
+                        tunnelId?.let {
+                            appDataRepository.tunnels.getById(it)
+                        },
+                    )
                 }
-                //TODO add failed to connect notification
                 launch {
-                    vpnService.vpnState.collect { state ->
-                        state.statistics
-                            ?.mapPeerStats()
-                            ?.map { it.value?.handshakeStatus() }
-                            .let { statuses ->
-                                when {
-                                    statuses?.all { it == HandshakeStatus.HEALTHY } == true -> {
-                                        if(!didShowConnected){
-                                            delay(Constants.VPN_CONNECTED_NOTIFICATION_DELAY)
-                                            launchVpnNotification(getString(R.string.tunnel_start_title),"${getString(R.string.tunnel_start_text)} $tunnelName")
-                                            didShowConnected = true
-                                        }
-                                    }
-                                    statuses?.any { it == HandshakeStatus.STALE } == true -> {}
-                                    statuses?.all { it == HandshakeStatus.NOT_STARTED } == true -> {}
-                                    else -> {}
-                                }
-                            }
-                    }
+                    handshakeNotifications()
                 }
             }
     }
 
-    override fun stopService(extras: Bundle?) {
-        super.stopService(extras)
-        lifecycleScope.launch(Dispatchers.IO) {
+    //TODO improve tunnel notifications
+    private suspend fun handshakeNotifications() {
+        withContext(ioDispatcher) {
+            var tunnelName: String? = null
+            vpnService.vpnState.collect { state ->
+                state.statistics
+                    ?.mapPeerStats()
+                    ?.map { it.value?.handshakeStatus() }
+                    .let { statuses ->
+                        when {
+                            statuses?.all { it == HandshakeStatus.HEALTHY } == true -> {
+                                if (!didShowConnected) {
+                                    delay(Constants.VPN_CONNECTED_NOTIFICATION_DELAY)
+                                    tunnelName = state.tunnelConfig?.name
+                                    launchVpnNotification(
+                                        getString(R.string.tunnel_start_title),
+                                        "${getString(R.string.tunnel_start_text)} - $tunnelName",
+                                    )
+                                    didShowConnected = true
+                                }
+                            }
+
+                            statuses?.any { it == HandshakeStatus.STALE } == true -> {}
+                            statuses?.all { it == HandshakeStatus.NOT_STARTED } ==
+                                true -> {
+                            }
+
+                            else -> {}
+                        }
+                    }
+                if (state.status == TunnelState.UP && state.tunnelConfig?.name != tunnelName) {
+                    tunnelName = state.tunnelConfig?.name
+                    launchVpnNotification(
+                        getString(R.string.tunnel_start_title),
+                        "${getString(R.string.tunnel_start_text)} - $tunnelName",
+                    )
+                }
+            }
+        }
+    }
+
+    private fun launchAlwaysOnDisabledNotification() {
+        launchVpnNotification(
+            title = this.getString(R.string.vpn_connection_failed),
+            description = this.getString(R.string.always_on_disabled),
+        )
+    }
+
+    override fun stopService() {
+        super.stopService()
+        lifecycleScope.launch {
             vpnService.stopTunnel()
             didShowConnected = false
         }
@@ -127,7 +142,10 @@ class WireGuardTunnelService : ForegroundService() {
         stopSelf()
     }
 
-    private fun launchVpnNotification(title : String = getString(R.string.vpn_starting),description : String = getString(R.string.attempt_connection)) {
+    private fun launchVpnNotification(
+        title: String = getString(R.string.vpn_starting),
+        description: String = getString(R.string.attempt_connection)
+    ) {
         val notification =
             notificationService.createNotification(
                 channelId = getString(R.string.vpn_channel_id),
@@ -136,13 +154,13 @@ class WireGuardTunnelService : ForegroundService() {
                 onGoing = false,
                 vibration = false,
                 showTimestamp = true,
-                description = description
+                description = description,
             )
         ServiceCompat.startForeground(
             this,
             foregroundId,
             notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
         )
     }
 
@@ -156,26 +174,28 @@ class WireGuardTunnelService : ForegroundService() {
                     this,
                     0,
                     Intent(this, NotificationActionReceiver::class.java),
-                    PendingIntent.FLAG_IMMUTABLE
+                    PendingIntent.FLAG_IMMUTABLE,
                 ),
                 actionText = getString(R.string.restart),
                 title = getString(R.string.vpn_connection_failed),
                 onGoing = false,
                 vibration = true,
                 showTimestamp = true,
-                description = message
+                description = message,
             )
         ServiceCompat.startForeground(
             this,
             foregroundId,
             notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID
+            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
         )
     }
 
     private fun cancelJob() {
-        if (this::job.isInitialized) {
-            job.cancel()
+        try {
+            job?.cancel()
+        } catch (e: CancellationException) {
+            Timber.i("Tunnel job cancelled")
         }
     }
 }

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

@@ -24,72 +24,70 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
     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 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 fun onLost(network: Network) {
-                                trySend(NetworkStatus.Unavailable(network))
-                            }
-
-                            override fun onCapabilitiesChanged(
-                                network: Network,
-                                networkCapabilities: NetworkCapabilities
-                            ) {
-                                trySend(
-                                    NetworkStatus.CapabilitiesChanged(
-                                        network,
-                                        networkCapabilities
-                                    )
-                                )
-                            }
+                        override fun onAvailable(network: Network) {
+                            trySend(NetworkStatus.Available(network))
                         }
-                    }
 
-                    else -> {
-                        object : ConnectivityManager.NetworkCallback() {
-                            override fun onAvailable(network: Network) {
-                                trySend(NetworkStatus.Available(network))
-                            }
+                        override fun onLost(network: Network) {
+                            trySend(NetworkStatus.Unavailable(network))
+                        }
 
-                            override fun onLost(network: Network) {
-                                trySend(NetworkStatus.Unavailable(network))
-                            }
-
-                            override fun onCapabilitiesChanged(
-                                network: Network,
-                                networkCapabilities: NetworkCapabilities
-                            ) {
-                                trySend(
-                                    NetworkStatus.CapabilitiesChanged(
-                                        network,
-                                        networkCapabilities
-                                    )
-                                )
-                            }
+                        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)
 
-            awaitClose {
-                connectivityManager.unregisterNetworkCallback(networkStatusCallback)
+                else -> {
+                    object : ConnectivityManager.NetworkCallback() {
+                        override fun onAvailable(network: Network) {
+                            trySend(NetworkStatus.Available(network))
+                        }
+
+                        override fun onLost(network: Network) {
+                            trySend(NetworkStatus.Unavailable(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)
+
+        awaitClose { connectivityManager.unregisterNetworkCallback(networkStatusCallback) }
+    }
 
     override fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
         var ssid: String? = getWifiNameFromCapabilities(networkCapabilities)
@@ -119,18 +117,16 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 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
-): Flow<Result> =
-    map { status ->
-        when (status) {
-            is NetworkStatus.Unavailable -> onUnavailable(status.network)
-            is NetworkStatus.Available -> onAvailable(status.network)
-            is NetworkStatus.CapabilitiesChanged -> onCapabilitiesChanged(
+    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
+                status.networkCapabilities,
             )
-        }
     }
+}

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

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

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

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

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

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

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

@@ -3,7 +3,6 @@ package com.zaneschepke.wireguardautotunnel.service.notification
 import android.app.Notification
 import android.app.NotificationManager
 import android.app.PendingIntent
-import androidx.core.app.NotificationCompat
 
 interface NotificationService {
     fun createNotification(

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

@@ -13,23 +13,21 @@ import com.zaneschepke.wireguardautotunnel.ui.MainActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WireGuardNotification
-@Inject
-constructor(
-    @ApplicationContext private val context: Context
-) : NotificationService {
+class WireGuardNotification @Inject constructor(@ApplicationContext private val context: Context) :
+    NotificationService {
     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)
+            context.getString(R.string.watcher_channel_id),
+        )
+    private val tunnelBuilder: NotificationCompat.Builder =
+        NotificationCompat.Builder(
+            context,
+            context.getString(R.string.vpn_channel_id),
         )
-    private val tunnelBuilder: NotificationCompat.Builder = NotificationCompat.Builder(
-        context,
-        context.getString(R.string.vpn_channel_id)
-    )
 
     override fun createNotification(
         channelId: String,
@@ -49,15 +47,16 @@ constructor(
             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
-            }
+                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, MainActivity::class.java).let { notificationIntent ->
@@ -65,26 +64,26 @@ constructor(
                     context,
                     0,
                     notificationIntent,
-                    PendingIntent.FLAG_IMMUTABLE
+                    PendingIntent.FLAG_IMMUTABLE,
                 )
             }
 
-        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
-                )
+        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()
+                    NotificationCompat.Action.Builder(0, actionText, action).build(),
                 )
                 it.setAutoCancel(true)
             }
@@ -95,7 +94,7 @@ constructor(
                 .setOngoing(onGoing)
                 .setPriority(NotificationCompat.PRIORITY_HIGH)
                 .setShowWhen(showTimestamp)
-                .setSmallIcon(R.mipmap.ic_launcher_foreground)
+                .setSmallIcon(R.drawable.ic_launcher)
                 .build()
         }
     }

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

@@ -1,75 +1,70 @@
 package com.zaneschepke.wireguardautotunnel.service.shortcut
 
 import android.os.Bundle
-import android.view.View
 import androidx.activity.ComponentActivity
-import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.Action
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardConnectivityWatcherService
 import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
-import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class ShortcutsActivity : ComponentActivity() {
-    @Inject
-    lateinit var settingsRepository: SettingsRepository
 
     @Inject
-    lateinit var tunnelConfigRepository: TunnelConfigRepository
+    lateinit var appDataRepository: AppDataRepository
 
-    private suspend fun toggleWatcherServicePause() {
-            val settings = settingsRepository.getSettings()
-            if (settings.isAutoTunnelEnabled) {
-                val pauseAutoTunnel = !settings.isAutoTunnelPaused
-                settingsRepository.save(settings.copy(
-                    isAutoTunnelPaused = pauseAutoTunnel
-                ))
-            }
-        }
+    @Inject
+    lateinit var serviceManager: ServiceManager
+
+    @Inject
+    @ApplicationScope
+    lateinit var applicationScope: CoroutineScope
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        setContentView(View(this))
-        if (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)
-                .equals(WireGuardTunnelService::class.java.simpleName)
-        ) {
-            lifecycleScope.launch(Dispatchers.Main) {
-                val settings = settingsRepository.getSettings()
-                if (settings.isShortcutsEnabled) {
-                    try {
+        applicationScope.launch {
+            val settings = appDataRepository.settings.getSettings()
+            if (settings.isShortcutsEnabled) {
+                when (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)) {
+                    WireGuardTunnelService::class.java.simpleName -> {
                         val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
-                        val tunnelConfig =
-                            if (tunnelName != null) {
-                                tunnelConfigRepository.getAll().firstOrNull { it.name == tunnelName }
-                            } else {
-                                if (settings.defaultTunnel == null) {
-                                    tunnelConfigRepository.getAll().first()
-                                } else {
-                                    TunnelConfig.from(settings.defaultTunnel!!)
-                                }
+                        val tunnelConfig = tunnelName?.let {
+                            appDataRepository.tunnels.getAll().firstOrNull {
+                                it.name == tunnelName
                             }
-                        tunnelConfig ?: return@launch
-                        toggleWatcherServicePause()
+                        }
                         when (intent.action) {
-                            Action.STOP.name -> ServiceManager.stopVpnService(
-                                this@ShortcutsActivity
+                            Action.START.name -> serviceManager.startVpnServiceForeground(
+                                this@ShortcutsActivity, tunnelConfig?.id, isManualStart = true,
                             )
-                            Action.START.name -> ServiceManager.startVpnService(
+
+                            Action.STOP.name -> serviceManager.stopVpnServiceForeground(
                                 this@ShortcutsActivity,
-                                tunnelConfig.toString()
+                                isManualStop = true,
+                            )
+                        }
+                    }
+
+                    WireGuardConnectivityWatcherService::class.java.simpleName -> {
+                        when (intent.action) {
+                            Action.START.name -> appDataRepository.settings.save(
+                                settings.copy(
+                                    isAutoTunnelPaused = false,
+                                ),
+                            )
+
+                            Action.STOP.name -> appDataRepository.settings.save(
+                                settings.copy(
+                                    isAutoTunnelPaused = true,
+                                ),
                             )
                         }
-                    } catch (e: Exception) {
-                        Timber.e(e.message)
-                        finish()
                     }
                 }
             }

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

@@ -0,0 +1,101 @@
+package com.zaneschepke.wireguardautotunnel.service.tile
+
+import android.os.Build
+import android.service.quicksettings.Tile
+import android.service.quicksettings.TileService
+import com.zaneschepke.wireguardautotunnel.R
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class AutoTunnelControlTile : TileService() {
+
+    @Inject
+    lateinit var appDataRepository: AppDataRepository
+
+    @Inject
+    lateinit var serviceManager: ServiceManager
+
+    @Inject
+    @ApplicationScope
+    lateinit var applicationScope: CoroutineScope
+
+    private var manualStartConfig: TunnelConfig? = null
+
+    override fun onStartListening() {
+        super.onStartListening()
+        applicationScope.launch {
+            val settings = appDataRepository.settings.getSettings()
+            when (settings.isAutoTunnelEnabled) {
+                true -> {
+                    if (settings.isAutoTunnelPaused) {
+                        setInactive()
+                        setTileDescription(this@AutoTunnelControlTile.getString(R.string.paused))
+                    } else {
+                        setActive()
+                        setTileDescription(this@AutoTunnelControlTile.getString(R.string.active))
+                    }
+                }
+
+                false -> {
+                    setTileDescription(this@AutoTunnelControlTile.getString(R.string.disabled))
+                    setUnavailable()
+                }
+            }
+        }
+    }
+
+    override fun onTileAdded() {
+        super.onTileAdded()
+        onStartListening()
+    }
+
+    override fun onClick() {
+        super.onClick()
+        unlockAndRun {
+            applicationScope.launch {
+                try {
+                    appDataRepository.toggleWatcherServicePause()
+                } catch (e: Exception) {
+                    Timber.e(e.message)
+                } finally {
+                    cancel()
+                }
+            }
+        }
+    }
+
+    private fun setActive() {
+        qsTile.state = Tile.STATE_ACTIVE
+        qsTile.updateTile()
+    }
+
+    private fun setInactive() {
+        qsTile.state = Tile.STATE_INACTIVE
+        qsTile.updateTile()
+    }
+
+    private fun setUnavailable() {
+        manualStartConfig = null
+        qsTile.state = Tile.STATE_UNAVAILABLE
+        qsTile.updateTile()
+    }
+
+    private fun setTileDescription(description: String) {
+        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()
+    }
+}

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

@@ -3,84 +3,86 @@ package com.zaneschepke.wireguardautotunnel.service.tile
 import android.os.Build
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
-import com.wireguard.android.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
-class TunnelControlTile() : TileService() {
+class TunnelControlTile : TileService() {
 
     @Inject
-    lateinit var tunnelConfigRepository: TunnelConfigRepository
-
-    @Inject
-    lateinit var settingsRepository: SettingsRepository
+    lateinit var appDataRepository: AppDataRepository
 
     @Inject
     lateinit var vpnService: VpnService
 
-    private val scope = CoroutineScope(Dispatchers.IO)
+    @Inject
+    lateinit var serviceManager: ServiceManager
 
-    private var tunnelName : String? = null
+    @Inject
+    @ApplicationScope
+    lateinit var applicationScope: CoroutineScope
+
+    private var manualStartConfig: TunnelConfig? = null
+
+    private var job: Job? = null;
 
     override fun onStartListening() {
         super.onStartListening()
         Timber.d("On start listening called")
-        scope.launch {
-            vpnService.vpnState.collect {
-                when(it.status) {
-                    Tunnel.State.UP -> setActive()
-                    Tunnel.State.DOWN -> setInactive()
+        //TODO Fix this
+        if (job == null || job?.isCancelled == true) job = applicationScope.launch {
+            vpnService.vpnState.collect { it ->
+                when (it.status) {
+                    TunnelState.UP -> {
+                        setActive()
+                        it.tunnelConfig?.name?.let { name -> setTileDescription(name) }
+                    }
+
+                    TunnelState.DOWN -> {
+                        setInactive()
+                        val config = appDataRepository.getStartTunnelConfig()?.also { config ->
+                            manualStartConfig = config
+                        } ?: appDataRepository.getPrimaryOrFirstTunnel()
+                        config?.let {
+                            setTileDescription(it.name)
+                        } ?: setUnavailable()
+                    }
+
                     else -> setInactive()
                 }
-                val tunnels = tunnelConfigRepository.getAll()
-                if(tunnels.isEmpty()) {
-                    setUnavailable()
-                    return@collect
-                }
-                tunnelName = it.name.ifBlank {
-                    val settings = settingsRepository.getSettings()
-                    if (settings.defaultTunnel != null) {
-                        TunnelConfig.from(settings.defaultTunnel!!).name
-                    } else tunnels.firstOrNull()?.name
-                }
-                setTileDescription(tunnelName ?: "")
             }
         }
     }
-    override fun onDestroy() {
-        super.onDestroy()
-        scope.cancel()
-    }
 
-    override fun onTileRemoved() {
-        super.onTileRemoved()
-        scope.cancel()
+    override fun onTileAdded() {
+        super.onTileAdded()
+        onStartListening()
     }
 
     override fun onClick() {
         super.onClick()
         unlockAndRun {
-            scope.launch {
+            applicationScope.launch {
                 try {
-                    val tunnelConfig = tunnelConfigRepository.getAll().first { it.name == tunnelName }
-                    toggleWatcherServicePause()
-                    if (vpnService.getState() == Tunnel.State.UP) {
-                        ServiceManager.stopVpnService(this@TunnelControlTile)
-                    } else {
-                        ServiceManager.startVpnServiceForeground(
+                    if (vpnService.getState() == TunnelState.UP) {
+                        serviceManager.stopVpnServiceForeground(
                             this@TunnelControlTile,
-                            tunnelConfig.toString()
+                            isManualStop = true,
+                        )
+                    } else {
+                        serviceManager.startVpnServiceForeground(
+                            this@TunnelControlTile, manualStartConfig?.id, isManualStart = true,
                         )
                     }
                 } catch (e: Exception) {
@@ -92,18 +94,6 @@ class TunnelControlTile() : TileService() {
         }
     }
 
-    private fun toggleWatcherServicePause() {
-        scope.launch {
-            val settings = settingsRepository.getSettings()
-            if (settings.isAutoTunnelEnabled) {
-                val pauseAutoTunnel = !settings.isAutoTunnelPaused
-                settingsRepository.save(settings.copy(
-                    isAutoTunnelPaused = pauseAutoTunnel
-                ))
-            }
-        }
-    }
-
     private fun setActive() {
         qsTile.state = Tile.STATE_ACTIVE
         qsTile.updateTile()
@@ -115,6 +105,7 @@ class TunnelControlTile() : TileService() {
     }
 
     private fun setUnavailable() {
+        manualStartConfig = null
         qsTile.state = Tile.STATE_UNAVAILABLE
         qsTile.updateTile()
     }

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

@@ -4,13 +4,13 @@ enum class HandshakeStatus {
     HEALTHY,
     STALE,
     UNKNOWN,
-    NOT_STARTED
-    ;
+    NOT_STARTED;
 
     companion object {
         private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 180
         const val STATUS_CHANGE_TIME_BUFFER = 30
-        const val STALE_TIME_LIMIT_SEC = WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + STATUS_CHANGE_TIME_BUFFER
+        const val 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/TunnelState.kt

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

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

@@ -1,10 +1,10 @@
 package com.zaneschepke.wireguardautotunnel.service.tunnel
 
-import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Tunnel
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 
 data class VpnState(
-    val status : Tunnel.State = Tunnel.State.DOWN,
-    val name : String = "",
-    val statistics : Statistics? = null
+    val status: TunnelState = TunnelState.DOWN,
+    val tunnelConfig: TunnelConfig? = null,
+    val statistics: TunnelStatistics? = null
 )

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

@@ -2,148 +2,200 @@ package com.zaneschepke.wireguardautotunnel.service.tunnel
 
 import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.BackendException
-import com.wireguard.android.backend.Statistics
 import com.wireguard.android.backend.Tunnel.State
-import com.wireguard.config.Config
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.module.Kernel
 import com.zaneschepke.wireguardautotunnel.module.Userspace
+import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.AmneziaStatistics
+import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
+import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.WireGuardStatistics
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
 import javax.inject.Inject
 
 class WireGuardTunnel
 @Inject
 constructor(
+    private val userspaceAmneziaBackend: org.amnezia.awg.backend.Backend,
     @Userspace private val userspaceBackend: Backend,
     @Kernel private val kernelBackend: Backend,
-    private val settingsRepository: SettingsRepository
+    private val appDataRepository: AppDataRepository,
+    @ApplicationScope private val applicationScope: CoroutineScope,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
 ) : VpnService {
     private val _vpnState = MutableStateFlow(VpnState())
     override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()
 
-    private val scope = CoroutineScope(Dispatchers.IO)
 
-    private lateinit var statsJob: Job
-
-    private var config: Config? = null
+    private var statsJob: Job? = null
 
     private var backend: Backend = userspaceBackend
 
-    private var backendIsUserspace = true
+    private var backendIsWgUserspace = true
+
+    private var backendIsAmneziaUserspace = false
 
     init {
-        scope.launch {
-            settingsRepository.getSettingsFlow().collect {
-                if (it.isKernelEnabled && backendIsUserspace) {
-                    Timber.d("Setting kernel backend")
+        applicationScope.launch(ioDispatcher) {
+            appDataRepository.settings.getSettingsFlow().collect {
+                if (it.isKernelEnabled && (backendIsWgUserspace || backendIsAmneziaUserspace)) {
+                    Timber.i("Setting kernel backend")
                     backend = kernelBackend
-                    backendIsUserspace = false
-                } else if (!it.isKernelEnabled && !backendIsUserspace) {
-                    Timber.d("Setting userspace backend")
+                    backendIsWgUserspace = false
+                    backendIsAmneziaUserspace = false
+                } else if (!it.isKernelEnabled && !it.isAmneziaEnabled && !backendIsWgUserspace) {
+                    Timber.i("Setting WireGuard userspace backend")
                     backend = userspaceBackend
-                    backendIsUserspace = true
+                    backendIsWgUserspace = true
+                    backendIsAmneziaUserspace = false
+                } else if (it.isAmneziaEnabled && !backendIsAmneziaUserspace) {
+                    Timber.i("Setting Amnezia userspace backend")
+                    backendIsAmneziaUserspace = true
+                    backendIsWgUserspace = false
                 }
             }
         }
     }
 
-    override suspend fun startTunnel(tunnelConfig: TunnelConfig): State {
-        return try {
-            stopTunnelOnConfigChange(tunnelConfig)
-            emitTunnelName(tunnelConfig.name)
-            config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val state =
-                backend.setState(
-                    this,
-                    State.UP,
-                    config
-                )
-            emitTunnelState(state)
-            state
-        } catch (e: Exception) {
-            Timber.e("Failed to start tunnel with error: ${e.message}")
-            State.DOWN
+    private fun setState(tunnelConfig: TunnelConfig?, tunnelState: TunnelState): TunnelState {
+        return if (backendIsAmneziaUserspace) {
+            Timber.i("Using Amnezia backend")
+            val config = tunnelConfig?.let {
+                if (it.amQuick != "") TunnelConfig.configFromAmQuick(it.amQuick) else {
+                    Timber.w("Using backwards compatible wg config, amnezia specific config not found.")
+                    TunnelConfig.configFromAmQuick(it.wgQuick)
+                }
+            }
+            val state = userspaceAmneziaBackend.setState(this, tunnelState.toAmState(), config)
+            TunnelState.from(state)
+        } else {
+            Timber.i("Using Wg backend")
+            val wgConfig = tunnelConfig?.let { TunnelConfig.configFromWgQuick(it.wgQuick) }
+            val state = backend.setState(
+                this,
+                tunnelState.toWgState(),
+                wgConfig,
+            )
+            TunnelState.from(state)
         }
     }
 
-    private fun emitTunnelState(state: State) {
+    override suspend fun startTunnel(tunnelConfig: TunnelConfig?): TunnelState {
+        return withContext(ioDispatcher) {
+            try {
+                //TODO we need better error handling here
+                val config = tunnelConfig ?: appDataRepository.getPrimaryOrFirstTunnel()
+                if (config != null) {
+                    emitTunnelConfig(config)
+                    setState(config, TunnelState.UP)
+                } else throw Exception("No tunnels")
+            } catch (e: BackendException) {
+                Timber.e("Failed to start tunnel with error: ${e.message}")
+                TunnelState.from(State.DOWN)
+            }
+        }
+    }
+
+    private fun emitTunnelState(state: TunnelState) {
         _vpnState.tryEmit(
             _vpnState.value.copy(
-                status = state
-            )
+                status = state,
+            ),
         )
     }
 
-    private fun emitBackendStatistics(statistics: Statistics) {
+    private fun emitBackendStatistics(statistics: TunnelStatistics) {
         _vpnState.tryEmit(
             _vpnState.value.copy(
-                statistics = statistics
-            )
+                statistics = statistics,
+            ),
         )
     }
 
-    private suspend fun emitTunnelName(name: String) {
+    private suspend fun emitTunnelConfig(tunnelConfig: TunnelConfig?) {
         _vpnState.emit(
             _vpnState.value.copy(
-                name = name
-            )
+                tunnelConfig = tunnelConfig,
+            ),
         )
     }
 
-    private suspend fun stopTunnelOnConfigChange(tunnelConfig: TunnelConfig) {
-        if (getState() == State.UP && _vpnState.value.name != tunnelConfig.name) {
-            stopTunnel()
-        }
-    }
-
-    override fun getName(): String {
-        return _vpnState.value.name
+    private fun resetVpnState() {
+        _vpnState.tryEmit(VpnState())
     }
 
     override suspend fun stopTunnel() {
-        try {
-            if (getState() == State.UP) {
-                val state = backend.setState(this, State.DOWN, null)
-                emitTunnelState(state)
+        withContext(ioDispatcher) {
+            try {
+                if (getState() == TunnelState.UP) {
+                    val state = setState(null, TunnelState.DOWN)
+                    resetVpnState()
+                    emitTunnelState(state)
+                }
+            } catch (e: BackendException) {
+                Timber.e("Failed to stop wireguard tunnel with error: ${e.message}")
+            } catch (e: org.amnezia.awg.backend.BackendException) {
+                Timber.e("Failed to stop amnezia tunnel with error: ${e.message}")
             }
-        } catch (e: BackendException) {
-            Timber.e("Failed to stop tunnel with error: ${e.message}")
         }
     }
 
-    override fun getState(): State {
-        return backend.getState(this)
+    override fun getState(): TunnelState {
+        return if (backendIsAmneziaUserspace) TunnelState.from(userspaceAmneziaBackend.getState(this))
+        else TunnelState.from(backend.getState(this))
+    }
+
+    override fun getName(): String {
+        return _vpnState.value.tunnelConfig?.name ?: ""
+    }
+
+
+    override fun onStateChange(newState: Tunnel.State) {
+        handleStateChange(TunnelState.from(newState))
+    }
+
+    private fun handleStateChange(state: TunnelState) {
+        emitTunnelState(state)
+        WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+        if (state == TunnelState.UP) {
+            statsJob = startTunnelStatisticsJob()
+        }
+        if (state == TunnelState.DOWN) {
+            try {
+                statsJob?.cancel()
+            } catch (e: CancellationException) {
+                Timber.i("Stats job cancelled")
+            }
+        }
+    }
+
+    private fun startTunnelStatisticsJob() = applicationScope.launch(ioDispatcher) {
+        while (true) {
+            if (backendIsAmneziaUserspace) {
+                emitBackendStatistics(AmneziaStatistics(userspaceAmneziaBackend.getStatistics(this@WireGuardTunnel)))
+            } else {
+                emitBackendStatistics(WireGuardStatistics(backend.getStatistics(this@WireGuardTunnel)))
+            }
+            delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
+        }
     }
 
     override fun onStateChange(state: State) {
-        val tunnel = this
-        emitTunnelState(state)
-        WireGuardAutoTunnel.requestTileServiceStateUpdate()
-        if (state == State.UP) {
-            statsJob =
-                scope.launch {
-                    while (true) {
-                        val statistics = backend.getStatistics(tunnel)
-                        emitBackendStatistics(statistics)
-                        delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
-                    }
-                }
-        }
-        if (state == State.DOWN) {
-            if (this::statsJob.isInitialized) {
-                statsJob.cancel()
-            }
-        }
+        handleStateChange(TunnelState.from(state))
     }
 }

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

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

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

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

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

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

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

@@ -1,13 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import androidx.lifecycle.ViewModel
-import com.zaneschepke.wireguardautotunnel.data.SettingsDao
-import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
-
-@HiltViewModel
-class ActivityViewModel @Inject constructor(
-    private val settingsRepo: SettingsDao,
-) : ViewModel() {
-
-}

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

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

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

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

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

@@ -1,16 +1,17 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
 import android.Manifest
-import android.content.Intent
-import android.net.Uri
 import android.os.Build
 import android.os.Bundle
-import android.provider.Settings
+import androidx.activity.SystemBarStyle
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.foundation.focusable
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarData
@@ -21,96 +22,149 @@ import androidx.compose.material3.SnackbarResult
 import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.unit.dp
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.lifecycleScope
+import androidx.navigation.NavType
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
+import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
+import androidx.navigation.navArgument
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
-import com.wireguard.android.backend.GoBackend
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.common.PermissionRequestFailedScreen
+import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.CustomSnackBar
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.ConfigScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.options.OptionsScreen
+import com.zaneschepke.wireguardautotunnel.ui.screens.pinlock.PinLockScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
-import com.zaneschepke.wireguardautotunnel.ui.theme.TransparentSystemBars
+import com.zaneschepke.wireguardautotunnel.ui.screens.support.logs.LogsScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
-import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.StringValue
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import xyz.teamgravity.pin_lock_compose.PinManager
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
+
+    @Inject
+    lateinit var dataStoreManager: DataStoreManager
+
+    @Inject
+    lateinit var settingsRepository: SettingsRepository
+
+    @Inject
+    lateinit var serviceManager: ServiceManager
+
     @OptIn(
-        ExperimentalPermissionsApi::class
+        ExperimentalPermissionsApi::class,
     )
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        setContent {
-//            val activityViewModel = hiltViewModel<ActivityViewModel>()
 
+        enableEdgeToEdge(navigationBarStyle = SystemBarStyle.dark(Color.Transparent.toArgb()))
+
+        // load preferences into memory and init data
+        lifecycleScope.launch {
+            dataStoreManager.init()
+            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+            val settings = settingsRepository.getSettings()
+            if (settings.isAutoTunnelEnabled) {
+                serviceManager.startWatcherService(application.applicationContext)
+            }
+        }
+        setContent {
+            val appViewModel = hiltViewModel<AppViewModel>()
+            val appUiState by appViewModel.appUiState.collectAsStateWithLifecycle()
             val navController = rememberNavController()
-            val focusRequester = remember { FocusRequester()}
+            val navBackStackEntry by navController.currentBackStackEntryAsState()
+
+            val notificationPermissionState =
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
+                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS) else null
+
+            val snackbarHostState = remember { SnackbarHostState() }
+
+            val vpnActivityResultState =
+                rememberLauncherForActivityResult(
+                    ActivityResultContracts.StartActivityForResult(),
+                    onResult = {
+                        val accepted = (it.resultCode == RESULT_OK)
+                        if (accepted) {
+                            appViewModel.onVpnPermissionAccepted()
+                        }
+                    },
+                )
+
+            fun showSnackBarMessage(message: StringValue) {
+                lifecycleScope.launch(Dispatchers.Main) {
+                    val result =
+                        snackbarHostState.showSnackbar(
+                            message = message.asString(this@MainActivity),
+                            duration = SnackbarDuration.Short,
+                        )
+                    when (result) {
+                        SnackbarResult.ActionPerformed,
+                        SnackbarResult.Dismissed -> {
+                            snackbarHostState.currentSnackbarData?.dismiss()
+                        }
+                    }
+                }
+            }
+
+            LaunchedEffect(appUiState.requestPermissions) {
+                if (appUiState.requestPermissions) {
+                    appViewModel.permissionsRequested()
+                    if (notificationPermissionState != null && !notificationPermissionState.status.isGranted
+                    ) {
+                        showSnackBarMessage(StringValue.StringResource(R.string.notification_permission_required))
+                        return@LaunchedEffect notificationPermissionState.launchPermissionRequest()
+                    }
+                    if (!appUiState.vpnPermissionAccepted) {
+                        return@LaunchedEffect appViewModel.vpnIntent?.let {
+                            vpnActivityResultState.launch(
+                                it,
+                            )
+                        }!!
+                    }
+                }
+            }
 
             WireguardAutoTunnelTheme {
-                TransparentSystemBars()
-
-                val snackbarHostState = remember { SnackbarHostState() }
-
-                val notificationPermissionState =
-                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS)
-
-                fun requestNotificationPermission() {
-                    if (!notificationPermissionState.status.isGranted && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                        notificationPermissionState.launchPermissionRequest()
-                    }
-                }
-
-                var vpnIntent by remember { mutableStateOf(GoBackend.VpnService.prepare(this)) }
-                val vpnActivityResultState =
-                    rememberLauncherForActivityResult(
-                        ActivityResultContracts.StartActivityForResult(),
-                        onResult = {
-                            val accepted = (it.resultCode == RESULT_OK)
-                            if (accepted) {
-                                vpnIntent = null
-                            }
-                        }
+                LaunchedEffect(Unit) {
+                    appViewModel.setNotificationPermissionAccepted(
+                        notificationPermissionState?.status?.isGranted ?: true,
                     )
-                LaunchedEffect(vpnIntent) {
-                    if (vpnIntent != null) {
-                        vpnActivityResultState.launch(vpnIntent)
-                    } else {
-                        requestNotificationPermission()
+                }
+
+                LaunchedEffect(appUiState.snackbarMessageConsumed) {
+                    if (!appUiState.snackbarMessageConsumed) {
+                        showSnackBarMessage(StringValue.DynamicString(appUiState.snackbarMessage))
+                        appViewModel.snackbarMessageConsumed()
                     }
                 }
 
-                fun showSnackBarMessage(message: String) {
-                    lifecycleScope.launch(Dispatchers.Main) {
-                        val result = snackbarHostState.showSnackbar(
-                                message = message,
-                                actionLabel = applicationContext.getString(R.string.okay),
-                                duration = SnackbarDuration.Short
-                            )
-                        when (result) {
-                            SnackbarResult.ActionPerformed, SnackbarResult.Dismissed -> {
-                                snackbarHostState.currentSnackbarData?.dismiss()
-                            }
-                        }
-                    }
-                }
+                val focusRequester = remember { FocusRequester() }
 
                 Scaffold(
                     snackbarHost = {
@@ -118,86 +172,117 @@ class MainActivity : AppCompatActivity() {
                             CustomSnackBar(
                                 snackbarData.visuals.message,
                                 isRtl = false,
-                                containerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(
-                                    2.dp
-                                )
+                                containerColor =
+                                MaterialTheme.colorScheme.surfaceColorAtElevation(
+                                    2.dp,
+                                ),
                             )
                         }
                     },
-                    modifier = Modifier.focusable().focusProperties { up = focusRequester },
-                    bottomBar =
-                    if (vpnIntent == null && notificationPermissionState.status.isGranted) {
-                        { BottomNavBar(navController, listOf(
-                            Screen.Main.navItem,
-                            Screen.Settings.navItem,
-                            Screen.Support.navItem)) }
-                    } else {
-                        {}
-                    }
+                    //TODO refactor
+                    modifier = Modifier
+                        .focusable()
+                        .focusProperties {
+                            when (navBackStackEntry?.destination?.route) {
+                                Screen.Lock.route -> Unit
+                                else -> up = focusRequester
+                            }
+                        },
+                    bottomBar = {
+                        BottomNavBar(
+                            navController,
+                            listOf(
+                                Screen.Main.navItem,
+                                Screen.Settings.navItem,
+                                Screen.Support.navItem,
+                            ),
+                        )
+                    },
                 ) { padding ->
-                    if (vpnIntent != null) {
-                        PermissionRequestFailedScreen(
-                            padding = padding,
-                            onRequestAgain = { vpnActivityResultState.launch(vpnIntent) },
-                            message = getString(R.string.vpn_permission_required),
-                            getString(R.string.retry)
-                        )
-                        return@Scaffold
-                    }
-                    if (!notificationPermissionState.status.isGranted) {
-                        PermissionRequestFailedScreen(
-                            padding = padding,
-                            onRequestAgain = {
-                                val intentSettings =
-                                    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
-                                intentSettings.data =
-                                    Uri.fromParts(
-                                        Constants.URI_PACKAGE_SCHEME,
-                                        this.packageName,
-                                        null
-                                    )
-                                startActivity(intentSettings)
-                            },
-                            message = getString(R.string.notification_permission_required),
-                            getString(R.string.open_settings)
-                        )
-                        return@Scaffold
-                    }
-                    NavHost(navController, startDestination = Screen.Main.route) {
+                    NavHost(
+                        navController,
+                        startDestination =
+                        (if (PinManager.pinExists()) Screen.Lock.route else Screen.Main.route),
+                        modifier =
+                        Modifier
+                            .padding(padding)
+                            .fillMaxSize(),
+                    ) {
                         composable(
                             Screen.Main.route,
                         ) {
-                            MainScreen(padding = padding, focusRequester = focusRequester, showSnackbarMessage = { message ->
-                                showSnackBarMessage(message)
-                            }, navController = navController)
+                            MainScreen(
+                                focusRequester = focusRequester,
+                                appViewModel = appViewModel,
+                                navController = navController,
+                            )
                         }
-                        composable(Screen.Settings.route,
+                        composable(
+                            Screen.Settings.route,
                         ) {
-                            SettingsScreen(padding = padding, showSnackbarMessage = { message ->
-                                showSnackBarMessage(message)
-                            }, focusRequester = focusRequester)
+                            SettingsScreen(
+                                appViewModel = appViewModel,
+                                navController = navController,
+                                focusRequester = focusRequester,
+                            )
                         }
-                        composable(Screen.Support.route,
+                        composable(
+                            Screen.Support.route,
                         ) {
-                            SupportScreen(padding = padding, focusRequester = focusRequester,
-                                showSnackbarMessage = { message ->
-                                    showSnackBarMessage(message)
-                                })
+                            SupportScreen(
+                                focusRequester = focusRequester,
+                                appViewModel = appViewModel,
+                                navController = navController,
+                            )
                         }
-                        composable("${Screen.Config.route}/{id}") {
+                        composable(Screen.Support.Logs.route) {
+                            LogsScreen()
+                        }
+                        composable(
+                            "${Screen.Config.route}/{id}?configType={configType}",
+                            arguments =
+                            listOf(
+                                navArgument("id") {
+                                    type = NavType.StringType
+                                    defaultValue = "0"
+                                },
+                                navArgument("configType") {
+                                    type = NavType.StringType
+                                    defaultValue = ConfigType.WIREGUARD.name
+                                },
+                            ),
+                        ) {
                             val id = it.arguments?.getString("id")
+                            val configType = ConfigType.valueOf(
+                                it.arguments?.getString("configType") ?: ConfigType.WIREGUARD.name,
+                            )
                             if (!id.isNullOrBlank()) {
-                                //https://dagger.dev/hilt/view-model#assisted-injection
                                 ConfigScreen(
                                     navController = navController,
-                                    id = id,
-                                    showSnackbarMessage = { message ->
-                                        showSnackBarMessage(message)
-                                    },
-                                    focusRequester = focusRequester
+                                    tunnelId = id,
+                                    appViewModel = appViewModel,
+                                    focusRequester = focusRequester,
+                                    configType = configType,
                                 )
                             }
                         }
+                        composable("${Screen.Option.route}/{id}") {
+                            val id = it.arguments?.getString("id")
+                            if (!id.isNullOrBlank()) {
+                                OptionsScreen(
+                                    navController = navController,
+                                    tunnelId = id,
+                                    appViewModel = appViewModel,
+                                    focusRequester = focusRequester,
+                                )
+                            }
+                        }
+                        composable(Screen.Lock.route) {
+                            PinLockScreen(
+                                navController = navController,
+                                appViewModel = appViewModel,
+                            )
+                        }
                     }
                 }
             }

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

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

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

@@ -10,8 +10,6 @@ import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.res.stringResource
-import com.zaneschepke.wireguardautotunnel.R
 
 @Composable
 fun ClickableIconButton(
@@ -23,19 +21,22 @@ fun ClickableIconButton(
 ) {
     TextButton(
         onClick = onClick,
-        enabled = enabled
+        enabled = enabled,
     ) {
         Text(text, Modifier.weight(1f, false))
         Spacer(modifier = Modifier.size(ButtonDefaults.IconSpacing))
         Icon(
             imageVector = icon,
-            contentDescription = stringResource(R.string.delete),
+            contentDescription = icon.name,
             modifier =
-            Modifier.size(ButtonDefaults.IconSize).weight(1f, false).clickable {
-                if (enabled) {
-                    onIconClick()
-                }
-            }
+            Modifier
+                .size(ButtonDefaults.IconSize)
+                .weight(1f, false)
+                .clickable {
+                    if (enabled) {
+                        onIconClick()
+                    }
+                },
         )
     }
 }

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

@@ -1,43 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import kotlinx.coroutines.launch
-
-@Composable
-fun PermissionRequestFailedScreen(
-    padding: PaddingValues,
-    onRequestAgain: () -> Unit,
-    message: String,
-    buttonText: String
-) {
-    val scope = rememberCoroutineScope()
-    Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center,
-        modifier =
-        Modifier
-            .fillMaxSize()
-            .padding(padding)
-    ) {
-        Text(message, textAlign = TextAlign.Center, modifier = Modifier.padding(15.dp))
-        Button(onClick = {
-            scope.launch {
-                onRequestAgain()
-            }
-        }) {
-            Text(buttonText)
-        }
-    }
-}

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

@@ -15,9 +15,10 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import com.wireguard.android.backend.Statistics
+import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.toThreeDecimalPlaceString
 
@@ -30,7 +31,7 @@ fun RowListItem(
     onClick: () -> Unit,
     rowButton: @Composable () -> Unit,
     expanded: Boolean,
-    statistics: Statistics?
+    statistics: TunnelStatistics?
 ) {
     Box(
         modifier =
@@ -38,45 +39,41 @@ fun RowListItem(
             .animateContentSize()
             .clip(RoundedCornerShape(30.dp))
             .combinedClickable(
-                onClick = {
-                    onClick()
-                },
-                onLongClick = {
-                    onHold()
-                }
-            )
+                onClick = { onClick() },
+                onLongClick = { onHold() },
+            ),
     ) {
         Column {
             Row(
-                modifier =
-                Modifier
+                modifier = Modifier
                     .fillMaxWidth()
                     .padding(horizontal = 15.dp, vertical = 5.dp),
                 verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween
+                horizontalArrangement = Arrangement.SpaceBetween,
             ) {
                 Row(
                     verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth(.60f)
+                    modifier = Modifier.fillMaxWidth(13 / 20f),
                 ) {
                     icon()
-                    Text(text)
+                    Text(text, maxLines = 1, overflow = TextOverflow.Ellipsis)
                 }
                 rowButton()
             }
             if (expanded) {
-                statistics?.peers()?.forEach {
+                statistics?.getPeers()?.forEach {
                     Row(
                         modifier =
                         Modifier
                             .fillMaxWidth()
                             .padding(end = 10.dp, bottom = 10.dp, start = 10.dp),
                         verticalAlignment = Alignment.CenterVertically,
-                        horizontalArrangement = Arrangement.SpaceEvenly
+                        horizontalArrangement = Arrangement.SpaceEvenly,
                     ) {
-                        val handshakeEpoch = statistics.peer(it)!!.latestHandshakeEpochMillis
-                        val peerTx = statistics.peer(it)!!.txBytes
-                        val peerRx = statistics.peer(it)!!.rxBytes
+                        //TODO change these to string resources
+                        val handshakeEpoch = statistics.peerStats(it)!!.latestHandshakeEpochMillis
+                        val peerTx = statistics.peerStats(it)!!.txBytes
+                        val peerRx = statistics.peerStats(it)!!.rxBytes
                         val peerId = it.toBase64().subSequence(0, 3).toString() + "***"
                         val handshakeSec =
                             NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch)

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

@@ -44,19 +44,21 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
             onQuery(onQueryChanged)
         },
         leadingIcon = {
+            val icon = Icons.Rounded.Search
             Icon(
-                imageVector = Icons.Rounded.Search,
+                imageVector = icon,
                 tint = MaterialTheme.colorScheme.onBackground,
-                contentDescription = stringResource(id = R.string.search_icon)
+                contentDescription = icon.name,
             )
         },
         trailingIcon = {
             if (showClearIcon) {
                 IconButton(onClick = { query = "" }) {
+                    val icon = Icons.Rounded.Clear
                     Icon(
-                        imageVector = Icons.Rounded.Clear,
+                        imageVector = icon,
                         tint = MaterialTheme.colorScheme.onBackground,
-                        contentDescription = stringResource(id = R.string.clear_icon)
+                        contentDescription = icon.name,
                     )
                 }
             }
@@ -66,7 +68,7 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
         TextFieldDefaults.colors(
             focusedContainerColor = Color.Transparent,
             unfocusedContainerColor = Color.Transparent,
-            disabledContainerColor = Color.Transparent
+            disabledContainerColor = Color.Transparent,
         ),
         placeholder = { Text(text = stringResource(R.string.hint_search_packages)) },
         textStyle = MaterialTheme.typography.bodySmall,
@@ -75,6 +77,6 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
         modifier =
         Modifier
             .fillMaxWidth()
-            .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape)
+            .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape),
     )
 }

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

@@ -22,19 +22,15 @@ fun ConfigurationTextBox(
         modifier = modifier,
         value = value,
         singleLine = true,
-        onValueChange = {
-            onValueChange(it)
-        },
+        onValueChange = { onValueChange(it) },
         label = { Text(label) },
         maxLines = 1,
-        placeholder = {
-            Text(hint)
-        },
+        placeholder = { Text(hint) },
         keyboardOptions =
         KeyboardOptions(
             capitalization = KeyboardCapitalization.None,
-            imeAction = ImeAction.Done
+            imeAction = ImeAction.Done,
         ),
-        keyboardActions = keyboardActions
+        keyboardActions = keyboardActions,
     )
 }

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

@@ -9,6 +9,7 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.Dp
 
 @Composable
@@ -21,21 +22,26 @@ fun ConfigurationToggle(
     modifier: Modifier = Modifier
 ) {
     Row(
-        modifier =
-        Modifier
+        modifier = Modifier
             .fillMaxWidth()
             .padding(padding),
         verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.SpaceBetween
+        horizontalArrangement = Arrangement.SpaceBetween,
     ) {
-        Text(label)
+        Text(
+            label, textAlign = TextAlign.Start,
+            modifier = Modifier
+                .weight(
+                    weight = 1.0f,
+                    fill = false,
+                ),
+            softWrap = true,
+        )
         Switch(
             modifier = modifier,
             enabled = enabled,
             checked = checked,
-            onCheckedChange = {
-                onCheckChanged()
-            }
+            onCheckedChange = { onCheckChanged() },
         )
     }
 }

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

@@ -6,21 +6,33 @@ import androidx.compose.material3.NavigationBar
 import androidx.compose.material3.NavigationBarItem
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
 import androidx.navigation.NavController
 import androidx.navigation.compose.currentBackStackEntryAsState
+import com.zaneschepke.wireguardautotunnel.ui.Screen
 
 @Composable
-fun BottomNavBar(
-    navController: NavController,
-    bottomNavItems: List<BottomNavItem>
-) {
+fun BottomNavBar(navController: NavController, bottomNavItems: List<BottomNavItem>) {
     val backStackEntry = navController.currentBackStackEntryAsState()
 
+    var showBottomBar by rememberSaveable { mutableStateOf(true) }
+    val navBackStackEntry by navController.currentBackStackEntryAsState()
+
+    //TODO find a better way to hide nav bar
+    showBottomBar = when (navBackStackEntry?.destination?.route) {
+        Screen.Lock.route -> false
+        else -> true
+    }
+
     NavigationBar(
-        containerColor = MaterialTheme.colorScheme.background
+        containerColor = if (!showBottomBar) Color.Transparent else MaterialTheme.colorScheme.background,
     ) {
-        bottomNavItems.forEach { item ->
+        if (showBottomBar) bottomNavItems.forEach { item ->
             val selected = item.route == backStackEntry.value?.destination?.route
 
             NavigationBarItem(
@@ -29,15 +41,15 @@ fun BottomNavBar(
                 label = {
                     Text(
                         text = item.name,
-                        fontWeight = FontWeight.SemiBold
+                        fontWeight = FontWeight.SemiBold,
                     )
                 },
                 icon = {
                     Icon(
                         imageVector = item.icon,
-                        contentDescription = "${item.name} Icon"
+                        contentDescription = "${item.name} Icon",
                     )
-                }
+                },
             )
         }
     }

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

@@ -11,51 +11,46 @@ import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentActivity
 
 @Composable
-fun AuthorizationPrompt(
-    onSuccess: () -> Unit,
-    onFailure: () -> Unit,
-    onError: (String) -> Unit
-) {
+fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (String) -> Unit) {
     val context = LocalContext.current
     val biometricManager = BiometricManager.from(context)
     val bio = biometricManager.canAuthenticate(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
-    val isBiometricAvailable =
-        remember {
-            when (bio) {
-                BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
-                    onError("Biometrics not available")
-                    false
-                }
-
-                BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> {
-                    onError("Biometrics not created")
-                    false
-                }
-
-                BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> {
-                    onError("Biometric hardware not found")
-                    false
-                }
-
-                BiometricManager.BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED -> {
-                    onError("Biometric security update required")
-                    false
-                }
-
-                BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED -> {
-                    onError("Biometrics not supported")
-                    false
-                }
-
-                BiometricManager.BIOMETRIC_STATUS_UNKNOWN -> {
-                    onError("Biometrics status unknown")
-                    false
-                }
-
-                BiometricManager.BIOMETRIC_SUCCESS -> true
-                else -> false
+    val isBiometricAvailable = remember {
+        when (bio) {
+            BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
+                onError("Biometrics not available")
+                false
             }
+
+            BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> {
+                onError("Biometrics not created")
+                false
+            }
+
+            BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> {
+                onError("Biometric hardware not found")
+                false
+            }
+
+            BiometricManager.BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED -> {
+                onError("Biometric security update required")
+                false
+            }
+
+            BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED -> {
+                onError("Biometrics not supported")
+                false
+            }
+
+            BiometricManager.BIOMETRIC_STATUS_UNKNOWN -> {
+                onError("Biometrics status unknown")
+                false
+            }
+
+            BiometricManager.BIOMETRIC_SUCCESS -> true
+            else -> false
         }
+    }
     if (isBiometricAvailable) {
         val executor = remember { ContextCompat.getMainExecutor(context) }
 
@@ -71,10 +66,7 @@ fun AuthorizationPrompt(
                 context as FragmentActivity,
                 executor,
                 object : BiometricPrompt.AuthenticationCallback() {
-                    override fun onAuthenticationError(
-                        errorCode: Int,
-                        errString: CharSequence
-                    ) {
+                    override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
                         super.onAuthenticationError(errorCode, errString)
                         onFailure()
                     }
@@ -90,7 +82,7 @@ fun AuthorizationPrompt(
                         super.onAuthenticationFailed()
                         onFailure()
                     }
-                }
+                },
             )
         biometricPrompt.authenticate(promptInfo)
     }

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

@@ -19,12 +19,9 @@ import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
-import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 
 @Composable
@@ -33,29 +30,32 @@ fun CustomSnackBar(
     isRtl: Boolean = true,
     containerColor: Color = MaterialTheme.colorScheme.surface
 ) {
-    val context = LocalContext.current
     Snackbar(
         containerColor = containerColor,
         modifier =
-        Modifier.fillMaxWidth(
-            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) 1 / 3f else 2 / 3f
-        ).padding(bottom = 100.dp),
-        shape = RoundedCornerShape(16.dp)
+        Modifier
+            .fillMaxWidth(
+                if (WireGuardAutoTunnel.isRunningOnAndroidTv()) 1 / 3f else 2 / 3f,
+            )
+            .padding(bottom = 100.dp),
+        shape = RoundedCornerShape(16.dp),
     ) {
         CompositionLocalProvider(
-            LocalLayoutDirection provides
-                    if (isRtl) LayoutDirection.Rtl else LayoutDirection.Ltr
+            LocalLayoutDirection provides if (isRtl) LayoutDirection.Rtl else LayoutDirection.Ltr,
         ) {
             Row(
-                modifier = Modifier.width(IntrinsicSize.Max).height(IntrinsicSize.Min),
+                modifier = Modifier
+                    .width(IntrinsicSize.Max)
+                    .height(IntrinsicSize.Min),
                 verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.Start
+                horizontalArrangement = Arrangement.Start,
             ) {
+                val icon = Icons.Rounded.Info
                 Icon(
-                    Icons.Rounded.Info,
-                    contentDescription = stringResource(R.string.info),
+                    icon,
+                    contentDescription = icon.name,
                     tint = Color.White,
-                    modifier = Modifier.padding(end = 10.dp)
+                    modifier = Modifier.padding(end = 10.dp),
                 )
                 Text(message, color = Color.White, modifier = Modifier.padding(end = 5.dp))
             }

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

@@ -13,10 +13,14 @@ import androidx.compose.ui.unit.dp
 
 @Composable
 fun LoadingScreen() {
-  Column(
-      horizontalAlignment = Alignment.CenterHorizontally,
-      verticalArrangement = Arrangement.Top,
-      modifier = Modifier.fillMaxSize().focusable().padding()) {
-          Column(modifier = Modifier.padding(120.dp)) { CircularProgressIndicator() }
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Top,
+        modifier = Modifier
+            .fillMaxSize()
+            .focusable()
+            .padding(),
+    ) {
+        Column(modifier = Modifier.padding(120.dp)) { CircularProgressIndicator() }
     }
 }

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

@@ -0,0 +1,25 @@
+package com.zaneschepke.wireguardautotunnel.ui.common.text
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun LogTypeLabel(color: Color, content: @Composable () -> Unit) {
+    Box(
+        modifier = Modifier
+            .size(20.dp)
+            .clip(RoundedCornerShape(2.dp))
+            .background(color),
+        contentAlignment = Alignment.Center,
+    ) {
+        content()
+    }
+}

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

@@ -12,14 +12,11 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 
 @Composable
-fun SectionTitle(
-    title: String,
-    padding: Dp
-) {
+fun SectionTitle(title: String, padding: Dp) {
     Text(
         title,
-        textAlign = TextAlign.Center,
+        textAlign = TextAlign.Start,
         style = TextStyle(fontSize = 18.sp, fontWeight = FontWeight.ExtraBold),
-        modifier = Modifier.padding(padding, bottom = 5.dp, top = 5.dp)
+        modifier = Modifier.padding(padding, bottom = 5.dp, top = 5.dp),
     )
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/models/InterfaceProxy.kt

@@ -1,30 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.models
-
-import com.wireguard.config.Interface
-
-data class InterfaceProxy(
-    var privateKey: String = "",
-    var publicKey: String = "",
-    var addresses: String = "",
-    var dnsServers: String = "",
-    var listenPort: String = "",
-    var mtu: String = ""
-) {
-    companion object {
-        fun from(i: Interface): InterfaceProxy {
-            return InterfaceProxy(
-                publicKey = i.keyPair.publicKey.toBase64().trim(),
-                privateKey = i.keyPair.privateKey.toBase64().trim(),
-                addresses = i.addresses.joinToString(", ").trim(),
-                dnsServers = i.dnsServers.joinToString(", ").replace("/", "").trim(),
-                listenPort = if (i.listenPort.isPresent) {
-                    i.listenPort.get().toString()
-                    .trim()
-                } else {
-                    ""
-                },
-                mtu = if (i.mtu.isPresent) i.mtu.get().toString().trim() else ""
-            )
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/models/PeerProxy.kt

@@ -1,49 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.models
-
-import com.wireguard.config.Peer
-
-data class PeerProxy(
-    var publicKey: String = "",
-    var preSharedKey: String = "",
-    var persistentKeepalive: String = "",
-    var endpoint: String = "",
-    var allowedIps: String = IPV4_WILDCARD.joinToString(", ").trim()
-) {
-    companion object {
-        fun from(peer: Peer): PeerProxy {
-            return PeerProxy(
-                publicKey = peer.publicKey.toBase64(),
-                preSharedKey = if (peer.preSharedKey.isPresent) {
-                    peer.preSharedKey.get().toBase64()
-                    .trim()
-                } else {
-                    ""
-                },
-                persistentKeepalive = if (peer.persistentKeepalive.isPresent) {
-                    peer.persistentKeepalive.get()
-                    .toString().trim()
-                } else {
-                    ""
-                },
-                endpoint = if (peer.endpoint.isPresent) {
-                    peer.endpoint.get().toString()
-                    .trim()
-                } else {
-                    ""
-                },
-                allowedIps = peer.allowedIps.joinToString(", ").trim()
-            )
-        }
-
-        val IPV4_PUBLIC_NETWORKS =
-            setOf(
-                "0.0.0.0/5", "8.0.0.0/7", "11.0.0.0/8", "12.0.0.0/6", "16.0.0.0/4", "32.0.0.0/3",
-                "64.0.0.0/2", "128.0.0.0/3", "160.0.0.0/5", "168.0.0.0/6", "172.0.0.0/12",
-                "172.32.0.0/11", "172.64.0.0/10", "172.128.0.0/9", "173.0.0.0/8", "174.0.0.0/7",
-                "176.0.0.0/4", "192.0.0.0/9", "192.128.0.0/11", "192.160.0.0/13", "192.169.0.0/16",
-                "192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10",
-                "193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6", "200.0.0.0/5", "208.0.0.0/4"
-            )
-        val IPV4_WILDCARD = setOf("0.0.0.0/0")
-    }
-}