feat: auto-tunneling flexibility

.editorconfig

@@ -1,14 +1,8 @@
-root = true
-
-[*]
-charset = utf-8
-indent_size = 4
-indent_style = tab
-max_line_length = 150
-trim_trailing_whitespace = true
-insert_final_newline = true
-
 [{*.kt,*.kts}]
+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
@@ -17,6 +11,8 @@ 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
@@ -24,7 +20,10 @@ ij_kotlin_blank_lines_before_declaration_with_comment_or_annotation_on_separate_
 ij_kotlin_block_comment_at_first_column = true
 ij_kotlin_call_parameters_new_line_after_left_paren = true
 ij_kotlin_call_parameters_right_paren_on_new_line = false
+ij_kotlin_call_parameters_wrap = on_every_item
 ij_kotlin_catch_on_new_line = false
+ij_kotlin_class_annotation_wrap = split_into_lines
+ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
 ij_kotlin_continuation_indent_for_chained_calls = true
 ij_kotlin_continuation_indent_for_expression_bodies = true
 ij_kotlin_continuation_indent_in_argument_lists = true
@@ -53,6 +52,7 @@ ij_kotlin_method_annotation_wrap = split_into_lines
 ij_kotlin_method_call_chain_wrap = normal
 ij_kotlin_method_parameters_new_line_after_left_paren = true
 ij_kotlin_method_parameters_right_paren_on_new_line = true
+ij_kotlin_method_parameters_wrap = on_every_item
 ij_kotlin_name_count_to_use_star_import = 9999
 ij_kotlin_name_count_to_use_star_import_for_members = 9999
 ij_kotlin_parameter_annotation_wrap = off
@@ -83,15 +83,3 @@ ij_kotlin_while_on_new_line = false
 ij_kotlin_wrap_elvis_expressions = 1
 ij_kotlin_wrap_expression_body_functions = 1
 ij_kotlin_wrap_first_method_in_call_chain = false
-#compose
-ktlint_standard_filename = disabled
-ktlint_standard_no-wildcard-imports = disabled
-ktlint_standard_function-naming = disabled
-ktlint_standard_property-naming = disabled
-ktlint_standard_package-naming = disabled
-ktlint_function_naming_ignore_when_annotated_with = Composable
-ktlint_code_style = android_studio
-ktlint_standard_import-ordering = disabled
-ktlint_standard_package-naming = disabled
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true

.github/CODE_OF_CONDUCT.md

@@ -1,22 +0,0 @@
-# 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/workflows/ci.yml

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

.github/workflows/issue-workflow.yml

@@ -1,20 +0,0 @@
-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

@@ -0,0 +1,99 @@
+# name of the workflow
+name: Android CI Tag Deployment (Pre-release)
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - '*.*.*-**'
+
+jobs:
+  build:
+    name: Build Signed APK
+
+    runs-on: ubuntu-latest
+
+    env:
+      SIGNING_KEY_ALIAS: ${{ secrets.SIGNING_KEY_ALIAS }}
+      SIGNING_KEY_PASSWORD: ${{ secrets.SIGNING_KEY_PASSWORD }}
+      SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
+      KEY_STORE_FILE: 'android_keystore.jks'
+      KEY_STORE_LOCATION: ${{ github.workspace }}/app/keystore/
+      GH_USER: ${{ secrets.GH_USER }}
+      GH_TOKEN: ${{ secrets.GH_TOKEN }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+          cache: gradle
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      # Here we need to decode keystore.jks from base64 string and place it
+      # in the folder specified in the release signing configuration
+      - name: Decode Keystore
+        id: decode_keystore
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: ${{ env.KEY_STORE_FILE }}
+          fileDir: ${{ env.KEY_STORE_LOCATION }}
+          encodedString: ${{ secrets.KEYSTORE }}
+
+      # create keystore path for gradle to read
+      - name: Create keystore path env var
+        run: |
+          store_path=${{ env.KEY_STORE_LOCATION }}${{ env.KEY_STORE_FILE }}
+          echo "KEY_STORE_PATH=$store_path" >> $GITHUB_ENV
+
+      - name: Create service_account.json
+        id: createServiceAccount
+        run: echo '${{ secrets.SERVICE_ACCOUNT_JSON }}' > service_account.json
+
+      # Build and sign APK ("-x test" argument is used to skip tests)
+      # add fdroid flavor for apk upload
+      - name: Build Fdroid Release APK
+        run: ./gradlew :app:assembleFdroidRelease -x test
+
+      # get fdroid flavor release apk path
+      - name: Get apk path
+        id: apk-path
+        run: echo "path=$(find . -regex '^.*/build/outputs/apk/fdroid/release/.*\.apk$' -type f | head -1)" >> $GITHUB_OUTPUT
+      - name: Get version code
+        run: |
+          version_code=$(grep "VERSION_CODE" buildSrc/src/main/kotlin/Constants.kt | awk '{print $5}' | tr -d '\n')
+          echo "VERSION_CODE=$version_code" >> $GITHUB_ENV
+      # Save the APK after the Build job is complete to publish it as a Github release in the next job
+      - name: Upload APK
+        uses: actions/upload-artifact@v4.3.1
+        with:
+          name: wgtunnel
+          path: ${{ steps.apk-path.outputs.path }}
+      - name: Download APK from build
+        uses: actions/download-artifact@v4
+        with:
+          name: wgtunnel
+      - name: Create Release with Fastlane changelog notes
+        id: create_release
+        uses: softprops/action-gh-release@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          # fix hardcode changelog file name
+          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/${{ env.VERSION_CODE }}.txt
+          tag_name: ${{ github.ref_name }}
+          name: ${{ github.ref_name }}
+          draft: false
+          prerelease: true
+          files: ${{ github.workspace }}/${{ steps.apk-path.outputs.path }}
+      - name: 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

@@ -1,21 +0,0 @@
-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

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

README.md

@@ -4,9 +4,8 @@ WG Tunnel
 
 <div align="center">
 
-[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/rbRRNh6H7V)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![X Community](https://img.shields.io/badge/X-000000?style=for-the-badge&logo=x&logoColor=white)](https://twitter.com/i/communities/1780655267685736818)
+[![Discord Chat](https://img.shields.io/discord/1108285024631001111.svg)](https://discord.gg/rbRRNh6H7V)
-[![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/wgtunnel)
 
 </div>
 
@@ -22,8 +21,7 @@ WG Tunnel
 
 <div align="left">
 
-This is an alternative Android Application for [WireGuard](https://www.wireguard.com/)
+This is an alternative Android Application for [WireGuard](https://www.wireguard.com/) with added
-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.
@@ -51,42 +49,24 @@ and on while on different networks. This app was created to offer a free solutio
 ## Features
 
 * Add tunnels via .conf file, zip, manual entry, or QR code
-* Auto connect to tunnels based on Wi-Fi SSID, ethernet, or mobile data
+* Auto connect to VPN based on Wi-Fi SSID, ethernet, or mobile data
 * Split tunneling by application with search
 * WireGuard support for kernel and userspace modes
-* Amnezia support for userspace mode for DPI/censorship protection
 * Always-On VPN support
-* Export Amnezia and WireGuard tunnels to zip
+* Export tunnels to zip
-* Quick tile support for tunnel toggling, auto-tunneling
+* Quick tile support for VPN toggling
-* Static shortcuts support for tunnel toggling, auto-tunneling
+* Static shortcuts support for primary tunnel for automation integration
 * Intent automation support for all tunnels
-* Automatic auto-tunneling service restart after reboot
+* Automatic service restart after reboot
-* Automatic tunnel restart after reboot
 * Battery preservation measures
-* Restart tunnel on ping failure (beta)
 
-## Fdroid
+## Docs (WIP)
 
-Want updates faster?
+Basic documentation of the feature and behaviors of this app can be
-
+found [here](https://zaneschepke.com/wgtunnel-docs/overview.html).
-Check out my personal [fdroid repository](https://github.com/zaneschepke/fdroid) to get updates the
-moment they are released.
-
-## Docs
-
-Information about features, behaviors, and answers to common questions can be found in the
-app [documentation](https://zaneschepke.com/wgtunnel-docs/overview.html).
 
 The repository for these docs can be found [here](https://github.com/zaneschepke/wgtunnel-docs).
 
-## Translation
-
-This app is using [Weblate](https://weblate.org) to assist with translations.
-
-Help translate WG Tunnel into your language
-at [Hosted Weblate](https://hosted.weblate.org/engage/wg-tunnel/).\
-[![Translation status](https://hosted.weblate.org/widgets/wg-tunnel/-/multi-auto.svg)](https://hosted.weblate.org/engage/wg-tunnel/)
-
 ## Building
 
 ```
@@ -100,11 +80,4 @@ And then build the app:
 $ ./gradlew assembleDebug
 ```
 
-## Contributing
+</span>
-
-Any contributions in the form of feedback, issues, code, or translations are welcome and much
-appreciated!
-
-Please read
-the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct)
-before contributing.

SECURITY.md

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

app/build.gradle.kts

@@ -1,27 +1,23 @@
+import java.util.Properties
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.hilt.android)
     alias(libs.plugins.kotlinxSerialization)
     alias(libs.plugins.ksp)
-	alias(libs.plugins.compose.compiler)
-	alias(libs.plugins.grgit)
 }
 
 android {
     namespace = Constants.APP_ID
     compileSdk = Constants.TARGET_SDK
 
-	androidResources {
-		generateLocaleConfig = true
-	}
-
     defaultConfig {
         applicationId = Constants.APP_ID
         minSdk = Constants.MIN_SDK
         targetSdk = Constants.TARGET_SDK
-		versionCode = determineVersionCode()
+        versionCode = Constants.VERSION_CODE
-		versionName = determineVersionName()
+        versionName = Constants.VERSION_NAME
 
         ksp { arg("room.schemaLocation", "$projectDir/schemas") }
 
@@ -29,16 +25,52 @@ android {
             getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
         }
 
+        resourceConfigurations.addAll(listOf("en"))
+
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables { useSupportLibrary = true }
     }
 
     signingConfigs {
         create(Constants.RELEASE) {
-			storeFile = getStoreFile()
+            val properties =
-			storePassword = getSigningProperty(Constants.STORE_PASS_VAR)
+                Properties().apply {
-			keyAlias = getSigningProperty(Constants.KEY_ALIAS_VAR)
+                    // created local file for signing details
-			keyPassword = getSigningProperty(Constants.KEY_PASS_VAR)
+                    try {
+                        load(file("signing.properties").reader())
+                    } catch (_: Exception) {
+                        load(file("signing_template.properties").reader())
+                    }
+                }
+
+            // try to get secrets from env first for pipeline build, then properties file for local
+            // 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),
+                    )
         }
     }
 
@@ -48,6 +80,16 @@ android {
             listOf("libwg-go.so", "libwg-quick.so", "libwg.so"),
         )
 
+        applicationVariants.all {
+            val variant = this
+            variant.outputs
+                .map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
+                .forEach { output ->
+                    val outputFileName =
+                        "${Constants.APP_NAME}-${variant.flavorName}-${variant.buildType.name}-${variant.versionName}.apk"
+                    output.outputFileName = outputFileName
+                }
+        }
         release {
             isDebuggable = false
             isMinifyEnabled = true
@@ -59,26 +101,6 @@ android {
             signingConfig = signingConfigs.getByName(Constants.RELEASE)
         }
         debug { isDebuggable = true }
-
-		create(Constants.PRERELEASE) {
-			initWith(buildTypes.getByName(Constants.RELEASE))
-		}
-
-		create(Constants.NIGHTLY) {
-			initWith(buildTypes.getByName(Constants.RELEASE))
-		}
-
-		applicationVariants.all {
-			val variant = this
-			variant.outputs
-				.map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
-				.forEach { output ->
-					val outputFileName =
-						"${Constants.APP_NAME}-${variant.flavorName}-" +
-							"${variant.buildType.name}-${variant.versionName}.apk"
-					output.outputFileName = outputFileName
-				}
-		}
     }
     flavorDimensions.add(Constants.TYPE)
     productFlavors {
@@ -88,6 +110,9 @@ android {
         }
         create("general") {
             dimension = Constants.TYPE
+            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
+                //any plugins general specific
+            }
         }
     }
     compileOptions {
@@ -100,6 +125,7 @@ android {
         compose = true
         buildConfig = true
     }
+    composeOptions { kotlinCompilerExtensionVersion = Constants.COMPOSE_COMPILER_EXTENSION_VERSION }
     packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
@@ -111,7 +137,6 @@ dependencies {
 
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)
-
     // helpers for implementing LifecycleOwner in a Service
     implementation(libs.androidx.lifecycle.service)
     implementation(libs.androidx.activity.compose)
@@ -135,18 +160,16 @@ dependencies {
 
     // 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)
@@ -174,6 +197,7 @@ dependencies {
 
     // barcode scanning
     implementation(libs.zxing.android.embedded)
+    implementation(libs.zxing.core)
 
     // bio
     implementation(libs.androidx.biometric.ktx)
@@ -182,28 +206,4 @@ dependencies {
     // shortcuts
     implementation(libs.androidx.core)
     implementation(libs.androidx.core.google.shortcuts)
-
-	// splash
-	implementation(libs.androidx.core.splashscreen)
-}
-
-fun determineVersionCode(): Int {
-	return with(getBuildTaskName().lowercase()) {
-		when {
-			contains(Constants.NIGHTLY) -> Constants.VERSION_CODE + Constants.NIGHTLY_CODE
-			contains(Constants.PRERELEASE) -> Constants.VERSION_CODE + Constants.PRERELEASE_CODE
-			else -> Constants.VERSION_CODE
-		}
-	}
-}
-
-fun determineVersionName(): String {
-	return with(getBuildTaskName().lowercase()) {
-		when {
-			contains(Constants.NIGHTLY) || contains(Constants.PRERELEASE) ->
-				Constants.VERSION_NAME +
-					"-${grgitService.service.get().grgit.head().abbreviatedId}"
-			else -> Constants.VERSION_NAME
-		}
-	}
 }

app/proguard-rules.pro

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

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

@@ -1,190 +0,0 @@
-{
-  "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/main/AndroidManifest.xml

@@ -51,8 +51,8 @@
     </queries>
     <application
         android:name=".WireGuardAutoTunnel"
-        android:allowBackup="false"
+        android:allowBackup="true"
-        android:banner="@drawable/ic_banner"
+        android:banner="@mipmap/ic_banner"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:enableOnBackInvokedCallback="true"
         android:fullBackupContent="@xml/backup_rules"
@@ -60,17 +60,18 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.AppSplashScreen"
+        android:theme="@style/Theme.WireguardAutoTunnel"
         tools:targetApi="tiramisu">
         <activity
-            android:name=".ui.SplashActivity"
+            android:name=".ui.MainActivity"
             android:exported="true"
-            android:theme="@style/Theme.AppSplashScreen">
+            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" />
             </intent-filter>
             <meta-data
@@ -78,23 +79,17 @@
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
-            android:name=".ui.MainActivity"
+            android:name=".ui.CaptureActivityPortrait"
-            android:exported="true"
+            android:screenOrientation="fullSensor"
-            android:theme="@style/Theme.WireguardAutoTunnel">
+            android:stateNotNeeded="true"
-        </activity>
+            android:theme="@style/zxing_CaptureTheme"
-        <activity
+            android:windowSoftInputMode="stateAlwaysHidden"
-            android:name="com.journeyapps.barcodescanner.CaptureActivity"
+            tools:ignore="DiscouragedApi" />
-            android:screenOrientation="portrait"
-            tools:replace="screenOrientation" />
-
         <activity
             android:name=".service.shortcut.ShortcutsActivity"
             android:enabled="true"
             android:exported="true"
-			android:noHistory="true"
-			android:excludeFromRecents="true"
             android:finishOnTaskLaunch="true"
-			android:launchMode="singleInstance"
             android:theme="@android:style/Theme.NoDisplay" />
 
         <service

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

@@ -2,34 +2,23 @@ package com.zaneschepke.wireguardautotunnel
 
 import android.app.Application
 import android.content.ComponentName
+import android.content.Context
 import android.content.pm.PackageManager
-import android.os.StrictMode
-import android.os.StrictMode.ThreadPolicy
 import android.service.quicksettings.TileService
 import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
 import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
 import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
 import dagger.hilt.android.HiltAndroidApp
 import timber.log.Timber
+import xyz.teamgravity.pin_lock_compose.PinManager
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
     override fun onCreate() {
         super.onCreate()
         instance = this
-		if (BuildConfig.DEBUG) {
+        if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree()) else Timber.plant(ReleaseTree())
-			Timber.plant(Timber.DebugTree())
+        PinManager.initialize(this)
-			StrictMode.setThreadPolicy(
-				ThreadPolicy.Builder()
-					.detectDiskReads()
-					.detectDiskWrites()
-					.detectNetwork()
-					.penaltyLog()
-					.build(),
-			)
-		} else {
-			Timber.plant(ReleaseTree())
-		}
     }
 
     companion object {
@@ -40,16 +29,16 @@ class WireGuardAutoTunnel : Application() {
             return instance.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
         }
 
-		fun requestTunnelTileServiceStateUpdate() {
+        fun requestTunnelTileServiceStateUpdate(context: Context) {
             TileService.requestListeningState(
-				instance,
+                context,
                 ComponentName(instance, TunnelControlTile::class.java),
             )
         }
 
-		fun requestAutoTunnelTileServiceUpdate() {
+        fun requestAutoTunnelTileServiceUpdate(context: Context) {
             TileService.requestListeningState(
-				instance,
+                context,
                 ComponentName(instance, AutoTunnelControlTile::class.java),
             )
         }

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

@@ -6,12 +6,12 @@ import androidx.room.DeleteColumn
 import androidx.room.RoomDatabase
 import androidx.room.TypeConverters
 import androidx.room.migration.AutoMigrationSpec
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 
 @Database(
     entities = [Settings::class, TunnelConfig::class],
-	version = 8,
+    version = 7,
     autoMigrations =
     [
         AutoMigration(from = 1, to = 2),
@@ -33,7 +33,6 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
             to = 7,
             spec = RemoveLegacySettingColumnsMigration::class,
         ),
-		AutoMigration(7, 8),
     ],
     exportSchema = true,
 )

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.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
 import kotlinx.coroutines.flow.Flow
 
 @Dao

app/src/main/java/com/zaneschepke/wireguardautotunnel/data/TunnelConfigDao.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.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
@@ -20,9 +20,6 @@ interface TunnelConfigDao {
     @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(): TunnelConfigs
 
@@ -36,10 +33,10 @@ interface TunnelConfigDao {
     suspend fun findByTunnelNetworkName(name: String): TunnelConfigs
 
     @Query("UPDATE TunnelConfig SET is_primary_tunnel = 0 WHERE is_primary_tunnel =1")
-	suspend fun resetPrimaryTunnel()
+    fun resetPrimaryTunnel()
 
     @Query("UPDATE TunnelConfig SET is_mobile_data_tunnel = 0 WHERE is_mobile_data_tunnel =1")
-	suspend fun resetMobileDataTunnel()
+    fun resetMobileDataTunnel()
 
     @Query("SELECT * FROM TUNNELCONFIG WHERE is_primary_tunnel=1")
     suspend fun findByPrimary(): TunnelConfigs

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

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

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

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

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

@@ -1,58 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/GeneralState.kt

@@ -0,0 +1,14 @@
+package com.zaneschepke.wireguardautotunnel.data.model
+
+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/model/Settings.kt

@@ -0,0 +1,53 @@
+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") 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,
+)

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

@@ -0,0 +1,38 @@
+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 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,
+) {
+    companion object {
+        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

@@ -1,10 +1,9 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 
 interface AppDataRepository {
     suspend fun getPrimaryOrFirstTunnel(): TunnelConfig?
-
     suspend fun getStartTunnelConfig(): TunnelConfig?
 
     suspend fun toggleWatcherServicePause()

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

@@ -1,14 +1,12 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import javax.inject.Inject
 
-class AppDataRoomRepository
+class AppDataRoomRepository @Inject constructor(
-@Inject
-constructor(
     override val settings: SettingsRepository,
     override val tunnels: TunnelConfigRepository,
-	override val appState: AppStateRepository,
+    override val appState: AppStateRepository
 ) : AppDataRepository {
     override suspend fun getPrimaryOrFirstTunnel(): TunnelConfig? {
         return tunnels.findPrimary().firstOrNull() ?: tunnels.getAll().firstOrNull()
@@ -19,9 +17,7 @@ constructor(
             appState.getActiveTunnelId()?.let {
                 tunnels.getById(it)
             }
-		} else {
+        } else null
-			null
-		}
     }
 
     override suspend fun toggleWatcherServicePause() {

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

@@ -1,23 +1,16 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import com.zaneschepke.wireguardautotunnel.data.model.GeneralState
 import kotlinx.coroutines.flow.Flow
 
 interface AppStateRepository {
     suspend fun isLocationDisclosureShown(): Boolean
-
     suspend fun setLocationDisclosureShown(shown: Boolean)
 
-	suspend fun isPinLockEnabled(): Boolean
-
-	suspend fun setPinLockEnabled(enabled: Boolean)
-
     suspend fun isBatteryOptimizationDisableShown(): Boolean
-
     suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
 
     suspend fun isTunnelRunningFromManualStart(): Boolean
-
     suspend fun setTunnelRunningFromManualStart(id: Int)
 
     suspend fun setManualStop()
@@ -29,4 +22,5 @@ interface AppStateRepository {
     suspend fun setCurrentSsid(ssid: String)
 
     val generalStateFlow: Flow<GeneralState>
+
 }

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

@@ -1,7 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
-import com.zaneschepke.wireguardautotunnel.data.domain.GeneralState
+import com.zaneschepke.wireguardautotunnel.data.model.GeneralState
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import timber.log.Timber
@@ -17,15 +17,6 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
         dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown)
     }
 
-	override suspend fun isPinLockEnabled(): Boolean {
-		return dataStoreManager.getFromStore(DataStoreManager.IS_PIN_LOCK_ENABLED)
-			?: GeneralState.PIN_LOCK_ENABLED_DEFAULT
-	}
-
-	override suspend fun setPinLockEnabled(enabled: Boolean) {
-		dataStoreManager.saveToDataStore(DataStoreManager.IS_PIN_LOCK_ENABLED, enabled)
-	}
-
     override suspend fun isBatteryOptimizationDisableShown(): Boolean {
         return dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
             ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
@@ -74,17 +65,11 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
             prefs?.let { pref ->
                 try {
                     GeneralState(
-						isLocationDisclosureShown =
+                        locationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
-						pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
                             ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-						isBatteryOptimizationDisableShown =
+                        batteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
-						pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
                             ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-						isTunnelRunningFromManualStart =
+                        tunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
-						pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
-							?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
-						isPinLockEnabled =
-						pref[DataStoreManager.IS_PIN_LOCK_ENABLED]
                             ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
                     )
                 } catch (e: IllegalArgumentException) {

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

@@ -1,10 +1,11 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.SettingsDao
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
 import kotlinx.coroutines.flow.Flow
 
 class RoomSettingsRepository(private val settingsDoa: SettingsDao) : SettingsRepository {
+
     override suspend fun save(settings: Settings) {
         settingsDoa.save(settings)
     }

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

@@ -1,7 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
 import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
@@ -28,6 +28,7 @@ class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
                 ),
             )
         }
+
     }
 
     override suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?) {
@@ -53,10 +54,6 @@ class RoomTunnelConfigRepository(private val tunnelConfigDao: TunnelConfigDao) :
         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)
     }

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

@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
 import kotlinx.coroutines.flow.Flow
 
 interface SettingsRepository {

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

@@ -1,10 +1,11 @@
 package com.zaneschepke.wireguardautotunnel.data.repository
 
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 import kotlinx.coroutines.flow.Flow
 
 interface TunnelConfigRepository {
+
     fun getTunnelConfigsFlow(): Flow<TunnelConfigs>
 
     suspend fun getAll(): TunnelConfigs
@@ -21,8 +22,6 @@ interface TunnelConfigRepository {
 
     suspend fun count(): Int
 
-	suspend fun findByTunnelName(name: String): TunnelConfig?
-
     suspend fun findByTunnelNetworksName(name: String): TunnelConfigs
 
     suspend fun findByMobileDataTunnel(): TunnelConfigs

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

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

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

@@ -1,27 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

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

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

@@ -0,0 +1,7 @@
+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,10 +1,7 @@
 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
@@ -21,25 +18,11 @@ 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 {
@@ -66,8 +49,8 @@ class RepositoryModule {
 
     @Singleton
     @Provides
-	fun providePreferencesDataStore(@ApplicationContext context: Context, @IoDispatcher ioDispatcher: CoroutineDispatcher): DataStoreManager {
+    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStoreManager {
-		return DataStoreManager(context, ioDispatcher)
+        return DataStoreManager(context)
     }
 
     @Provides
@@ -81,8 +64,10 @@ class RepositoryModule {
     fun provideAppDataRepository(
         settingsRepository: SettingsRepository,
         tunnelConfigRepository: TunnelConfigRepository,
-		appStateRepository: AppStateRepository,
+        appStateRepository: AppStateRepository
     ): AppDataRepository {
         return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
     }
+
+
 }

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

@@ -17,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

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

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

@@ -2,10 +2,6 @@ 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/ViewModelModule.kt

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

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

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

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

@@ -4,14 +4,12 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
@@ -23,15 +21,10 @@ class NotificationActionReceiver : BroadcastReceiver() {
     @Inject
     lateinit var serviceManager: ServiceManager
 
-	@Inject
+    override fun onReceive(context: Context, intent: Intent?) = goAsync {
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
-
-	override fun onReceive(context: Context, intent: Intent?) {
-		applicationScope.launch {
         try {
             //TODO fix for manual start changes when enabled
-				serviceManager.stopVpnServiceForeground(context)
+            serviceManager.stopVpnService(context)
             delay(Constants.TOGGLE_TUNNEL_DELAY)
             serviceManager.startVpnServiceForeground(context)
         } catch (e: Exception) {
@@ -41,4 +34,3 @@ class NotificationActionReceiver : BroadcastReceiver() {
         }
     }
 }
-}

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

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

@@ -23,10 +23,9 @@ open class ForegroundService : LifecycleService() {
             val action = intent.action
             when (action) {
                 Action.START.name,
-				Action.START_FOREGROUND.name,
+                Action.START_FOREGROUND.name -> startService(intent.extras)
-				-> startService(intent.extras)
 
-				Action.STOP.name, Action.STOP_FOREGROUND.name -> stopService()
+                Action.STOP.name -> stopService(intent.extras)
                 Constants.ALWAYS_ON_VPN_ACTION -> {
                     Timber.i("Always-on VPN starting service")
                     startService(intent.extras)
@@ -39,19 +38,29 @@ open class ForegroundService : LifecycleService() {
                 "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() {
+    protected open fun stopService(extras: Bundle?) {
         Timber.d("Stopping ${this.javaClass.simpleName}")
+        try {
             stopForeground(STOP_FOREGROUND_REMOVE)
             stopSelf()
+        } catch (e: Exception) {
+            Timber.e(e)
+        }
         isServiceStarted = false
     }
 }

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

@@ -4,17 +4,17 @@ import android.app.Service
 import android.content.Context
 import android.content.Intent
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.withContext
 import timber.log.Timber
 
-class ServiceManager(
+class ServiceManager(private val appDataRepository: AppDataRepository) {
-	private val appDataRepository: AppDataRepository,
+
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
+    private fun <T : Service> actionOnService(
+        action: Action,
+        context: Context,
+        cls: Class<T>,
+        extras: Map<String, Int>? = null
     ) {
-	private fun <T : Service> actionOnService(action: Action, context: Context, cls: Class<T>, extras: Map<String, Int>? = null) {
         val intent =
             Intent(context, cls).also {
                 it.action = action.name
@@ -23,19 +23,26 @@ class ServiceManager(
         intent.component?.javaClass
         try {
             when (action) {
-				Action.START_FOREGROUND, Action.STOP_FOREGROUND ->
+                Action.START_FOREGROUND -> {
-					context.startForegroundService(
+                    context.startForegroundService(intent)
-						intent,
+                }
-					)
 
-				Action.START, Action.STOP -> context.startService(intent)
+                Action.START -> {
+                    context.startService(intent)
+                }
+
+                Action.STOP -> context.startService(intent)
             }
         } catch (e: Exception) {
             Timber.e(e.message)
         }
     }
 
-	suspend fun startVpnService(context: Context, tunnelId: Int? = null, isManualStart: Boolean = false) {
+    suspend fun startVpnService(
+        context: Context,
+        tunnelId: Int? = null,
+        isManualStart: Boolean = false
+    ) {
         if (isManualStart) onManualStart(tunnelId)
         actionOnService(
             Action.START,
@@ -45,29 +52,15 @@ class ServiceManager(
         )
     }
 
-	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,
-			)
-		}
-	}
-
     suspend fun stopVpnService(context: Context, isManualStop: Boolean = false) {
-		withContext(ioDispatcher) {
         if (isManualStop) onManualStop()
-			Timber.i("Stopping vpn service")
+        Timber.d("Stopping vpn service action")
         actionOnService(
             Action.STOP,
             context,
             WireGuardTunnelService::class.java,
         )
     }
-	}
 
     private suspend fun onManualStop() {
         appDataRepository.appState.setManualStop()
@@ -79,8 +72,11 @@ class ServiceManager(
         }
     }
 
-	suspend fun startVpnServiceForeground(context: Context, tunnelId: Int? = null, isManualStart: Boolean = false) {
+    suspend fun startVpnServiceForeground(
-		withContext(ioDispatcher) {
+        context: Context,
+        tunnelId: Int? = null,
+        isManualStart: Boolean = false
+    ) {
         if (isManualStart) onManualStart(tunnelId)
         actionOnService(
             Action.START_FOREGROUND,
@@ -89,9 +85,10 @@ class ServiceManager(
             tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
         )
     }
-	}
 
-	fun startWatcherServiceForeground(context: Context) {
+    fun startWatcherServiceForeground(
+        context: Context,
+    ) {
         actionOnService(
             Action.START_FOREGROUND,
             context,

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

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

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

@@ -1,73 +1,84 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground
 
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.wireguard.android.backend.Tunnel
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 
 data class WatcherState(
     val isWifiConnected: Boolean = false,
+    val config: TunnelConfig? = null,
+    val vpnStatus: Tunnel.State = Tunnel.State.DOWN,
     val isEthernetConnected: Boolean = false,
     val isMobileDataConnected: Boolean = false,
     val currentNetworkSSID: String = "",
-	val settings: Settings = Settings(),
+    val settings: Settings = Settings()
 ) {
+
+    private fun isVpnConnected() = vpnStatus == Tunnel.State.UP
     fun isEthernetConditionMet(): Boolean {
-		return (
+        return (isEthernetConnected &&
-			isEthernetConnected &&
+            settings.isTunnelOnEthernetEnabled &&
-				settings.isTunnelOnEthernetEnabled
+            !isVpnConnected())
-			)
     }
 
     fun isMobileDataConditionMet(): Boolean {
-		return (
+        return (!isEthernetConnected &&
-			!isEthernetConnected &&
             settings.isTunnelOnMobileDataEnabled &&
             !isWifiConnected &&
-				isMobileDataConnected
+            isMobileDataConnected &&
-			)
+            !isVpnConnected())
+    }
+
+    fun isTunnelNotMobileDataPreferredConditionMet(): Boolean {
+        return (!isEthernetConnected &&
+            settings.isTunnelOnMobileDataEnabled &&
+            !isWifiConnected &&
+            isMobileDataConnected &&
+            config?.isMobileDataTunnel == false && isVpnConnected())
     }
 
     fun isTunnelOffOnMobileDataConditionMet(): Boolean {
-		return (
+        return (!isEthernetConnected &&
-			!isEthernetConnected &&
             !settings.isTunnelOnMobileDataEnabled &&
             isMobileDataConnected &&
-				!isWifiConnected
+            !isWifiConnected &&
-			)
+            isVpnConnected())
     }
 
     fun isUntrustedWifiConditionMet(): Boolean {
-		return (
+        return (!isEthernetConnected &&
-			!isEthernetConnected &&
             isWifiConnected &&
             !settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
             settings.isTunnelOnWifiEnabled
-			)
+            && !isVpnConnected())
+    }
+
+    fun isTunnelNotWifiNamePreferredMet(ssid: String): Boolean {
+        return (!isEthernetConnected &&
+            isWifiConnected &&
+            !settings.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
+            settings.isTunnelOnWifiEnabled && config?.tunnelNetworks?.contains(ssid) == false && isVpnConnected())
     }
 
     fun isTrustedWifiConditionMet(): Boolean {
-		return (
+        return (!isEthernetConnected &&
-			!isEthernetConnected &&
+            (isWifiConnected &&
-				(
+                settings.trustedNetworkSSIDs.contains(currentNetworkSSID)) &&
-					isWifiConnected &&
+            (isVpnConnected()))
-						settings.trustedNetworkSSIDs.contains(currentNetworkSSID)
-					)
-			)
     }
 
     fun isTunnelOffOnWifiConditionMet(): Boolean {
-		return (
+        return (!isEthernetConnected &&
-			!isEthernetConnected &&
+            (isWifiConnected &&
-				(
+                !settings.isTunnelOnWifiEnabled &&
-					isWifiConnected &&
+                (isVpnConnected())))
-						!settings.isTunnelOnWifiEnabled
-					)
-			)
     }
 
     fun isTunnelOffOnNoConnectivityMet(): Boolean {
-		return (
+        return (!isEthernetConnected &&
-			!isEthernetConnected &&
             !isWifiConnected &&
-				!isMobileDataConnected
+            !isMobileDataConnected &&
-			)
+            (isVpnConnected()))
     }
 }
+

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

@@ -5,34 +5,30 @@ import android.os.Bundle
 import android.os.PowerManager
 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.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
 import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.service.network.WifiService
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import timber.log.Timber
 import java.net.InetAddress
 import javax.inject.Inject
 
+
 @AndroidEntryPoint
 class WireGuardConnectivityWatcherService : ForegroundService() {
     private val foregroundId = 122
@@ -58,30 +54,20 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     @Inject
     lateinit var serviceManager: ServiceManager
 
-	@Inject
-	@IoDispatcher
-	lateinit var ioDispatcher: CoroutineDispatcher
-
-	@Inject
-	@MainImmediateDispatcher
-	lateinit var mainImmediateDispatcher: CoroutineDispatcher
-
     private val networkEventsFlow = MutableStateFlow(WatcherState())
 
-	private var watcherJob: Job? = null
+    private lateinit var watcherJob: Job
 
     private var wakeLock: PowerManager.WakeLock? = null
     private val tag = this.javaClass.name
 
     override fun onCreate() {
         super.onCreate()
-		lifecycleScope.launch(mainImmediateDispatcher) {
+        lifecycleScope.launch(Dispatchers.Main) {
             try {
                 if (appDataRepository.settings.getSettings().isAutoTunnelPaused) {
                     launchWatcherPausedNotification()
-				} else {
+                } else launchWatcherNotification()
-					launchWatcherNotification()
-				}
             } catch (e: Exception) {
                 Timber.e("Failed to start watcher service, not enough permissions")
             }
@@ -100,8 +86,8 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         }
     }
 
-	override fun stopService() {
+    override fun stopService(extras: Bundle?) {
-		super.stopService()
+        super.stopService(extras)
         wakeLock?.let {
             if (it.isHeld) {
                 it.release()
@@ -111,7 +97,9 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         stopSelf()
     }
 
-	private fun launchWatcherNotification(description: String = getString(R.string.watcher_notification_text_active)) {
+    private fun launchWatcherNotification(
+        description: String = getString(R.string.watcher_notification_text_active)
+    ) {
         val notification =
             notificationService.createNotification(
                 channelId = getString(R.string.watcher_channel_id),
@@ -146,16 +134,14 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     }
 
     private fun cancelWatcherJob() {
-		try {
+        if (this::watcherJob.isInitialized) {
-			watcherJob?.cancel()
+            watcherJob.cancel()
-		} catch (e: CancellationException) {
-			Timber.i("Watcher job cancelled")
         }
     }
 
     private fun startWatcherJob() {
         watcherJob =
-			lifecycleScope.launch {
+            lifecycleScope.launch(Dispatchers.IO) {
                 val setting = appDataRepository.settings.getSettings()
                 launch {
                     Timber.i("Starting wifi watcher")
@@ -173,6 +159,10 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
                         watchForEthernetConnectivityChanges()
                     }
                 }
+                launch {
+                    Timber.i("Starting vpn state watcher")
+                    watchForVpnConnectivityChanges()
+                }
                 launch {
                     Timber.i("Starting settings watcher")
                     watchForSettingsChanges()
@@ -187,75 +177,63 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
                     Timber.i("Starting management watcher")
                     manageVpn()
                 }
+
             }
     }
 
     private suspend fun watchForMobileDataConnectivityChanges() {
-		withContext(ioDispatcher) {
+        mobileDataService.networkStatus.collect {
-			mobileDataService.networkStatus.collect { status ->
+            when (it) {
-				when (status) {
                 is NetworkStatus.Available -> {
                     Timber.i("Gained Mobile data connection")
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isMobileDataConnected = true,
                         )
                 }
-					}
 
                 is NetworkStatus.CapabilitiesChanged -> {
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isMobileDataConnected = true,
                         )
-						}
                     Timber.i("Mobile data capabilities changed")
                 }
 
                 is NetworkStatus.Unavailable -> {
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.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) {
+                if (vpnService.vpnState.value.status == Tunnel.State.UP) {
                     val tunnelConfig = vpnService.vpnState.value.tunnelConfig
                     tunnelConfig?.let {
-							val config = TunnelConfig.configFromWgQuick(it.wgQuick)
+                        val config = TunnelConfig.configFromQuick(it.wgQuick)
-							val results =
+                        val results = config.peers.map { peer ->
-								config.peers.map { peer ->
+                            val host = if (peer.endpoint.isPresent &&
-									val host =
+                                peer.endpoint.get().resolved.isPresent)
-										if (peer.endpoint.isPresent &&
-											peer.endpoint.get().resolved.isPresent
-										) {
                                 peer.endpoint.get().resolved.get().host
-										} else {
+                            else Constants.BACKUP_PING_HOST
-											Constants.DEFAULT_PING_IP
-										}
                             Timber.i("Checking reachability of: $host")
-									val reachable =
+                            val reachable = InetAddress.getByName(host)
-										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)
+                            serviceManager.stopVpnService(this)
                             delay(Constants.VPN_RESTART_DELAY)
-								serviceManager.startVpnServiceForeground(context, it.id)
+                            serviceManager.startVpnServiceForeground(this)
                             delay(Constants.PING_COOLDOWN)
                         }
                     }
@@ -266,109 +244,100 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
             Timber.e(e)
         }
     }
-	}
 
     private suspend fun watchForSettingsChanges() {
-		appDataRepository.settings.getSettingsFlow().collect { settings ->
+        appDataRepository.settings.getSettingsFlow().collect {
-			if (networkEventsFlow.value.settings.isAutoTunnelPaused
+            if (networkEventsFlow.value.settings.isAutoTunnelPaused != it.isAutoTunnelPaused) {
-				!= settings.isAutoTunnelPaused
+                when (it.isAutoTunnelPaused) {
-			) {
-				when (settings.isAutoTunnelPaused) {
                     true -> launchWatcherPausedNotification()
                     false -> launchWatcherNotification()
                 }
             }
-			networkEventsFlow.update {
+            networkEventsFlow.value =
-				it.copy(
+                networkEventsFlow.value.copy(
-					settings = settings,
+                    settings = it,
                 )
         }
     }
+
+    private suspend fun watchForVpnConnectivityChanges() {
+        vpnService.vpnState.collect {
+            networkEventsFlow.value =
+                networkEventsFlow.value.copy(
+                    vpnStatus = it.status,
+                    config = it.tunnelConfig,
+                )
+        }
     }
 
     private suspend fun watchForEthernetConnectivityChanges() {
-		withContext(ioDispatcher) {
+        ethernetService.networkStatus.collect {
-			ethernetService.networkStatus.collect { status ->
+            when (it) {
-				when (status) {
                 is NetworkStatus.Available -> {
                     Timber.i("Gained Ethernet connection")
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isEthernetConnected = true,
                         )
                 }
-					}
 
                 is NetworkStatus.CapabilitiesChanged -> {
                     Timber.i("Ethernet capabilities changed")
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isEthernetConnected = true,
                         )
                 }
-					}
 
                 is NetworkStatus.Unavailable -> {
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isEthernetConnected = false,
                         )
-						}
                     Timber.i("Lost Ethernet connection")
                 }
             }
         }
     }
-	}
 
     private suspend fun watchForWifiConnectivityChanges() {
-		withContext(ioDispatcher) {
+        wifiService.networkStatus.collect {
-			wifiService.networkStatus.collect { status ->
+            when (it) {
-				when (status) {
                 is NetworkStatus.Available -> {
                     Timber.i("Gained Wi-Fi connection")
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isWifiConnected = true,
                         )
                 }
-					}
 
                 is NetworkStatus.CapabilitiesChanged -> {
                     Timber.i("Wifi capabilities changed")
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isWifiConnected = true,
                         )
-						}
+                    val ssid = wifiService.getNetworkName(it.networkCapabilities)
-						val ssid = wifiService.getNetworkName(status.networkCapabilities)
+                    ssid?.let {
-						ssid?.let { name ->
+                        Timber.i("Detected SSID: $ssid")
-							if (name.contains(Constants.UNREADABLE_SSID)) {
+                        appDataRepository.appState.setCurrentSsid(ssid)
-								Timber.w("SSID unreadable: missing permissions")
+                        networkEventsFlow.value =
-							} else {
+                            networkEventsFlow.value.copy(
-								Timber.i("Detected valid SSID")
+                                currentNetworkSSID = ssid,
-							}
-							appDataRepository.appState.setCurrentSsid(name)
-							networkEventsFlow.update {
-								it.copy(
-									currentNetworkSSID = name,
                             )
-							}
                     } ?: Timber.w("Failed to read ssid")
                 }
 
                 is NetworkStatus.Unavailable -> {
-						networkEventsFlow.update {
+                    networkEventsFlow.value =
-							it.copy(
+                        networkEventsFlow.value.copy(
                             isWifiConnected = false,
                         )
-						}
                     Timber.i("Lost Wi-Fi connection")
                 }
             }
         }
     }
-	}
 
     private suspend fun getMobileDataTunnel(): TunnelConfig? {
         return appDataRepository.tunnels.findByMobileDataTunnel().firstOrNull()
@@ -378,89 +347,72 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         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)
+                        serviceManager.startVpnServiceForeground(this)
                     }
 
                     watcherState.isMobileDataConditionMet() -> {
-							Timber.i("$autoTunnel - tunnel on mobile data condition met")
+                        Timber.i("$autoTunnel - tunnel on on mobile data condition met")
-							val mobileDataTunnel = getMobileDataTunnel()
+                        serviceManager.startVpnServiceForeground(this, getMobileDataTunnel()?.id)
-							val tunnel =
+                    }
-								mobileDataTunnel ?: appDataRepository.getPrimaryOrFirstTunnel()
+
-							if (isTunnelDown() || tunnelConfig?.isMobileDataTunnel == false) {
+                    watcherState.isTunnelNotMobileDataPreferredConditionMet() -> {
+                        getMobileDataTunnel()?.let {
+                            Timber.i("$autoTunnel - tunnel connected on mobile data is not preferred condition met, switching to preferred")
                             serviceManager.startVpnServiceForeground(
-									context,
+                                this,
-									tunnel?.id,
+                                getMobileDataTunnel()?.id,
                             )
                         }
                     }
 
                     watcherState.isTunnelOffOnMobileDataConditionMet() -> {
                         Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
-							if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
+                        serviceManager.stopVpnService(this)
                     }
 
-						watcherState.isUntrustedWifiConditionMet() -> {
+                    watcherState.isTunnelNotWifiNamePreferredMet(watcherState.currentNetworkSSID) -> {
-							if (tunnelConfig?.tunnelNetworks?.contains(watcherState.currentNetworkSSID) == false ||
+                        Timber.i("$autoTunnel - tunnel on ssid not associated with current tunnel condition met")
-								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: ${it.name}")
+                            Timber.i("Found tunnel associated with this SSID, bringing tunnel up")
-									if (isTunnelDown() || tunnelConfig?.id != it.id) {
+                            serviceManager.startVpnServiceForeground(this, it.id)
-										serviceManager.startVpnServiceForeground(
-											context,
-											it.id,
-										)
-									}
                         } ?: suspend {
                             Timber.i("No tunnel associated with this SSID, using defaults")
-									val default = appDataRepository.getPrimaryOrFirstTunnel()
+                            if (appDataRepository.getPrimaryOrFirstTunnel()?.name != vpnService.name) {
-									if (default?.name != vpnService.name) {
+                                serviceManager.startVpnServiceForeground(this)
-										default?.let {
-											serviceManager.startVpnServiceForeground(context, it.id)
-										}
                             }
                         }.invoke()
                     }
+
+                    watcherState.isUntrustedWifiConditionMet() -> {
+                        Timber.i("$autoTunnel - tunnel on untrusted wifi condition met")
+                        serviceManager.startVpnServiceForeground(
+                            this,
+                            getSsidTunnel(watcherState.currentNetworkSSID)?.id,
+                        )
                     }
 
                     watcherState.isTrustedWifiConditionMet() -> {
-							Timber.i(
+                        Timber.i("$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off")
-								"$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off",
+                        serviceManager.stopVpnService(this)
-							)
-							if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
                     }
 
                     watcherState.isTunnelOffOnWifiConditionMet() -> {
-							Timber.i(
+                        Timber.i("$autoTunnel - tunnel off on wifi condition met, turning vpn off")
-								"$autoTunnel - tunnel off on wifi condition met, turning vpn off",
+                        serviceManager.stopVpnService(this)
-							)
-							if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
                     }
 
                     watcherState.isTunnelOffOnNoConnectivityMet() -> {
-							Timber.i(
+                        Timber.i("$autoTunnel - tunnel off on no connectivity met, turning vpn off")
-								"$autoTunnel - tunnel off on no connectivity met, turning vpn off",
+                        serviceManager.stopVpnService(this)
-							)
-							if (!isTunnelDown()) serviceManager.stopVpnServiceForeground(context)
                     }
 
                     else -> {
@@ -471,4 +423,3 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         }
     }
 }
-}

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

@@ -5,26 +5,21 @@ import android.content.Intent
 import android.os.Bundle
 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.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
-import com.zaneschepke.wireguardautotunnel.module.MainImmediateDispatcher
 import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
 import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
 import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
@@ -40,21 +35,13 @@ class WireGuardTunnelService : ForegroundService() {
     @Inject
     lateinit var notificationService: NotificationService
 
-	@Inject
+    private lateinit var job: Job
-	@MainImmediateDispatcher
-	lateinit var mainImmediateDispatcher: CoroutineDispatcher
-
-	@Inject
-	@IoDispatcher
-	lateinit var ioDispatcher: CoroutineDispatcher
-
-	private var job: Job? = null
 
     private var didShowConnected = false
 
     override fun onCreate() {
         super.onCreate()
-		lifecycleScope.launch(mainImmediateDispatcher) {
+        lifecycleScope.launch(Dispatchers.Main) {
             //TODO fix this to not launch if AOVPN
             if (appDataRepository.tunnels.count() != 0) {
                 launchVpnNotification()
@@ -66,10 +53,10 @@ class WireGuardTunnelService : ForegroundService() {
         super.startService(extras)
         cancelJob()
         job =
-			lifecycleScope.launch {
+            lifecycleScope.launch(Dispatchers.IO) {
                 launch {
                     val tunnelId = extras?.getInt(Constants.TUNNEL_EXTRA_KEY)
-					if (vpnService.getState() == TunnelState.UP) {
+                    if (vpnService.getState() == Tunnel.State.UP) {
                         vpnService.stopTunnel()
                     }
                     vpnService.startTunnel(
@@ -86,7 +73,6 @@ class WireGuardTunnelService : ForegroundService() {
 
     //TODO improve tunnel notifications
     private suspend fun handshakeNotifications() {
-		withContext(ioDispatcher) {
         var tunnelName: String? = null
         vpnService.vpnState.collect { state ->
             state.statistics
@@ -114,7 +100,7 @@ class WireGuardTunnelService : ForegroundService() {
                         else -> {}
                     }
                 }
-				if (state.status == TunnelState.UP && state.tunnelConfig?.name != tunnelName) {
+            if (state.status == Tunnel.State.UP && state.tunnelConfig?.name != tunnelName) {
                 tunnelName = state.tunnelConfig?.name
                 launchVpnNotification(
                     getString(R.string.tunnel_start_title),
@@ -123,7 +109,6 @@ class WireGuardTunnelService : ForegroundService() {
             }
         }
     }
-	}
 
     private fun launchAlwaysOnDisabledNotification() {
         launchVpnNotification(
@@ -132,9 +117,9 @@ class WireGuardTunnelService : ForegroundService() {
         )
     }
 
-	override fun stopService() {
+    override fun stopService(extras: Bundle?) {
-		super.stopService()
+        super.stopService(extras)
-		lifecycleScope.launch {
+        lifecycleScope.launch(Dispatchers.IO) {
             vpnService.stopTunnel()
             didShowConnected = false
         }
@@ -142,7 +127,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),
@@ -189,10 +177,8 @@ class WireGuardTunnelService : ForegroundService() {
     }
 
     private fun cancelJob() {
-		try {
+        if (this::job.isInitialized) {
-			job?.cancel()
+            job.cancel()
-		} catch (e: CancellationException) {
-			Timber.i("Tunnel job cancelled")
         }
     }
 }

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

@@ -16,7 +16,7 @@ import kotlinx.coroutines.flow.map
 
 abstract class BaseNetworkService<T : BaseNetworkService<T>>(
     val context: Context,
-	networkCapability: Int,
+    networkCapability: Int
 ) : NetworkService<T> {
     private val connectivityManager =
         context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
@@ -24,8 +24,7 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
     private val wifiManager =
         context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
 
-	override val networkStatus =
+    override val networkStatus = callbackFlow {
-		callbackFlow {
         val networkStatusCallback =
             when (Build.VERSION.SDK_INT) {
                 in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
@@ -41,7 +40,10 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
                             trySend(NetworkStatus.Unavailable(network))
                         }
 
-							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
+                        override fun onCapabilitiesChanged(
+                            network: Network,
+                            networkCapabilities: NetworkCapabilities
+                        ) {
                             trySend(
                                 NetworkStatus.CapabilitiesChanged(
                                     network,
@@ -62,7 +64,10 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
                             trySend(NetworkStatus.Unavailable(network))
                         }
 
-							override fun onCapabilitiesChanged(network: Network, networkCapabilities: NetworkCapabilities) {
+                        override fun onCapabilitiesChanged(
+                            network: Network,
+                            networkCapabilities: NetworkCapabilities
+                        ) {
                             trySend(
                                 NetworkStatus.CapabilitiesChanged(
                                     network,
@@ -113,7 +118,7 @@ inline fun <Result> Flow<NetworkStatus>.map(
     crossinline onUnavailable: suspend (network: Network) -> Result,
     crossinline onAvailable: suspend (network: Network) -> Result,
     crossinline onCapabilitiesChanged:
-	suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result,
+    suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result
 ): Flow<Result> = map { status ->
     when (status) {
         is NetworkStatus.Unavailable -> onUnavailable(status.network)

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

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

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

@@ -9,15 +9,11 @@ import android.content.Intent
 import android.graphics.Color
 import androidx.core.app.NotificationCompat
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.ui.SplashActivity
+import com.zaneschepke.wireguardautotunnel.ui.MainActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WireGuardNotification
+class WireGuardNotification @Inject constructor(@ApplicationContext private val context: Context) :
-@Inject
-constructor(
-	@ApplicationContext private val context: Context,
-) :
     NotificationService {
     private val notificationManager =
         context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -63,7 +59,7 @@ constructor(
                 }
         notificationManager.createNotificationChannel(channel)
         val pendingIntent: PendingIntent =
-			Intent(context, SplashActivity::class.java).let { notificationIntent ->
+            Intent(context, MainActivity::class.java).let { notificationIntent ->
                 PendingIntent.getActivity(
                     context,
                     0,

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

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

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

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

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

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

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

@@ -4,8 +4,7 @@ enum class HandshakeStatus {
     HEALTHY,
     STALE,
     UNKNOWN,
-	NOT_STARTED,
+    NOT_STARTED;
-	;
 
     companion object {
         private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 180

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

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

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

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

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

@@ -2,138 +2,81 @@ 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.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.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
-import javax.inject.Provider
 
 class WireGuardTunnel
 @Inject
 constructor(
-	private val userspaceAmneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
+    @Userspace private val userspaceBackend: Backend,
-	@Userspace private val userspaceBackend: Provider<Backend>,
+    @Kernel private val kernelBackend: Backend,
-	@Kernel private val kernelBackend: Provider<Backend>,
     private val appDataRepository: AppDataRepository,
-	@ApplicationScope private val applicationScope: CoroutineScope,
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : VpnService {
     private val _vpnState = MutableStateFlow(VpnState())
     override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()
 
-	private var statsJob: Job? = null
+    private val scope = CoroutineScope(Dispatchers.IO)
 
-	private var backendIsWgUserspace = true
+    private lateinit var statsJob: Job
 
-	private var backendIsAmneziaUserspace = false
+    private var backend: Backend = userspaceBackend
+
+    private var backendIsUserspace = true
 
     init {
-		applicationScope.launch(ioDispatcher) {
+        scope.launch {
             appDataRepository.settings.getSettingsFlow().collect {
-				if (it.isKernelEnabled && (backendIsWgUserspace || backendIsAmneziaUserspace)) {
+                if (it.isKernelEnabled && backendIsUserspace) {
-					Timber.i("Setting kernel backend")
+                    Timber.d("Setting kernel backend")
-					backendIsWgUserspace = false
+                    backend = kernelBackend
-					backendIsAmneziaUserspace = false
+                    backendIsUserspace = false
-				} else if (!it.isKernelEnabled && !it.isAmneziaEnabled && !backendIsWgUserspace) {
+                } else if (!it.isKernelEnabled && !backendIsUserspace) {
-					Timber.i("Setting WireGuard userspace backend")
+                    Timber.d("Setting userspace backend")
-					backendIsWgUserspace = true
+                    backend = userspaceBackend
-					backendIsAmneziaUserspace = false
+                    backendIsUserspace = true
-				} else if (it.isAmneziaEnabled && !backendIsAmneziaUserspace) {
-					Timber.i("Setting Amnezia userspace backend")
-					backendIsAmneziaUserspace = true
-					backendIsWgUserspace = false
                 }
             }
         }
     }
 
-	private fun setState(tunnelConfig: TunnelConfig?, tunnelState: TunnelState): TunnelState {
+    override suspend fun startTunnel(tunnelConfig: TunnelConfig?): State {
-		return if (backendIsAmneziaUserspace) {
+        return try {
-			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.get().setState(this, tunnelState.toAmState(), config)
-			TunnelState.from(state)
-		} else {
-			Timber.i("Using Wg backend")
-			val wgConfig = tunnelConfig?.let { TunnelConfig.configFromWgQuick(it.wgQuick) }
-			val state =
-				backend().setState(
-					this,
-					tunnelState.toWgState(),
-					wgConfig,
-				)
-			TunnelState.from(state)
-		}
-	}
-
-	override suspend fun startTunnel(tunnelConfig: TunnelConfig?): TunnelState {
-		return withContext(ioDispatcher) {
-			try {
             //TODO we need better error handling here
-				// need to bubble up these errors to the UI
             val config = tunnelConfig ?: appDataRepository.getPrimaryOrFirstTunnel()
             if (config != null) {
                 emitTunnelConfig(config)
-					setState(config, TunnelState.UP)
+                val wgConfig = TunnelConfig.configFromQuick(config.wgQuick)
-				} else {
+                val state =
-					throw Exception("No tunnels")
+                    backend.setState(
-				}
+                        this,
+                        State.UP,
+                        wgConfig,
+                    )
+                state
+            } else throw Exception("No tunnels")
         } catch (e: BackendException) {
             Timber.e("Failed to start tunnel with error: ${e.message}")
-				TunnelState.from(State.DOWN)
+            State.DOWN
-			}
         }
     }
 
-	private fun backend(): Backend {
+    private fun emitTunnelState(state: State) {
-		return when {
-			backendIsWgUserspace -> {
-				userspaceBackend.get()
-			}
-
-			!backendIsWgUserspace && !backendIsAmneziaUserspace -> {
-				kernelBackend.get()
-			}
-
-			else -> {
-				userspaceBackend.get()
-			}
-		}
-	}
-
-	private fun emitTunnelState(state: TunnelState) {
         _vpnState.tryEmit(
             _vpnState.value.copy(
                 status = state,
@@ -141,7 +84,7 @@ constructor(
         )
     }
 
-	private fun emitBackendStatistics(statistics: TunnelStatistics) {
+    private fun emitBackendStatistics(statistics: Statistics) {
         _vpnState.tryEmit(
             _vpnState.value.copy(
                 statistics = statistics,
@@ -157,77 +100,43 @@ constructor(
         )
     }
 
-	private fun resetVpnState() {
-		_vpnState.tryEmit(VpnState())
-	}
-
     override suspend fun stopTunnel() {
-		withContext(ioDispatcher) {
         try {
-				if (getState() == TunnelState.UP) {
+            if (getState() == State.UP) {
-					val state = setState(null, TunnelState.DOWN)
+                val state = backend.setState(this, State.DOWN, null)
-					resetVpnState()
                 emitTunnelState(state)
             }
         } catch (e: BackendException) {
-				Timber.e("Failed to stop wireguard tunnel with error: ${e.message}")
+            Timber.e("Failed to stop tunnel with error: ${e.message}")
-			} catch (e: org.amnezia.awg.backend.BackendException) {
-				Timber.e("Failed to stop amnezia tunnel with error: ${e.message}")
-			}
         }
     }
 
-	override fun getState(): TunnelState {
+    override fun getState(): State {
-		return if (backendIsAmneziaUserspace) {
+        return backend.getState(this)
-			TunnelState.from(
-				userspaceAmneziaBackend.get().getState(this),
-			)
-		} else {
-			TunnelState.from(backend().getState(this))
-		}
     }
 
     override fun getName(): String {
         return _vpnState.value.tunnelConfig?.name ?: ""
     }
 
-	override fun onStateChange(newState: Tunnel.State) {
+    override fun onStateChange(state: State) {
-		handleStateChange(TunnelState.from(newState))
+        val tunnel = this
-	}
-
-	private fun handleStateChange(state: TunnelState) {
         emitTunnelState(state)
-		WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+        WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(WireGuardAutoTunnel.instance)
-		if (state == TunnelState.UP) {
+        if (state == State.UP) {
-			statsJob = startTunnelStatisticsJob()
+            statsJob =
-		}
+                scope.launch {
-		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) {
+                        val statistics = backend.getStatistics(tunnel)
-				emitBackendStatistics(
+                        emitBackendStatistics(statistics)
-					AmneziaStatistics(
-						userspaceAmneziaBackend.get().getStatistics(this@WireGuardTunnel),
-					),
-				)
-			} else {
-				emitBackendStatistics(
-					WireGuardStatistics(backend().getStatistics(this@WireGuardTunnel)),
-				)
-			}
                         delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
                     }
                 }
-
+        }
-	override fun onStateChange(state: State) {
+        if (state == State.DOWN) {
-		handleStateChange(TunnelState.from(state))
+            if (this::statsJob.isInitialized) {
+                statsJob.cancel()
+            }
+        }
     }
 }

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

@@ -1,34 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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/AppUiState.kt

@@ -5,5 +5,5 @@ data class AppUiState(
     val snackbarMessageConsumed: Boolean = true,
     val vpnPermissionAccepted: Boolean = false,
     val notificationPermissionAccepted: Boolean = false,
-	val requestPermissions: Boolean = false,
+    val requestPermissions: Boolean = false
 )

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

@@ -1,35 +1,46 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
+import android.app.Application
 import android.content.ActivityNotFoundException
-import android.content.Context
 import android.content.Intent
 import android.net.Uri
+import android.widget.Toast
+import androidx.compose.runtime.mutableStateListOf
 import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
 import com.wireguard.android.backend.GoBackend
+import com.zaneschepke.logcatter.Logcatter
+import com.zaneschepke.logcatter.model.LogMessage
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 import timber.log.Timber
+import java.time.Instant
 import javax.inject.Inject
 
 @HiltViewModel
 class AppViewModel
 @Inject
-constructor() : ViewModel() {
+constructor(
+    private val application: Application,
+) : ViewModel() {
+
     val vpnIntent: Intent? = GoBackend.VpnService.prepare(WireGuardAutoTunnel.instance)
 
-	private val _appUiState =
+    private val _appUiState = MutableStateFlow(
-		MutableStateFlow(
         AppUiState(
             vpnPermissionAccepted = vpnIntent == null,
         ),
     )
     val appUiState = _appUiState.asStateFlow()
 
+
     fun isRequiredPermissionGranted(): Boolean {
         val allAccepted =
             (_appUiState.value.vpnPermissionAccepted && _appUiState.value.vpnPermissionAccepted)
@@ -38,86 +49,100 @@ constructor() : ViewModel() {
     }
 
     private fun requestPermissions() {
-		_appUiState.update {
+        _appUiState.value = _appUiState.value.copy(
-			it.copy(
             requestPermissions = true,
         )
     }
-	}
 
     fun permissionsRequested() {
-		_appUiState.update {
+        _appUiState.value = _appUiState.value.copy(
-			it.copy(
             requestPermissions = false,
         )
     }
-	}
 
-	fun openWebPage(url: String, context: Context) {
+    fun openWebPage(url: String) {
         try {
             val webpage: Uri = Uri.parse(url)
-			val intent =
+            val intent = Intent(Intent.ACTION_VIEW, webpage).apply {
-				Intent(Intent.ACTION_VIEW, webpage).apply {
                 addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
             }
-			context.startActivity(intent)
+            application.startActivity(intent)
         } catch (e: ActivityNotFoundException) {
             Timber.e(e)
-			showSnackbarMessage(context.getString(R.string.no_browser_detected))
+            showSnackbarMessage(application.getString(R.string.no_browser_detected))
         }
     }
 
     fun onVpnPermissionAccepted() {
-		_appUiState.update {
+        _appUiState.value = _appUiState.value.copy(
-			it.copy(
             vpnPermissionAccepted = true,
         )
     }
-	}
 
-	fun launchEmail(context: Context) {
+    fun launchEmail() {
         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_EMAIL, arrayOf(application.getString(R.string.my_email)))
-					putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.email_subject))
+                    putExtra(Intent.EXTRA_SUBJECT, application.getString(R.string.email_subject))
                     addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                 }
-			context.startActivity(
+            application.startActivity(
-				Intent.createChooser(intent, context.getString(R.string.email_chooser)).apply {
+                Intent.createChooser(intent, application.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))
+            showSnackbarMessage(application.getString(R.string.no_email_detected))
         }
     }
 
     fun showSnackbarMessage(message: String) {
-		_appUiState.update {
+        _appUiState.value = _appUiState.value.copy(
-			it.copy(
             snackbarMessage = message,
             snackbarMessageConsumed = false,
         )
     }
-	}
 
     fun snackbarMessageConsumed() {
-		_appUiState.update {
+        _appUiState.value = _appUiState.value.copy(
-			it.copy(
             snackbarMessage = "",
             snackbarMessageConsumed = true,
         )
     }
+
+    val logs = mutableStateListOf<LogMessage>()
+
+    fun readLogCatOutput() =
+        viewModelScope.launch(viewModelScope.coroutineContext + Dispatchers.IO) {
+            launch {
+                Logcatter.logs {
+                    logs.add(it)
+                    if (logs.size > Constants.LOG_BUFFER_SIZE) {
+                        logs.removeRange(0, (logs.size - Constants.LOG_BUFFER_SIZE).toInt())
+                    }
+                }
+            }
+        }
+
+    fun clearLogs() {
+        logs.clear()
+        Logcatter.clear()
+    }
+
+    fun saveLogsToFile() {
+        val fileName = "${Constants.BASE_LOG_FILE_NAME}-${Instant.now().epochSecond}.txt"
+        val content = logs.joinToString(separator = "\n")
+        FileUtils.saveFileToDownloads(application.applicationContext, content, fileName)
+        Toast.makeText(application, application.getString(R.string.logs_saved), Toast.LENGTH_SHORT)
+            .show()
     }
 
     fun setNotificationPermissionAccepted(accepted: Boolean) {
-		_appUiState.update {
+        _appUiState.value = _appUiState.value.copy(
-			it.copy(
             notificationPermissionAccepted = accepted,
         )
     }
 }
-}

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

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

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

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

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

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

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

@@ -1,67 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import android.annotation.SuppressLint
-import android.content.Intent
-import android.os.Build
-import android.os.Bundle
-import androidx.activity.ComponentActivity
-import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.lifecycleScope
-import androidx.lifecycle.repeatOnLifecycle
-import com.zaneschepke.logcatter.LocalLogCollector
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel.Companion.isRunningOnAndroidTv
-import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import dagger.hilt.android.AndroidEntryPoint
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import xyz.teamgravity.pin_lock_compose.PinManager
-import javax.inject.Inject
-
-@SuppressLint("CustomSplashScreen")
-@AndroidEntryPoint
-class SplashActivity : ComponentActivity() {
-	@Inject
-	lateinit var appStateRepository: AppStateRepository
-
-	@Inject
-	lateinit var localLogCollector: LocalLogCollector
-
-	@Inject
-	@ApplicationScope
-	lateinit var applicationScope: CoroutineScope
-
-	override fun onCreate(savedInstanceState: Bundle?) {
-		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-			val splashScreen = installSplashScreen()
-			splashScreen.setKeepOnScreenCondition { true }
-		}
-		super.onCreate(savedInstanceState)
-
-		applicationScope.launch {
-			if (!isRunningOnAndroidTv()) localLogCollector.start()
-		}
-
-		lifecycleScope.launch {
-			repeatOnLifecycle(Lifecycle.State.CREATED) {
-				val pinLockEnabled = appStateRepository.isPinLockEnabled()
-				if (pinLockEnabled) {
-					PinManager.initialize(WireGuardAutoTunnel.instance)
-				}
-
-				val intent =
-					Intent(this@SplashActivity, MainActivity::class.java).apply {
-						putExtra(IS_PIN_LOCK_ENABLED_KEY, pinLockEnabled)
-					}
-				startActivity(intent)
-				finish()
-			}
-		}
-	}
-
-	companion object {
-		const val IS_PIN_LOCK_ENABLED_KEY = "is_pin_lock_enabled"
-	}
-}

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

@@ -12,7 +12,13 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 
 @Composable
-fun ClickableIconButton(onClick: () -> Unit, onIconClick: () -> Unit, text: String, icon: ImageVector, enabled: Boolean) {
+fun ClickableIconButton(
+    onClick: () -> Unit,
+    onIconClick: () -> Unit,
+    text: String,
+    icon: ImageVector,
+    enabled: Boolean
+) {
     TextButton(
         onClick = onClick,
         enabled = enabled,

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

@@ -15,12 +15,9 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStatistics
+import com.wireguard.android.backend.Statistics
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.toThreeDecimalPlaceString
 
@@ -33,13 +30,11 @@ fun RowListItem(
     onClick: () -> Unit,
     rowButton: @Composable () -> Unit,
     expanded: Boolean,
-	statistics: TunnelStatistics?,
+    statistics: Statistics?
-	focusRequester: FocusRequester,
 ) {
     Box(
         modifier =
         Modifier
-			.focusRequester(focusRequester)
             .animateContentSize()
             .clip(RoundedCornerShape(30.dp))
             .combinedClickable(
@@ -49,8 +44,7 @@ fun RowListItem(
     ) {
         Column {
             Row(
-				modifier =
+                modifier = Modifier
-				Modifier
                     .fillMaxWidth()
                     .padding(horizontal = 15.dp, vertical = 5.dp),
                 verticalAlignment = Alignment.CenterVertically,
@@ -58,15 +52,14 @@ fun RowListItem(
             ) {
                 Row(
                     verticalAlignment = Alignment.CenterVertically,
-					modifier = Modifier.fillMaxWidth(13 / 20f),
                 ) {
                     icon()
-					Text(text, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                    Text(text)
                 }
                 rowButton()
             }
             if (expanded) {
-				statistics?.getPeers()?.forEach {
+                statistics?.peers()?.forEach {
                     Row(
                         modifier =
                         Modifier
@@ -76,9 +69,9 @@ fun RowListItem(
                         horizontalArrangement = Arrangement.SpaceEvenly,
                     ) {
                         //TODO change these to string resources
-						val handshakeEpoch = statistics.peerStats(it)!!.latestHandshakeEpochMillis
+                        val handshakeEpoch = statistics.peer(it)!!.latestHandshakeEpochMillis
-						val peerTx = statistics.peerStats(it)!!.txBytes
+                        val peerTx = statistics.peer(it)!!.txBytes
-						val peerRx = statistics.peerStats(it)!!.rxBytes
+                        val peerRx = statistics.peer(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,21 +44,19 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
             onQuery(onQueryChanged)
         },
         leadingIcon = {
-			val icon = Icons.Rounded.Search
             Icon(
-				imageVector = icon,
+                imageVector = Icons.Rounded.Search,
                 tint = MaterialTheme.colorScheme.onBackground,
-				contentDescription = icon.name,
+                contentDescription = stringResource(id = R.string.search_icon),
             )
         },
         trailingIcon = {
             if (showClearIcon) {
                 IconButton(onClick = { query = "" }) {
-					val icon = Icons.Rounded.Clear
                     Icon(
-						imageVector = icon,
+                        imageVector = Icons.Rounded.Clear,
                         tint = MaterialTheme.colorScheme.onBackground,
-						contentDescription = icon.name,
+                        contentDescription = stringResource(id = R.string.clear_icon),
                     )
                 }
             }

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

@@ -16,7 +16,7 @@ fun ConfigurationTextBox(
     onValueChange: (String) -> Unit,
     keyboardActions: KeyboardActions,
     label: String,
-	modifier: Modifier,
+    modifier: Modifier
 ) {
     OutlinedTextField(
         modifier = modifier,

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

@@ -13,26 +13,22 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.Dp
 
 @Composable
-fun ConfigurationToggle(label: String, enabled: Boolean, checked: Boolean, padding: Dp, onCheckChanged: () -> Unit, modifier: Modifier = Modifier) {
+fun ConfigurationToggle(
+    label: String,
+    enabled: Boolean,
+    checked: Boolean,
+    padding: Dp,
+    onCheckChanged: () -> Unit,
+    modifier: Modifier = Modifier
+) {
     Row(
-		modifier =
+        modifier = Modifier
-		Modifier
             .fillMaxWidth()
             .padding(padding),
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.SpaceBetween,
     ) {
-		Text(
+        Text(label, textAlign = TextAlign.Start)
-			label,
-			textAlign = TextAlign.Start,
-			modifier =
-			Modifier
-				.weight(
-					weight = 1.0f,
-					fill = false,
-				),
-			softWrap = true,
-		)
         Switch(
             modifier = modifier,
             enabled = enabled,

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

@@ -1,37 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common.dialog
-
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.res.stringResource
-import com.zaneschepke.wireguardautotunnel.R
-
-@Composable
-fun InfoDialog(
-	onAttest: () -> Unit,
-	onDismiss: () -> Unit,
-	title: @Composable () -> Unit,
-	body: @Composable () -> Unit,
-	confirmText: @Composable () -> Unit,
-) {
-	AlertDialog(
-		onDismissRequest = { onDismiss() },
-		confirmButton = {
-			TextButton(
-				onClick = {
-					onAttest()
-				},
-			) {
-				confirmText()
-			}
-		},
-		dismissButton = {
-			TextButton(onClick = { onDismiss() }) {
-				Text(text = stringResource(R.string.cancel))
-			}
-		},
-		title = { title() },
-		text = { body() },
-	)
-}

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

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

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

@@ -15,8 +15,7 @@ fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (
     val context = LocalContext.current
     val biometricManager = BiometricManager.from(context)
     val bio = biometricManager.canAuthenticate(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
-	val isBiometricAvailable =
+    val isBiometricAvailable = remember {
-		remember {
         when (bio) {
             BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
                 onError("Biometrics not available")
@@ -72,7 +71,9 @@ fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (
                         onFailure()
                     }
 
-					override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
+                    override fun onAuthenticationSucceeded(
+                        result: BiometricPrompt.AuthenticationResult
+                    ) {
                         super.onAuthenticationSucceeded(result)
                         onSuccess()
                     }

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

@@ -25,7 +25,11 @@ import androidx.compose.ui.unit.dp
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 
 @Composable
-fun CustomSnackBar(message: String, isRtl: Boolean = true, containerColor: Color = MaterialTheme.colorScheme.surface) {
+fun CustomSnackBar(
+    message: String,
+    isRtl: Boolean = true,
+    containerColor: Color = MaterialTheme.colorScheme.surface
+) {
     Snackbar(
         containerColor = containerColor,
         modifier =
@@ -40,8 +44,7 @@ fun CustomSnackBar(message: String, isRtl: Boolean = true, containerColor: Color
             LocalLayoutDirection provides if (isRtl) LayoutDirection.Rtl else LayoutDirection.Ltr,
         ) {
             Row(
-				modifier =
+                modifier = Modifier
-				Modifier
                     .width(IntrinsicSize.Max)
                     .height(IntrinsicSize.Min),
                 verticalAlignment = Alignment.CenterVertically,

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

@@ -16,8 +16,7 @@ fun LoadingScreen() {
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.Top,
-		modifier =
+        modifier = Modifier
-		Modifier
             .fillMaxSize()
             .focusable()
             .padding(),

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

@@ -14,8 +14,7 @@ import androidx.compose.ui.unit.dp
 @Composable
 fun LogTypeLabel(color: Color, content: @Composable () -> Unit) {
     Box(
-		modifier =
+        modifier = Modifier
-		Modifier
             .size(20.dp)
             .clip(RoundedCornerShape(2.dp))
             .background(color),

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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,73 @@
+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")
+    }
+}

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

@@ -79,9 +79,9 @@ import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationTextBox
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.AuthorizationPrompt
 import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
 import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.getMessage
+import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.util.Result
 import kotlinx.coroutines.delay
 
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@@ -94,8 +94,7 @@ fun ConfigScreen(
     focusRequester: FocusRequester,
     navController: NavController,
     appViewModel: AppViewModel,
-	tunnelId: String,
+    tunnelId: String
-	configType: ConfigType,
 ) {
     val context = LocalContext.current
     val clipboardManager: ClipboardManager = LocalClipboardManager.current
@@ -128,23 +127,16 @@ fun ConfigScreen(
     val fillMaxWidth = .85f
     val screenPadding = 5.dp
 
-	val applicationButtonText =
+    val applicationButtonText = buildAnnotatedString {
-		buildAnnotatedString {
         append(stringResource(id = R.string.tunneling_apps))
         append(": ")
         if (uiState.isAllApplicationsEnabled) {
             append(stringResource(id = R.string.all))
         } else {
             append("${uiState.checkedPackageNames.size} ")
-				(
+            (if (uiState.include) append(stringResource(id = R.string.included)) else append(
-					if (uiState.include) {
-						append(stringResource(id = R.string.included))
-					} else {
-						append(
                 stringResource(id = R.string.excluded),
-						)
+            ))
-					}
-					)
         }
     }
 
@@ -156,15 +148,11 @@ fun ConfigScreen(
             },
             onError = {
                 showAuthPrompt = false
-				appViewModel.showSnackbarMessage(
+                appViewModel.showSnackbarMessage(Event.Error.AuthenticationFailed.message)
-					context.getString(R.string.error_authentication_failed),
-				)
             },
             onFailure = {
                 showAuthPrompt = false
-				appViewModel.showSnackbarMessage(
+                appViewModel.showSnackbarMessage(Event.Error.AuthorizationFailed.message)
-					context.getString(R.string.error_authorization_failed),
-				)
             },
         )
     }
@@ -186,8 +174,7 @@ fun ConfigScreen(
                     .fillMaxHeight(if (uiState.isAllApplicationsEnabled) 1 / 5f else 4 / 5f),
             ) {
                 Column(
-					modifier =
+                    modifier = Modifier
-					Modifier
                         .fillMaxWidth(),
                 ) {
                     Row(
@@ -258,8 +245,7 @@ fun ConfigScreen(
                                 Row(
                                     verticalAlignment = Alignment.CenterVertically,
                                     horizontalArrangement = Arrangement.SpaceBetween,
-									modifier =
+                                    modifier = Modifier
-									Modifier
                                         .fillMaxSize()
                                         .padding(5.dp),
                                 ) {
@@ -288,11 +274,9 @@ fun ConfigScreen(
                                     Checkbox(
                                         modifier = Modifier.fillMaxSize(),
                                         checked =
-										(
+                                        (uiState.checkedPackageNames.contains(
-											uiState.checkedPackageNames.contains(
                                             pack.packageName,
-											)
+                                        )),
-											),
                                         onCheckedChange = {
                                             if (it) {
                                                 viewModel.onAddCheckedPackage(pack.packageName)
@@ -307,8 +291,7 @@ fun ConfigScreen(
                     }
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
-						modifier =
+                        modifier = Modifier
-						Modifier
                             .fillMaxSize()
                             .padding(top = 5.dp),
                         horizontalArrangement = Arrangement.Center,
@@ -336,13 +319,15 @@ fun ConfigScreen(
                     }
                 },
                 onClick = {
-					viewModel.onSaveAllChanges(configType).onSuccess {
+                    viewModel.onSaveAllChanges().let {
-						appViewModel.showSnackbarMessage(
+                        when (it) {
-							context.getString(R.string.config_changes_saved),
+                            is Result.Success -> {
-						)
+                                appViewModel.showSnackbarMessage(it.data.message)
                                 navController.navigate(Screen.Main.route)
-					}.onFailure {
+                            }
-						appViewModel.showSnackbarMessage(it.getMessage(context))
+
+                            is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
+                        }
                     }
                 },
                 containerColor = fobColor,
@@ -372,22 +357,19 @@ fun ConfigScreen(
                     shape = RoundedCornerShape(12.dp),
                     color = MaterialTheme.colorScheme.surface,
                     modifier =
-					(
+                    (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-						if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                         Modifier
                             .fillMaxHeight(fillMaxHeight)
                             .fillMaxWidth(fillMaxWidth)
                     } else {
                         Modifier.fillMaxWidth(fillMaxWidth)
-						}
+                    })
-						)
                         .padding(bottom = 10.dp),
                 ) {
                     Column(
                         horizontalAlignment = Alignment.Start,
                         verticalArrangement = Arrangement.Top,
-						modifier =
+                        modifier = Modifier
-						Modifier
                             .padding(15.dp)
                             .focusGroup(),
                     ) {
@@ -401,23 +383,19 @@ fun ConfigScreen(
                             keyboardActions = keyboardActions,
                             label = stringResource(R.string.name),
                             hint = stringResource(R.string.tunnel_name).lowercase(),
-							modifier =
+                            modifier = Modifier
-							Modifier
                                 .fillMaxWidth()
                                 .focusRequester(focusRequester),
                         )
                         OutlinedTextField(
-							modifier =
+                            modifier = Modifier
-							Modifier
                                 .fillMaxWidth()
                                 .clickable { showAuthPrompt = true },
                             value = uiState.interfaceProxy.privateKey,
                             visualTransformation =
-							if ((tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated) {
+                            if ((tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated)
                                 VisualTransformation.None
-							} else {
+                            else PasswordVisualTransformation(),
-								PasswordVisualTransformation()
-							},
                             enabled = (tunnelId == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated,
                             onValueChange = { value -> viewModel.onPrivateKeyChange(value) },
                             trailingIcon = {
@@ -475,8 +453,7 @@ fun ConfigScreen(
                                 keyboardActions = keyboardActions,
                                 label = stringResource(R.string.addresses),
                                 hint = stringResource(R.string.comma_separated_list),
-								modifier =
+                                modifier = Modifier
-								Modifier
                                     .fillMaxWidth(3 / 5f)
                                     .padding(end = 5.dp),
                             )
@@ -496,8 +473,7 @@ fun ConfigScreen(
                                 keyboardActions = keyboardActions,
                                 label = stringResource(R.string.dns_servers),
                                 hint = stringResource(R.string.comma_separated_list),
-								modifier =
+                                modifier = Modifier
-								Modifier
                                     .fillMaxWidth(3 / 5f)
                                     .padding(end = 5.dp),
                             )
@@ -510,165 +486,9 @@ fun ConfigScreen(
                                 modifier = Modifier.width(IntrinsicSize.Min),
                             )
                         }
-						if (configType == ConfigType.AMNEZIA) {
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.junkPacketCount,
-								onValueChange = {
-										value ->
-									viewModel.onJunkPacketCountChanged(value)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.junk_packet_count),
-								hint = stringResource(R.string.junk_packet_count).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.junkPacketMinSize,
-								onValueChange = { value ->
-									viewModel.onJunkPacketMinSizeChanged(
-										value,
-									)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.junk_packet_minimum_size),
-								hint =
-								stringResource(
-									R.string.junk_packet_minimum_size,
-								).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.junkPacketMaxSize,
-								onValueChange = { value ->
-									viewModel.onJunkPacketMaxSizeChanged(
-										value,
-									)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.junk_packet_maximum_size),
-								hint =
-								stringResource(
-									R.string.junk_packet_maximum_size,
-								).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.initPacketJunkSize,
-								onValueChange = { value ->
-									viewModel.onInitPacketJunkSizeChanged(
-										value,
-									)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.init_packet_junk_size),
-								hint = stringResource(R.string.init_packet_junk_size).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.responsePacketJunkSize,
-								onValueChange = {
-										value ->
-									viewModel.onResponsePacketJunkSize(value)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.response_packet_junk_size),
-								hint =
-								stringResource(
-									R.string.response_packet_junk_size,
-								).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.initPacketMagicHeader,
-								onValueChange = {
-										value ->
-									viewModel.onInitPacketMagicHeader(value)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.init_packet_magic_header),
-								hint =
-								stringResource(
-									R.string.init_packet_magic_header,
-								).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.responsePacketMagicHeader,
-								onValueChange = { value ->
-									viewModel.onResponsePacketMagicHeader(
-										value,
-									)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.response_packet_magic_header),
-								hint =
-								stringResource(
-									R.string.response_packet_magic_header,
-								).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.underloadPacketMagicHeader,
-								onValueChange = { value ->
-									viewModel.onUnderloadPacketMagicHeader(
-										value,
-									)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.underload_packet_magic_header),
-								hint =
-								stringResource(
-									R.string.underload_packet_magic_header,
-								).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-							ConfigurationTextBox(
-								value = uiState.interfaceProxy.transportPacketMagicHeader,
-								onValueChange = { value ->
-									viewModel.onTransportPacketMagicHeader(
-										value,
-									)
-								},
-								keyboardActions = keyboardActions,
-								label = stringResource(R.string.transport_packet_magic_header),
-								hint =
-								stringResource(
-									R.string.transport_packet_magic_header,
-								).lowercase(),
-								modifier =
-								Modifier
-									.fillMaxWidth()
-									.focusRequester(focusRequester),
-							)
-						}
                         Row(
                             verticalAlignment = Alignment.CenterVertically,
-							modifier =
+                            modifier = Modifier
-							Modifier
                                 .fillMaxSize()
                                 .padding(top = 5.dp),
                             horizontalArrangement = Arrangement.Center,
@@ -686,30 +506,26 @@ fun ConfigScreen(
                         shape = RoundedCornerShape(12.dp),
                         color = MaterialTheme.colorScheme.surface,
                         modifier =
-						(
+                        (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-							if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                             Modifier
                                 .fillMaxHeight(fillMaxHeight)
                                 .fillMaxWidth(fillMaxWidth)
                         } else {
                             Modifier.fillMaxWidth(fillMaxWidth)
-							}
+                        })
-							)
                             .padding(top = 10.dp, bottom = 10.dp),
                     ) {
                         Column(
                             horizontalAlignment = Alignment.Start,
                             verticalArrangement = Arrangement.Top,
-							modifier =
+                            modifier = Modifier
-							Modifier
                                 .padding(horizontal = 15.dp)
                                 .padding(bottom = 10.dp),
                         ) {
                             Row(
                                 horizontalArrangement = Arrangement.SpaceBetween,
                                 verticalAlignment = Alignment.CenterVertically,
-								modifier =
+                                modifier = Modifier
-								Modifier
                                     .fillMaxWidth()
                                     .padding(horizontal = 5.dp),
                             ) {
@@ -795,8 +611,7 @@ fun ConfigScreen(
                 Row(
                     horizontalArrangement = Arrangement.SpaceEvenly,
                     verticalAlignment = Alignment.CenterVertically,
-					modifier =
+                    modifier = Modifier
-					Modifier
                         .fillMaxSize()
                         .padding(bottom = 140.dp),
                 ) {

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

@@ -1,9 +1,8 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.config
 
-import com.wireguard.config.Config
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.ui.models.InterfaceProxy
-import com.zaneschepke.wireguardautotunnel.ui.screens.config.model.InterfaceProxy
+import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
-import com.zaneschepke.wireguardautotunnel.ui.screens.config.model.PeerProxy
 import com.zaneschepke.wireguardautotunnel.util.Packages
 
 data class ConfigUiState(
@@ -15,59 +14,5 @@ data class ConfigUiState(
     val isAllApplicationsEnabled: Boolean = false,
     val loading: Boolean = true,
     val tunnel: TunnelConfig? = null,
-	val tunnelName: String = "",
+    val tunnelName: String = ""
-	val isAmneziaEnabled: Boolean = false,
-) {
-	companion object {
-		fun from(config: Config): ConfigUiState {
-			val proxyPeers = config.peers.map { PeerProxy.from(it) }
-			val proxyInterface = InterfaceProxy.from(config.`interface`)
-			var include = true
-			var isAllApplicationsEnabled = false
-			val checkedPackages =
-				if (config.`interface`.includedApplications.isNotEmpty()) {
-					config.`interface`.includedApplications
-				} else if (config.`interface`.excludedApplications.isNotEmpty()) {
-					include = false
-					config.`interface`.excludedApplications
-				} else {
-					isAllApplicationsEnabled = true
-					emptySet()
-				}
-			return ConfigUiState(
-				proxyPeers,
-				proxyInterface,
-				emptyList(),
-				checkedPackages.toList(),
-				include,
-				isAllApplicationsEnabled,
 )
-		}
-
-		fun from(config: org.amnezia.awg.config.Config): ConfigUiState {
-			// TODO update with new values
-			val proxyPeers = config.peers.map { PeerProxy.from(it) }
-			val proxyInterface = InterfaceProxy.from(config.`interface`)
-			var include = true
-			var isAllApplicationsEnabled = false
-			val checkedPackages =
-				if (config.`interface`.includedApplications.isNotEmpty()) {
-					config.`interface`.includedApplications
-				} else if (config.`interface`.excludedApplications.isNotEmpty()) {
-					include = false
-					config.`interface`.excludedApplications
-				} else {
-					isAllApplicationsEnabled = true
-					emptySet()
-				}
-			return ConfigUiState(
-				proxyPeers,
-				proxyInterface,
-				emptyList(),
-				checkedPackages.toList(),
-				include,
-				isAllApplicationsEnabled,
-			)
-		}
-	}
-}

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

@@ -1,6 +1,7 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.config
 
 import android.Manifest
+import android.app.Application
 import android.content.pm.PackageInfo
 import android.content.pm.PackageManager
 import android.os.Build
@@ -11,25 +12,21 @@ import com.wireguard.config.Interface
 import com.wireguard.config.Peer
 import com.wireguard.crypto.Key
 import com.wireguard.crypto.KeyPair
-import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.ui.models.InterfaceProxy
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
+import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
-import com.zaneschepke.wireguardautotunnel.ui.screens.config.model.PeerProxy
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.Event
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import com.zaneschepke.wireguardautotunnel.util.StringValue
+import com.zaneschepke.wireguardautotunnel.util.Result
-import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
 import com.zaneschepke.wireguardautotunnel.util.removeAt
 import com.zaneschepke.wireguardautotunnel.util.update
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
@@ -38,40 +35,49 @@ import javax.inject.Inject
 class ConfigViewModel
 @Inject
 constructor(
-	private val settingsRepository: SettingsRepository,
+    private val application: Application,
-	private val appDataRepository: AppDataRepository,
+    private val appDataRepository: AppDataRepository
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : ViewModel() {
-	private val packageManager = WireGuardAutoTunnel.instance.packageManager
+
+    private val packageManager = application.packageManager
 
     private val _uiState = MutableStateFlow(ConfigUiState())
     val uiState = _uiState.asStateFlow()
 
-	fun init(tunnelId: String) = viewModelScope.launch(ioDispatcher) {
+    fun init(tunnelId: String) =
+        viewModelScope.launch(Dispatchers.IO) {
             val packages = getQueriedPackages("")
             val state =
                 if (tunnelId != Constants.MANUAL_TUNNEL_CONFIG_ID) {
                     val tunnelConfig =
                         appDataRepository.tunnels.getAll()
                             .firstOrNull { it.id.toString() == tunnelId }
-				val isAmneziaEnabled = settingsRepository.getSettings().isAmneziaEnabled
                     if (tunnelConfig != null) {
-					(
+                        val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-						if (isAmneziaEnabled) {
+                        val proxyPeers = config.peers.map { PeerProxy.from(it) }
-							val amConfig =
+                        val proxyInterface = InterfaceProxy.from(config.`interface`)
-								if (tunnelConfig.amQuick == "") tunnelConfig.wgQuick else tunnelConfig.amQuick
+                        var include = true
-							ConfigUiState.from(TunnelConfig.configFromAmQuick(amConfig))
+                        var isAllApplicationsEnabled = false
+                        val checkedPackages =
+                            if (config.`interface`.includedApplications.isNotEmpty()) {
+                                config.`interface`.includedApplications
+                            } else if (config.`interface`.excludedApplications.isNotEmpty()) {
+                                include = false
+                                config.`interface`.excludedApplications
                             } else {
-							ConfigUiState.from(
+                                isAllApplicationsEnabled = true
-								TunnelConfig.configFromWgQuick(tunnelConfig.wgQuick),
+                                emptySet()
-							)
                             }
-						).copy(
+                        ConfigUiState(
-						packages = packages,
+                            proxyPeers,
-						loading = false,
+                            proxyInterface,
-						tunnel = tunnelConfig,
+                            packages,
-						tunnelName = tunnelConfig.name,
+                            checkedPackages.toList(),
-						isAmneziaEnabled = isAmneziaEnabled,
+                            include,
+                            isAllApplicationsEnabled,
+                            false,
+                            tunnelConfig,
+                            tunnelConfig.name,
                         )
                     } else {
                         ConfigUiState(loading = false, packages = packages)
@@ -115,7 +121,7 @@ constructor(
     }
 
     fun getPackageLabel(packageInfo: PackageInfo): String {
-		return packageInfo.applicationInfo?.loadLabel(packageManager).toString()
+        return packageInfo.applicationInfo.loadLabel(application.packageManager).toString()
     }
 
     private fun getAllInternetCapablePackages(): List<PackageInfo> {
@@ -137,12 +143,14 @@ constructor(
         return _uiState.value.isAllApplicationsEnabled
     }
 
-	private fun saveConfig(tunnelConfig: TunnelConfig) = viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }
+    private fun saveConfig(tunnelConfig: TunnelConfig) =
+        viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }
 
-	private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) = viewModelScope.launch {
+    private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) =
+        viewModelScope.launch {
             if (tunnelConfig != null) {
                 saveConfig(tunnelConfig).join()
-			WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+                WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
             }
         }
 
@@ -160,20 +168,6 @@ constructor(
         }
     }
 
-	private fun buildAmPeerListFromProxyPeers(): List<org.amnezia.awg.config.Peer> {
-		return _uiState.value.proxyPeers.map {
-			val builder = org.amnezia.awg.config.Peer.Builder()
-			if (it.allowedIps.isNotEmpty()) builder.parseAllowedIPs(it.allowedIps.trim())
-			if (it.publicKey.isNotEmpty()) builder.parsePublicKey(it.publicKey.trim())
-			if (it.preSharedKey.isNotEmpty()) builder.parsePreSharedKey(it.preSharedKey.trim())
-			if (it.endpoint.isNotEmpty()) builder.parseEndpoint(it.endpoint.trim())
-			if (it.persistentKeepalive.isNotEmpty()) {
-				builder.parsePersistentKeepalive(it.persistentKeepalive.trim())
-			}
-			builder.build()
-		}
-	}
-
     private fun emptyCheckedPackagesList() {
         _uiState.value = _uiState.value.copy(checkedPackageNames = emptyList())
     }
@@ -185,154 +179,45 @@ constructor(
         if (_uiState.value.interfaceProxy.dnsServers.isNotEmpty()) {
             builder.parseDnsServers(_uiState.value.interfaceProxy.dnsServers.trim())
         }
-		if (_uiState.value.interfaceProxy.mtu.isNotEmpty()) {
+        if (_uiState.value.interfaceProxy.mtu.isNotEmpty())
             builder.parseMtu(_uiState.value.interfaceProxy.mtu.trim())
-		}
         if (_uiState.value.interfaceProxy.listenPort.isNotEmpty()) {
             builder.parseListenPort(_uiState.value.interfaceProxy.listenPort.trim())
         }
         if (isAllApplicationsEnabled()) emptyCheckedPackagesList()
-		if (_uiState.value.include) {
+        if (_uiState.value.include) builder.includeApplications(_uiState.value.checkedPackageNames)
-			builder.includeApplications(
+        if (!_uiState.value.include) builder.excludeApplications(_uiState.value.checkedPackageNames)
-				_uiState.value.checkedPackageNames,
-			)
-		}
-		if (!_uiState.value.include) {
-			builder.excludeApplications(
-				_uiState.value.checkedPackageNames,
-			)
-		}
         return builder.build()
     }
 
-	private fun buildAmInterfaceListFromProxyInterface(): org.amnezia.awg.config.Interface {
+    fun onSaveAllChanges(): Result<Event> {
-		val builder = org.amnezia.awg.config.Interface.Builder()
+        return try {
-		builder.parsePrivateKey(_uiState.value.interfaceProxy.privateKey.trim())
-		builder.parseAddresses(_uiState.value.interfaceProxy.addresses.trim())
-		if (_uiState.value.interfaceProxy.dnsServers.isNotEmpty()) {
-			builder.parseDnsServers(_uiState.value.interfaceProxy.dnsServers.trim())
-		}
-		if (_uiState.value.interfaceProxy.mtu.isNotEmpty()) {
-			builder.parseMtu(_uiState.value.interfaceProxy.mtu.trim())
-		}
-		if (_uiState.value.interfaceProxy.listenPort.isNotEmpty()) {
-			builder.parseListenPort(_uiState.value.interfaceProxy.listenPort.trim())
-		}
-		if (isAllApplicationsEnabled()) emptyCheckedPackagesList()
-		if (_uiState.value.include) {
-			builder.includeApplications(
-				_uiState.value.checkedPackageNames,
-			)
-		}
-		if (!_uiState.value.include) {
-			builder.excludeApplications(
-				_uiState.value.checkedPackageNames,
-			)
-		}
-		if (_uiState.value.interfaceProxy.junkPacketCount.isNotEmpty()) {
-			builder.setJunkPacketCount(
-				_uiState.value.interfaceProxy.junkPacketCount.trim().toInt(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.junkPacketMinSize.isNotEmpty()) {
-			builder.setJunkPacketMinSize(
-				_uiState.value.interfaceProxy.junkPacketMinSize.trim().toInt(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.junkPacketMaxSize.isNotEmpty()) {
-			builder.setJunkPacketMaxSize(
-				_uiState.value.interfaceProxy.junkPacketMaxSize.trim().toInt(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.initPacketJunkSize.isNotEmpty()) {
-			builder.setInitPacketJunkSize(
-				_uiState.value.interfaceProxy.initPacketJunkSize.trim().toInt(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.responsePacketJunkSize.isNotEmpty()) {
-			builder.setResponsePacketJunkSize(
-				_uiState.value.interfaceProxy.responsePacketJunkSize.trim().toInt(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.initPacketMagicHeader.isNotEmpty()) {
-			builder.setInitPacketMagicHeader(
-				_uiState.value.interfaceProxy.initPacketMagicHeader.trim().toLong(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.responsePacketMagicHeader.isNotEmpty()) {
-			builder.setResponsePacketMagicHeader(
-				_uiState.value.interfaceProxy.responsePacketMagicHeader.trim().toLong(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.transportPacketMagicHeader.isNotEmpty()) {
-			builder.setTransportPacketMagicHeader(
-				_uiState.value.interfaceProxy.transportPacketMagicHeader.trim().toLong(),
-			)
-		}
-		if (_uiState.value.interfaceProxy.underloadPacketMagicHeader.isNotEmpty()) {
-			builder.setUnderloadPacketMagicHeader(
-				_uiState.value.interfaceProxy.underloadPacketMagicHeader.trim().toLong(),
-			)
-		}
-		return builder.build()
-	}
-
-	private fun buildConfig(): Config {
             val peerList = buildPeerListFromProxyPeers()
             val wgInterface = buildInterfaceListFromProxyInterface()
-		return Config.Builder().addPeers(peerList).setInterface(wgInterface).build()
+            val config = Config.Builder().addPeers(peerList).setInterface(wgInterface).build()
-	}
+            val tunnelConfig = when (uiState.value.tunnel) {
-
+                null -> TunnelConfig(
-	private fun buildAmConfig(): org.amnezia.awg.config.Config {
-		val peerList = buildAmPeerListFromProxyPeers()
-		val amInterface = buildAmInterfaceListFromProxyInterface()
-		return org.amnezia.awg.config.Config.Builder().addPeers(
-			peerList,
-		).setInterface(amInterface)
-			.build()
-	}
-
-	fun onSaveAllChanges(configType: ConfigType): Result<Unit> {
-		return try {
-			val wgQuick = buildConfig().toWgQuickString()
-			val amQuick =
-				if (configType == ConfigType.AMNEZIA) {
-					buildAmConfig().toAwgQuickString()
-				} else {
-					TunnelConfig.AM_QUICK_DEFAULT
-				}
-			val tunnelConfig =
-				when (uiState.value.tunnel) {
-					null ->
-						TunnelConfig(
                     name = _uiState.value.tunnelName,
-							wgQuick = wgQuick,
+                    wgQuick = config.toWgQuickString(),
-							amQuick = amQuick,
                 )
 
-					else ->
+                else -> uiState.value.tunnel!!.copy(
-						uiState.value.tunnel!!.copy(
                     name = _uiState.value.tunnelName,
-							wgQuick = wgQuick,
+                    wgQuick = config.toWgQuickString(),
-							amQuick = amQuick,
                 )
             }
             updateTunnelConfig(tunnelConfig)
-			Result.success(Unit)
+            Result.Success(Event.Message.ConfigSaved)
         } catch (e: Exception) {
             Timber.e(e)
             val message = e.message?.substringAfter(":", missingDelimiterValue = "")
-			val stringValue =
+            Result.Error(Event.Error.ConfigParseError(message ?: ""))
-				message?.let {
-					StringValue.DynamicString(message)
-				} ?: StringValue.StringResource(R.string.unknown_error)
-			Result.failure(WgTunnelExceptions.ConfigParseError(stringValue))
         }
     }
 
     fun onPeerPublicKeyChange(index: Int, value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 proxyPeers =
                 _uiState.value.proxyPeers.update(
                     index,
@@ -340,11 +225,10 @@ constructor(
                 ),
             )
     }
-	}
 
     fun onPreSharedKeyChange(index: Int, value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 proxyPeers =
                 _uiState.value.proxyPeers.update(
                     index,
@@ -352,11 +236,10 @@ constructor(
                 ),
             )
     }
-	}
 
     fun onEndpointChange(index: Int, value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 proxyPeers =
                 _uiState.value.proxyPeers.update(
                     index,
@@ -364,11 +247,10 @@ constructor(
                 ),
             )
     }
-	}
 
     fun onAllowedIpsChange(index: Int, value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 proxyPeers =
                 _uiState.value.proxyPeers.update(
                     index,
@@ -376,11 +258,10 @@ constructor(
                 ),
             )
     }
-	}
 
     fun onPersistentKeepaliveChanged(index: Int, value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 proxyPeers =
                 _uiState.value.proxyPeers.update(
                     index,
@@ -388,26 +269,22 @@ constructor(
                 ),
             )
     }
-	}
 
     fun onDeletePeer(index: Int) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 proxyPeers = _uiState.value.proxyPeers.removeAt(index),
             )
     }
-	}
 
     fun addEmptyPeer() {
-		_uiState.update {
+        _uiState.value = _uiState.value.copy(proxyPeers = _uiState.value.proxyPeers + PeerProxy())
-			it.copy(proxyPeers = _uiState.value.proxyPeers + PeerProxy())
-		}
     }
 
     fun generateKeyPair() {
         val keyPair = KeyPair()
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 interfaceProxy =
                 _uiState.value.interfaceProxy.copy(
                     privateKey = keyPair.privateKey.toBase64(),
@@ -415,52 +292,45 @@ constructor(
                 ),
             )
     }
-	}
 
     fun onAddressesChanged(value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 interfaceProxy = _uiState.value.interfaceProxy.copy(addresses = value),
             )
     }
-	}
 
     fun onListenPortChanged(value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 interfaceProxy = _uiState.value.interfaceProxy.copy(listenPort = value),
             )
     }
-	}
 
     fun onDnsServersChanged(value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 interfaceProxy = _uiState.value.interfaceProxy.copy(dnsServers = value),
             )
     }
-	}
 
     fun onMtuChanged(value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(mtu = value))
+            _uiState.value.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(mtu = value))
-		}
     }
 
     private fun onInterfacePublicKeyChange(value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 interfaceProxy = _uiState.value.interfaceProxy.copy(publicKey = value),
             )
     }
-	}
 
     fun onPrivateKeyChange(value: String) {
-		_uiState.update {
+        _uiState.value =
-			it.copy(
+            _uiState.value.copy(
                 interfaceProxy = _uiState.value.interfaceProxy.copy(privateKey = value),
             )
-		}
         if (NumberUtils.isValidKey(value)) {
             val pair = KeyPair(Key.fromBase64(value))
             onInterfacePublicKeyChange(pair.publicKey.toBase64())
@@ -474,93 +344,6 @@ constructor(
             getAllInternetCapablePackages().filter {
                 getPackageLabel(it).lowercase().contains(query.lowercase())
             }
-		_uiState.update { it.copy(packages = packages) }
+        _uiState.value = _uiState.value.copy(packages = packages)
-	}
-
-	fun onJunkPacketCountChanged(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketCount = value),
-			)
-		}
-	}
-
-	fun onJunkPacketMinSizeChanged(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketMinSize = value),
-			)
-		}
-	}
-
-	fun onJunkPacketMaxSizeChanged(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy = _uiState.value.interfaceProxy.copy(junkPacketMaxSize = value),
-			)
-		}
-	}
-
-	fun onInitPacketJunkSizeChanged(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy = _uiState.value.interfaceProxy.copy(initPacketJunkSize = value),
-			)
-		}
-	}
-
-	fun onResponsePacketJunkSize(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy =
-				_uiState.value.interfaceProxy.copy(
-					responsePacketJunkSize = value,
-				),
-			)
-		}
-	}
-
-	fun onInitPacketMagicHeader(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy =
-				_uiState.value.interfaceProxy.copy(
-					initPacketMagicHeader = value,
-				),
-			)
-		}
-	}
-
-	fun onResponsePacketMagicHeader(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy =
-				_uiState.value.interfaceProxy.copy(
-					responsePacketMagicHeader = value,
-				),
-			)
-		}
-	}
-
-	fun onTransportPacketMagicHeader(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy =
-				_uiState.value.interfaceProxy.copy(
-					transportPacketMagicHeader = value,
-				),
-			)
-		}
-	}
-
-	fun onUnderloadPacketMagicHeader(value: String) {
-		_uiState.update {
-			it.copy(
-				interfaceProxy =
-				_uiState.value.interfaceProxy.copy(
-					underloadPacketMagicHeader = value,
-				),
-			)
-		}
     }
 }

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

@@ -1,118 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.config.model
-
-import com.wireguard.config.Interface
-
-data class InterfaceProxy(
-	val privateKey: String = "",
-	val publicKey: String = "",
-	val addresses: String = "",
-	val dnsServers: String = "",
-	val listenPort: String = "",
-	val mtu: String = "",
-	val junkPacketCount: String = "",
-	val junkPacketMinSize: String = "",
-	val junkPacketMaxSize: String = "",
-	val initPacketJunkSize: String = "",
-	val responsePacketJunkSize: String = "",
-	val initPacketMagicHeader: String = "",
-	val responsePacketMagicHeader: String = "",
-	val underloadPacketMagicHeader: String = "",
-	val transportPacketMagicHeader: 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 "",
-			)
-		}
-
-		fun from(i: org.amnezia.awg.config.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 "",
-				junkPacketCount =
-				if (i.junkPacketCount.isPresent) {
-					i.junkPacketCount.get()
-						.toString()
-				} else {
-					""
-				},
-				junkPacketMinSize =
-				if (i.junkPacketMinSize.isPresent) {
-					i.junkPacketMinSize.get()
-						.toString()
-				} else {
-					""
-				},
-				junkPacketMaxSize =
-				if (i.junkPacketMaxSize.isPresent) {
-					i.junkPacketMaxSize.get()
-						.toString()
-				} else {
-					""
-				},
-				initPacketJunkSize =
-				if (i.initPacketJunkSize.isPresent) {
-					i.initPacketJunkSize.get()
-						.toString()
-				} else {
-					""
-				},
-				responsePacketJunkSize =
-				if (i.responsePacketJunkSize.isPresent) {
-					i.responsePacketJunkSize.get()
-						.toString()
-				} else {
-					""
-				},
-				initPacketMagicHeader =
-				if (i.initPacketMagicHeader.isPresent) {
-					i.initPacketMagicHeader.get()
-						.toString()
-				} else {
-					""
-				},
-				responsePacketMagicHeader =
-				if (i.responsePacketMagicHeader.isPresent) {
-					i.responsePacketMagicHeader.get()
-						.toString()
-				} else {
-					""
-				},
-				transportPacketMagicHeader =
-				if (i.transportPacketMagicHeader.isPresent) {
-					i.transportPacketMagicHeader.get()
-						.toString()
-				} else {
-					""
-				},
-				underloadPacketMagicHeader =
-				if (i.underloadPacketMagicHeader.isPresent) {
-					i.underloadPacketMagicHeader.get()
-						.toString()
-				} else {
-					""
-				},
-			)
-		}
-	}
-}

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

@@ -1,98 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.config.model
-
-import com.wireguard.config.Peer
-
-data class PeerProxy(
-	val publicKey: String = "",
-	val preSharedKey: String = "",
-	val persistentKeepalive: String = "",
-	val endpoint: String = "",
-	val 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(),
-			)
-		}
-
-		fun from(peer: org.amnezia.awg.config.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")
-	}
-}

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

@@ -1,6 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.main
-
-enum class ConfigType {
-	AMNEZIA,
-	WIREGUARD,
-}

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

@@ -14,7 +14,6 @@ import androidx.compose.animation.slideInVertically
 import androidx.compose.animation.slideOutVertically
 import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.gestures.ScrollableDefaults
 import androidx.compose.foundation.gestures.detectTapGestures
@@ -30,11 +29,11 @@ import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.overscroll
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.ClickableText
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Create
 import androidx.compose.material.icons.filled.FileOpen
 import androidx.compose.material.icons.filled.QrCode
+import androidx.compose.material.icons.rounded.Add
 import androidx.compose.material.icons.rounded.Bolt
 import androidx.compose.material.icons.rounded.Circle
 import androidx.compose.material.icons.rounded.CopyAll
@@ -43,8 +42,10 @@ import androidx.compose.material.icons.rounded.Info
 import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material.icons.rounded.Smartphone
 import androidx.compose.material.icons.rounded.Star
+import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.FabPosition
+import androidx.compose.material3.FloatingActionButton
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
@@ -69,47 +70,40 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
-import androidx.compose.ui.input.nestedscroll.NestedScrollSource
-import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalHapticFeedback
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
-import com.iamageo.multifablibrary.FabIcon
-import com.iamageo.multifablibrary.FabOption
-import com.iamageo.multifablibrary.MultiFabItem
-import com.iamageo.multifablibrary.MultiFloatingActionButton
 import com.journeyapps.barcodescanner.ScanContract
 import com.journeyapps.barcodescanner.ScanOptions
+import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
+import com.zaneschepke.wireguardautotunnel.ui.CaptureActivityPortrait
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.RowListItem
-import com.zaneschepke.wireguardautotunnel.ui.common.dialog.InfoDialog
 import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
 import com.zaneschepke.wireguardautotunnel.ui.theme.corn
 import com.zaneschepke.wireguardautotunnel.ui.theme.mint
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.getMessage
+import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.util.Result
 import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
 import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
+import com.zaneschepke.wireguardautotunnel.util.truncateWithEllipsis
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
@@ -120,35 +114,15 @@ fun MainScreen(
     viewModel: MainViewModel = hiltViewModel(),
     appViewModel: AppViewModel,
     focusRequester: FocusRequester,
-	navController: NavController,
+    navController: NavController
 ) {
     val haptic = LocalHapticFeedback.current
     val context = LocalContext.current
     val isVisible = rememberSaveable { mutableStateOf(true) }
-	val scope = rememberCoroutineScope()
+    val scope = rememberCoroutineScope { Dispatchers.IO }
 
     val sheetState = rememberModalBottomSheetState()
     var showBottomSheet by remember { mutableStateOf(false) }
-	var configType by remember { mutableStateOf(ConfigType.WIREGUARD) }
-
-	// Nested scroll for control FAB
-	val nestedScrollConnection =
-		remember {
-			object : NestedScrollConnection {
-				override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
-					// Hide FAB
-					if (available.y < -1) {
-						isVisible.value = false
-					}
-					// Show FAB
-					if (available.y > 1) {
-						isVisible.value = true
-					}
-
-					return Offset.Zero
-				}
-			}
-		}
 
     var showDeleteTunnelAlertDialog by remember { mutableStateOf(false) }
     var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
@@ -190,9 +164,7 @@ fun MainScreen(
                                 name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
                         }
                     ) {
-						appViewModel.showSnackbarMessage(
+                        appViewModel.showSnackbarMessage(Event.Error.FileExplorerRequired.message)
-							context.getString(R.string.error_no_file_explorer),
-						)
                     }
                     return intent
                 }
@@ -200,8 +172,11 @@ fun MainScreen(
         ) { data ->
             if (data == null) return@rememberLauncherForActivityResult
             scope.launch {
-				viewModel.onTunnelFileSelected(data, configType, context).onFailure {
+                viewModel.onTunnelFileSelected(data).let {
-					appViewModel.showSnackbarMessage(it.getMessage(context))
+                    when (it) {
+                        is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
+                        is Result.Success -> {}
+                    }
                 }
             }
         }
@@ -211,37 +186,44 @@ fun MainScreen(
             onResult = {
                 if (it.contents != null) {
                     scope.launch {
-						viewModel.onTunnelQrResult(it.contents, configType).onFailure { error ->
+                        viewModel.onTunnelQrResult(it.contents).let { result ->
-							appViewModel.showSnackbarMessage(error.getMessage(context))
+                            when (result) {
+                                is Result.Success -> {}
+                                is Result.Error -> appViewModel.showSnackbarMessage(result.error.message)
+                            }
                         }
                     }
                 }
             },
         )
 
-	if (showDeleteTunnelAlertDialog) {
+    AnimatedVisibility(showDeleteTunnelAlertDialog) {
-		InfoDialog(
+        AlertDialog(
-			onDismiss = { showDeleteTunnelAlertDialog = false },
+            onDismissRequest = { showDeleteTunnelAlertDialog = false },
-			onAttest = {
+            confirmButton = {
-				selectedTunnel?.let { viewModel.onDelete(it, context) }
+                TextButton(
+                    onClick = {
+                        selectedTunnel?.let { viewModel.onDelete(it) }
                         showDeleteTunnelAlertDialog = false
                         selectedTunnel = null
                     },
+                ) {
+                    Text(text = stringResource(R.string.yes))
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showDeleteTunnelAlertDialog = false }) {
+                    Text(text = stringResource(R.string.cancel))
+                }
+            },
             title = { Text(text = stringResource(R.string.delete_tunnel)) },
-			body = { Text(text = stringResource(R.string.delete_tunnel_message)) },
+            text = { Text(text = stringResource(R.string.delete_tunnel_message)) },
-			confirmText = { Text(text = stringResource(R.string.yes)) },
         )
     }
 
     fun onTunnelToggle(checked: Boolean, tunnel: TunnelConfig) {
         if (appViewModel.isRequiredPermissionGranted()) {
-			if (checked) {
+            if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
-				viewModel.onTunnelStart(tunnel, context)
-			} else {
-				viewModel.onTunnelStop(
-					context,
-				)
-			}
         }
     }
 
@@ -249,27 +231,14 @@ fun MainScreen(
         return LoadingScreen()
     }
 
-	fun launchQrScanner() {
-		val scanOptions = ScanOptions()
-		scanOptions.setDesiredBarcodeFormats(ScanOptions.QR_CODE)
-		scanOptions.setOrientationLocked(true)
-		scanOptions.setPrompt(
-			context.getString(R.string.scanning_qr),
-		)
-		scanOptions.setBeepEnabled(false)
-		scanLauncher.launch(scanOptions)
-	}
-
     Scaffold(
         modifier =
         Modifier.pointerInput(Unit) {
-			if (uiState.tunnels.isNotEmpty()) {
             detectTapGestures(
                 onTap = {
                     selectedTunnel = null
                 },
             )
-			}
         },
         floatingActionButtonPosition = FabPosition.End,
         floatingActionButton = {
@@ -277,83 +246,49 @@ fun MainScreen(
                 visible = isVisible.value,
                 enter = slideInVertically(initialOffsetY = { it * 2 }),
                 exit = slideOutVertically(targetOffsetY = { it * 2 }),
-				modifier =
-				Modifier
-					.focusRequester(focusRequester)
-					.focusGroup(),
             ) {
                 val secondaryColor = MaterialTheme.colorScheme.secondary
-				val tvFobColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
+                val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-				val fobColor =
+                var fobColor by remember { mutableStateOf(secondaryColor) }
-					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) tvFobColor else secondaryColor
+                FloatingActionButton(
-				val fobIconColor =
-					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) Color.White else MaterialTheme.colorScheme.background
-				MultiFloatingActionButton(
-					fabIcon =
-					FabIcon(
-						iconRes = R.drawable.add,
-						iconResAfterRotate = R.drawable.close,
-						iconRotate = 180f,
-					),
-					fabOption =
-					FabOption(
-						iconTint = fobIconColor,
-						backgroundTint = fobColor,
-					),
-					itemsMultiFab =
-					listOf(
-						MultiFabItem(
-							label = {
-								Text(
-									stringResource(id = R.string.amnezia),
-									color = Color.White,
-									textAlign = TextAlign.Center,
-									modifier = Modifier.padding(end = 10.dp),
-								)
-							},
                     modifier =
-							Modifier
+                    (if (
-								.size(40.dp),
+                        WireGuardAutoTunnel.isRunningOnAndroidTv() &&
-							icon = R.drawable.add,
+                        uiState.tunnels.isEmpty()
-							value = ConfigType.AMNEZIA.name,
-							miniFabOption =
-							FabOption(
-								backgroundTint = fobColor,
-								fobIconColor,
-							),
-						),
-						MultiFabItem(
-							label = {
-								Text(
-									stringResource(id = R.string.wireguard),
-									color = Color.White,
-									textAlign = TextAlign.Center,
-									modifier = Modifier.padding(end = 10.dp),
                     )
+                        Modifier.focusRequester(focusRequester)
+                    else Modifier)
+                        .onFocusChanged {
+                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                                fobColor = if (it.isFocused) hoverColor else secondaryColor
+                            }
                         },
-							icon = R.drawable.add,
+                    onClick = { showBottomSheet = true },
-							value = ConfigType.WIREGUARD.name,
+                    containerColor = fobColor,
-							miniFabOption =
-							FabOption(
-								backgroundTint = fobColor,
-								fobIconColor,
-							),
-						),
-					),
-					onFabItemClicked = {
-						showBottomSheet = true
-						configType = ConfigType.valueOf(it.value)
-					},
                     shape = RoundedCornerShape(16.dp),
+                ) {
+                    Icon(
+                        imageVector = Icons.Rounded.Add,
+                        contentDescription = stringResource(id = R.string.add_tunnel),
+                        tint = Color.DarkGray,
                     )
                 }
+            }
         },
     ) {
+        AnimatedVisibility(uiState.tunnels.isEmpty(), exit = fadeOut(), enter = fadeIn()) {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Center,
+                modifier = Modifier
+                    .fillMaxSize(),
+            ) {
+                Text(text = stringResource(R.string.no_tunnels), fontStyle = FontStyle.Italic)
+            }
+        }
         if (showBottomSheet) {
             ModalBottomSheet(
-				onDismissRequest = {
+                onDismissRequest = { showBottomSheet = false },
-					showBottomSheet = false
-				},
                 sheetState = sheetState,
             ) {
                 // Sheet content
@@ -386,7 +321,16 @@ fun MainScreen(
                             .clickable {
                                 scope.launch {
                                     showBottomSheet = false
-									launchQrScanner()
+                                    val scanOptions = ScanOptions()
+                                    scanOptions.setDesiredBarcodeFormats(ScanOptions.QR_CODE)
+                                    scanOptions.setOrientationLocked(true)
+                                    scanOptions.setPrompt(
+                                        context.getString(R.string.scanning_qr),
+                                    )
+                                    scanOptions.setBeepEnabled(false)
+                                    scanOptions.captureActivity =
+                                        CaptureActivityPortrait::class.java
+                                    scanLauncher.launch(scanOptions)
                                 }
                             }
                             .padding(10.dp),
@@ -410,7 +354,7 @@ fun MainScreen(
                         .clickable {
                             showBottomSheet = false
                             navController.navigate(
-								"${Screen.Config.route}/${Constants.MANUAL_TUNNEL_CONFIG_ID}?configType=$configType",
+                                "${Screen.Config.route}/${Constants.MANUAL_TUNNEL_CONFIG_ID}",
                             )
                         }
                         .padding(10.dp),
@@ -433,131 +377,58 @@ fun MainScreen(
             verticalArrangement = Arrangement.Top,
             modifier =
             Modifier
-				.fillMaxSize()
+                .fillMaxWidth()
-				.overscroll(ScrollableDefaults.overscrollEffect())
+                .overscroll(ScrollableDefaults.overscrollEffect()),
-				.nestedScroll(nestedScrollConnection),
             state = rememberLazyListState(0, uiState.tunnels.count()),
             userScrollEnabled = true,
             reverseLayout = false,
             flingBehavior = ScrollableDefaults.flingBehavior(),
         ) {
-			item {
-				AnimatedVisibility(
-					uiState.tunnels.isEmpty(),
-					exit = fadeOut(),
-					enter = fadeIn(),
-				) {
-					Column(
-						horizontalAlignment = Alignment.CenterHorizontally,
-						verticalArrangement = Arrangement.Center,
-						modifier =
-						Modifier
-							.padding(top = 100.dp)
-							.fillMaxSize(),
-					) {
-						val gettingStarted =
-							buildAnnotatedString {
-								append(stringResource(id = R.string.see_the))
-								append(" ")
-								pushStringAnnotation(
-									tag = "gettingStarted",
-									annotation = stringResource(id = R.string.getting_started_url),
-								)
-								withStyle(
-									style = SpanStyle(color = MaterialTheme.colorScheme.primary),
-								) {
-									append(stringResource(id = R.string.getting_started_guide))
-								}
-								pop()
-								append(" ")
-								append(stringResource(R.string.unsure_how))
-								append(".")
-							}
-						Text(
-							text = stringResource(R.string.no_tunnels),
-							fontStyle = FontStyle.Italic,
-						)
-						ClickableText(
-							modifier =
-							Modifier
-								.padding(vertical = 10.dp, horizontal = 24.dp),
-							text = gettingStarted,
-							style =
-							MaterialTheme.typography.bodyMedium.copy(
-								color = MaterialTheme.colorScheme.onSurfaceVariant,
-								textAlign = TextAlign.Center,
-							),
-						) {
-							gettingStarted.getStringAnnotations(tag = "gettingStarted", it, it)
-								.firstOrNull()?.let { annotation ->
-									appViewModel.openWebPage(annotation.item, context)
-								}
-						}
-					}
-				}
-			}
             item {
                 if (uiState.settings.isAutoTunnelEnabled) {
-					val itemFocusRequester = remember { FocusRequester() }
+                    val autoTunnelingLabel = buildAnnotatedString {
-					val autoTunnelingLabel =
-						buildAnnotatedString {
                         append(stringResource(id = R.string.auto_tunneling))
                         append(": ")
-							if (uiState.settings.isAutoTunnelPaused) {
+                        if (uiState.settings.isAutoTunnelPaused) append(
-								append(
                             stringResource(id = R.string.paused),
-								)
+                        ) else append(
-							} else {
-								append(
                             stringResource(id = R.string.active),
                         )
                     }
-						}
                     RowListItem(
                         icon = {
                             val icon = Icons.Rounded.Bolt
                             Icon(
                                 icon,
                                 icon.name,
-								modifier =
+                                modifier = Modifier
-								Modifier
                                     .padding(end = 8.5.dp)
                                     .size(25.dp),
                                 tint =
-								if (uiState.settings.isAutoTunnelPaused) {
+                                if (uiState.settings.isAutoTunnelPaused) Color.Gray
-									Color.Gray
+                                else mint,
-								} else {
-									mint
-								},
                             )
                         },
                         text = autoTunnelingLabel.text,
                         rowButton = {
                             if (uiState.settings.isAutoTunnelPaused) {
                                 TextButton(
-									modifier = Modifier.focusRequester(itemFocusRequester),
                                     onClick = { viewModel.resumeAutoTunneling() },
                                 ) {
                                     Text(stringResource(id = R.string.resume))
                                 }
                             } else {
                                 TextButton(
-									modifier = Modifier.focusRequester(itemFocusRequester),
                                     onClick = { viewModel.pauseAutoTunneling() },
                                 ) {
                                     Text(stringResource(id = R.string.pause))
                                 }
                             }
                         },
-						onClick = {
+                        onClick = {},
-							if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-								itemFocusRequester.requestFocus()
-							}
-						},
                         onHold = {},
                         expanded = false,
                         statistics = null,
-						focusRequester = focusRequester,
                     )
                 }
             }
@@ -566,10 +437,9 @@ fun MainScreen(
                 key = { tunnel -> tunnel.id },
             ) { tunnel ->
                 val leadingIconColor =
-					(
+                    (if (
-						if (
                         uiState.vpnState.tunnelConfig?.name == tunnel.name &&
-							uiState.vpnState.status == TunnelState.UP
+                        uiState.vpnState.status == Tunnel.State.UP
                     ) {
                         uiState.vpnState.statistics
                             ?.mapPeerStats()
@@ -588,15 +458,12 @@ fun MainScreen(
                             }
                     } else {
                         Color.Gray
-						}
+                    })
-						)
-				val itemFocusRequester = remember { FocusRequester() }
                 val expanded = remember { mutableStateOf(false) }
                 RowListItem(
                     icon = {
                         val circleIcon = Icons.Rounded.Circle
-						val icon =
+                        val icon = if (tunnel.isPrimaryTunnel) {
-							if (tunnel.isPrimaryTunnel) {
                             Icons.Rounded.Star
                         } else if (tunnel.isMobileDataTunnel) {
                             Icons.Rounded.Smartphone
@@ -607,8 +474,7 @@ fun MainScreen(
                             icon,
                             icon.name,
                             tint = leadingIconColor,
-							modifier =
+                            modifier = Modifier
-							Modifier
                                 .padding(
                                     end = if (icon == circleIcon) 12.5.dp else 10.dp,
                                     start = if (icon == circleIcon) 2.5.dp else 0.dp,
@@ -616,15 +482,13 @@ fun MainScreen(
                                 .size(if (icon == circleIcon) 15.dp else 20.dp),
                         )
                     },
-					text = tunnel.name,
+                    text = tunnel.name.truncateWithEllipsis(Constants.ALLOWED_DISPLAY_NAME_LENGTH),
                     onHold = {
                         if (
-							(uiState.vpnState.status == TunnelState.UP) &&
+                            (uiState.vpnState.status == Tunnel.State.UP) &&
                             (tunnel.name == uiState.vpnState.tunnelConfig?.name)
                         ) {
-							appViewModel.showSnackbarMessage(
+                            appViewModel.showSnackbarMessage(Event.Message.TunnelOffAction.message)
-								context.getString(R.string.turn_off_tunnel),
-							)
                             return@RowListItem
                         }
                         haptic.performHapticFeedback(HapticFeedbackType.LongPress)
@@ -633,19 +497,18 @@ fun MainScreen(
                     onClick = {
                         if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                             if (
-								uiState.vpnState.status == TunnelState.UP &&
+                                uiState.vpnState.status == Tunnel.State.UP &&
                                 (uiState.vpnState.tunnelConfig?.name == tunnel.name)
                             ) {
                                 expanded.value = !expanded.value
                             }
                         } else {
                             selectedTunnel = tunnel
-							itemFocusRequester.requestFocus()
+                            focusRequester.requestFocus()
                         }
                     },
                     statistics = uiState.vpnState.statistics,
                     expanded = expanded.value,
-					focusRequester = focusRequester,
                     rowButton = {
                         if (
                             tunnel.id == selectedTunnel?.id &&
@@ -659,7 +522,7 @@ fun MainScreen(
                                             !uiState.settings.isAutoTunnelPaused
                                         ) {
                                             appViewModel.showSnackbarMessage(
-												context.getString(R.string.turn_off_tunnel),
+                                                Event.Message.AutoTunnelOffAction.message,
                                             )
                                         } else {
                                             navController.navigate(
@@ -692,17 +555,16 @@ fun MainScreen(
                         } else {
                             val checked by remember {
                                 derivedStateOf {
-									(
+                                    (uiState.vpnState.status == Tunnel.State.UP &&
-										uiState.vpnState.status == TunnelState.UP &&
+                                        tunnel.name == uiState.vpnState.tunnelConfig?.name)
-											tunnel.name == uiState.vpnState.tunnelConfig?.name
-										)
                                 }
                             }
                             if (!checked) expanded.value = false
 
                             @Composable
-							fun TunnelSwitch() = Switch(
+                            fun TunnelSwitch() =
-								modifier = Modifier.focusRequester(itemFocusRequester),
+                                Switch(
+                                    modifier = Modifier.focusRequester(focusRequester),
                                     checked = checked,
                                     onCheckedChange = { checked ->
                                         if (!checked) expanded.value = false
@@ -713,9 +575,9 @@ fun MainScreen(
                                 Row {
                                     IconButton(
                                         onClick = {
-											if (uiState.settings.isAutoTunnelEnabled && !uiState.settings.isAutoTunnelPaused) {
+                                            if (uiState.settings.isAutoTunnelEnabled) {
                                                 appViewModel.showSnackbarMessage(
-													context.getString(R.string.turn_off_auto),
+                                                    Event.Message.AutoTunnelOffAction.message,
                                                 )
                                             } else {
                                                 selectedTunnel = tunnel
@@ -735,13 +597,13 @@ fun MainScreen(
                                         modifier = Modifier.focusRequester(focusRequester),
                                         onClick = {
                                             if (
-												uiState.vpnState.status == TunnelState.UP &&
+                                                uiState.vpnState.status == Tunnel.State.UP &&
                                                 (uiState.vpnState.tunnelConfig?.name == tunnel.name)
                                             ) {
                                                 expanded.value = !expanded.value
                                             } else {
                                                 appViewModel.showSnackbarMessage(
-													context.getString(R.string.turn_on_tunnel),
+                                                    Event.Message.TunnelOnAction.message,
                                                 )
                                             }
                                         },
@@ -758,11 +620,11 @@ fun MainScreen(
                                     IconButton(
                                         onClick = {
                                             if (
-												uiState.vpnState.status == TunnelState.UP &&
+                                                uiState.vpnState.status == Tunnel.State.UP &&
                                                 tunnel.name == uiState.vpnState.tunnelConfig?.name
                                             ) {
                                                 appViewModel.showSnackbarMessage(
-													context.getString(R.string.turn_off_tunnel),
+                                                    Event.Message.TunnelOffAction.message,
                                                 )
                                             } else {
                                                 selectedTunnel = tunnel

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

@@ -1,6 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.main
 
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnState
 import com.zaneschepke.wireguardautotunnel.util.TunnelConfigs
 
@@ -8,5 +8,5 @@ data class MainUiState(
     val settings: Settings = Settings(),
     val tunnels: TunnelConfigs = emptyList(),
     val vpnState: VpnState = VpnState(),
-	val loading: Boolean = true,
+    val loading: Boolean = true
 )

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

@@ -1,5 +1,6 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.main
 
+import android.app.Application
 import android.content.Context
 import android.database.Cursor
 import android.net.Uri
@@ -8,18 +9,17 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wireguard.config.Config
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.Settings
+import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
+import com.zaneschepke.wireguardautotunnel.util.Event
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
+import com.zaneschepke.wireguardautotunnel.util.Result
-import com.zaneschepke.wireguardautotunnel.util.toWgQuickString
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
@@ -34,11 +34,12 @@ import javax.inject.Inject
 class MainViewModel
 @Inject
 constructor(
+    private val application: Application,
     private val appDataRepository: AppDataRepository,
     private val serviceManager: ServiceManager,
-	val vpnService: VpnService,
+    val vpnService: VpnService
-	@IoDispatcher private val ioDispatcher: CoroutineDispatcher,
 ) : ViewModel() {
+
     val uiState =
         combine(
             appDataRepository.settings.getSettingsFlow(),
@@ -53,20 +54,21 @@ constructor(
                 MainUiState(),
             )
 
-	private fun stopWatcherService(context: Context) {
+    private fun stopWatcherService() =
-		serviceManager.stopWatcherService(context)
+        viewModelScope.launch(Dispatchers.IO) {
+            serviceManager.stopWatcherService(application.applicationContext)
         }
 
-	fun onDelete(tunnel: TunnelConfig, context: Context) {
+    fun onDelete(tunnel: TunnelConfig) {
-		viewModelScope.launch {
+        viewModelScope.launch(Dispatchers.IO) {
             val settings = appDataRepository.settings.getSettings()
             val isPrimary = tunnel.isPrimaryTunnel
             if (appDataRepository.tunnels.count() == 1 || isPrimary) {
-				stopWatcherService(context)
+                stopWatcherService()
                 resetTunnelSetting(settings)
             }
             appDataRepository.tunnels.delete(tunnel)
-			WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
         }
     }
 
@@ -79,168 +81,80 @@ constructor(
         )
     }
 
-	fun onTunnelStart(tunnelConfig: TunnelConfig, context: Context) = viewModelScope.launch {
+    fun onTunnelStart(tunnelConfig: TunnelConfig) =
+        viewModelScope.launch(Dispatchers.IO) {
             Timber.d("On start called!")
             serviceManager.startVpnService(
-			context,
+                application.applicationContext,
                 tunnelConfig.id,
                 isManualStart = true,
             )
         }
 
-	fun onTunnelStop(context: Context) = viewModelScope.launch {
+
+    fun onTunnelStop() =
+        viewModelScope.launch(Dispatchers.IO) {
             Timber.i("Stopping active tunnel")
-		serviceManager.stopVpnService(context, isManualStop = true)
+            serviceManager.stopVpnService(application.applicationContext, isManualStop = true)
         }
 
-	private fun validateConfigString(config: String, configType: ConfigType) {
+    private fun validateConfigString(config: String) {
-		when (configType) {
+        TunnelConfig.configFromQuick(config)
-			ConfigType.AMNEZIA -> TunnelConfig.configFromAmQuick(config)
-			ConfigType.WIREGUARD -> TunnelConfig.configFromWgQuick(config)
-		}
     }
 
-	private fun generateQrCodeDefaultName(config: String, configType: ConfigType): String {
+    suspend fun onTunnelQrResult(result: String): Result<Unit> {
         return try {
-			when (configType) {
+            validateConfigString(result)
-				ConfigType.AMNEZIA -> {
-					TunnelConfig.configFromAmQuick(config).peers[0].endpoint.get().host
-				}
-
-				ConfigType.WIREGUARD -> {
-					TunnelConfig.configFromWgQuick(config).peers[0].endpoint.get().host
-				}
-			}
-		} catch (e: Exception) {
-			Timber.e(e)
-			NumberUtils.generateRandomTunnelName()
-		}
-	}
-
-	private fun generateQrCodeTunnelName(config: String, configType: ConfigType): String {
-		var defaultName = generateQrCodeDefaultName(config, configType)
-		val lines = config.lines().toMutableList()
-		val linesIterator = lines.iterator()
-		while (linesIterator.hasNext()) {
-			val next = linesIterator.next()
-			if (next.contains(Constants.QR_CODE_NAME_PROPERTY)) {
-				defaultName = next.substringAfter(Constants.QR_CODE_NAME_PROPERTY).trim()
-				break
-			}
-		}
-		return defaultName
-	}
-
-	suspend fun onTunnelQrResult(result: String, configType: ConfigType): Result<Unit> {
-		return withContext(ioDispatcher) {
-			try {
-				validateConfigString(result, configType)
-				val tunnelName =
-					makeTunnelNameUnique(generateQrCodeTunnelName(result, configType))
             val tunnelConfig =
-					when (configType) {
+                TunnelConfig(name = NumberUtils.generateRandomTunnelName(), wgQuick = result)
-						ConfigType.AMNEZIA -> {
-							TunnelConfig(
-								name = tunnelName,
-								amQuick = result,
-								wgQuick =
-								TunnelConfig.configFromAmQuick(
-									result,
-								).toWgQuickString(),
-							)
-						}
-
-						ConfigType.WIREGUARD ->
-							TunnelConfig(
-								name = tunnelName,
-								wgQuick = result,
-							)
-					}
             addTunnel(tunnelConfig)
-				Result.success(Unit)
+            Result.Success(Unit)
         } catch (e: Exception) {
             Timber.e(e)
-				Result.failure(WgTunnelExceptions.InvalidQrCode())
+            Result.Error(Event.Error.InvalidQrCode)
-			}
-		}
-	}
-
-	private suspend fun makeTunnelNameUnique(name: String): String {
-		return withContext(ioDispatcher) {
-			val tunnels = appDataRepository.tunnels.getAll()
-			var tunnelName = name
-			var num = 1
-			while (tunnels.any { it.name == tunnelName }) {
-				tunnelName = name + "($num)"
-				num++
-			}
-			tunnelName
         }
     }
 
-	private fun saveTunnelConfigFromStream(stream: InputStream, fileName: String, type: ConfigType) {
+    private suspend fun saveTunnelConfigFromStream(stream: InputStream, fileName: String) {
-		var amQuick: String? = null
+        val bufferReader = stream.bufferedReader(charset = Charsets.UTF_8)
-		val wgQuick =
+        val config = Config.parse(bufferReader)
-			stream.use {
+        val tunnelName = getNameFromFileName(fileName)
-				when (type) {
+        addTunnel(TunnelConfig(name = tunnelName, wgQuick = config.toWgQuickString()))
-					ConfigType.AMNEZIA -> {
+        withContext(Dispatchers.IO) { stream.close() }
-						val config = org.amnezia.awg.config.Config.parse(it)
-						amQuick = config.toAwgQuickString()
-						config.toWgQuickString()
     }
 
-					ConfigType.WIREGUARD -> {
+    private fun getInputStreamFromUri(uri: Uri): InputStream? {
-						Config.parse(it).toWgQuickString()
+        return application.applicationContext.contentResolver.openInputStream(uri)
-					}
-				}
-			}
-		viewModelScope.launch {
-			val tunnelName = makeTunnelNameUnique(getNameFromFileName(fileName))
-			addTunnel(
-				TunnelConfig(
-					name = tunnelName,
-					wgQuick = wgQuick,
-					amQuick = amQuick ?: TunnelConfig.AM_QUICK_DEFAULT,
-				),
-			)
-		}
     }
 
-	private fun getInputStreamFromUri(uri: Uri, context: Context): InputStream? {
+    suspend fun onTunnelFileSelected(uri: Uri): Result<Unit> {
-		return context.applicationContext.contentResolver.openInputStream(uri)
-	}
-
-	suspend fun onTunnelFileSelected(uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
-		return withContext(ioDispatcher) {
         try {
             if (isValidUriContentScheme(uri)) {
-					val fileName = getFileName(context, uri)
+                val fileName = getFileName(application.applicationContext, uri)
-					return@withContext when (getFileExtensionFromFileName(fileName)) {
+                when (getFileExtensionFromFileName(fileName)) {
                     Constants.CONF_FILE_EXTENSION ->
-							saveTunnelFromConfUri(fileName, uri, configType, context)
+                        saveTunnelFromConfUri(fileName, uri).let {
-
+                            when (it) {
-						Constants.ZIP_FILE_EXTENSION ->
+                                is Result.Error -> return Result.Error(Event.Error.FileReadFailed)
-							saveTunnelsFromZipUri(
+                                is Result.Success -> return it
-								uri,
-								configType,
-								context,
-							)
-
-						else -> Result.failure(WgTunnelExceptions.InvalidFileExtension())
                             }
+                        }
+
+                    Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(uri)
+                    else -> return Result.Error(Event.Error.InvalidFileExtension)
+                }
+                return Result.Success(Unit)
             } else {
-					Result.failure(WgTunnelExceptions.InvalidFileExtension())
+                return Result.Error(Event.Error.InvalidFileExtension)
             }
         } catch (e: Exception) {
             Timber.e(e)
-				Result.failure(WgTunnelExceptions.FileReadFailed())
+            return Result.Error(Event.Error.FileReadFailed)
-			}
         }
     }
 
-	private suspend fun saveTunnelsFromZipUri(uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
+    private suspend fun saveTunnelsFromZipUri(uri: Uri) {
-		return withContext(ioDispatcher) {
+        ZipInputStream(getInputStreamFromUri(uri)).use { zip ->
-			ZipInputStream(getInputStreamFromUri(uri, context)).use { zip ->
             generateSequence { zip.nextEntry }
                 .filterNot {
                     it.isDirectory ||
@@ -248,79 +162,43 @@ constructor(
                 }
                 .forEach {
                     val name = getNameFromFileName(it.name)
-						withContext(viewModelScope.coroutineContext) {
+                    val config = Config.parse(zip)
-							try {
+                    viewModelScope.launch(Dispatchers.IO) {
-								var amQuick: String? = null
+                        addTunnel(TunnelConfig(name = name, wgQuick = config.toWgQuickString()))
-								val wgQuick =
-									when (configType) {
-										ConfigType.AMNEZIA -> {
-											val config =
-												org.amnezia.awg.config.Config.parse(
-													zip,
-												)
-											amQuick = config.toAwgQuickString()
-											config.toWgQuickString()
                     }
-
-										ConfigType.WIREGUARD -> {
-											Config.parse(zip).toWgQuickString()
-										}
-									}
-								addTunnel(
-									TunnelConfig(
-										name = makeTunnelNameUnique(name),
-										wgQuick = wgQuick,
-										amQuick = amQuick ?: TunnelConfig.AM_QUICK_DEFAULT,
-									),
-								)
-								Result.success(Unit)
-							} catch (e: Exception) {
-								Result.failure(WgTunnelExceptions.FileReadFailed())
-							}
-						}
-					}
-				Result.success(Unit)
                 }
         }
     }
 
-	private suspend fun saveTunnelFromConfUri(name: String, uri: Uri, configType: ConfigType, context: Context): Result<Unit> {
+    private suspend fun saveTunnelFromConfUri(name: String, uri: Uri): Result<Unit> {
-		return withContext(ioDispatcher) {
+        val stream = getInputStreamFromUri(uri)
-			val stream = getInputStreamFromUri(uri, context)
+        return if (stream != null) {
-			return@withContext if (stream != null) {
+            saveTunnelConfigFromStream(stream, name)
-				try {
+            Result.Success(Unit)
-					saveTunnelConfigFromStream(stream, name, configType)
-				} catch (e: Exception) {
-					return@withContext Result.failure(WgTunnelExceptions.ConfigParseError())
-				}
-				Result.success(Unit)
         } else {
-				Result.failure(WgTunnelExceptions.FileReadFailed())
+            Result.Error(Event.Error.FileReadFailed)
-			}
         }
     }
 
-	private fun addTunnel(tunnelConfig: TunnelConfig) = viewModelScope.launch {
+    private suspend fun addTunnel(tunnelConfig: TunnelConfig) {
         val firstTunnel = appDataRepository.tunnels.count() == 0
         saveTunnel(tunnelConfig)
-		if (firstTunnel) WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+        if (firstTunnel) WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
     }
 
-	fun pauseAutoTunneling() = viewModelScope.launch {
+    fun pauseAutoTunneling() =
-		appDataRepository.settings.save(
+        viewModelScope.launch {
-			uiState.value.settings.copy(isAutoTunnelPaused = true),
+            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = true))
-		)
+            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate(application)
-		WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
         }
 
-	fun resumeAutoTunneling() = viewModelScope.launch {
+    fun resumeAutoTunneling() =
-		appDataRepository.settings.save(
+        viewModelScope.launch {
-			uiState.value.settings.copy(isAutoTunnelPaused = false),
+            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = false))
-		)
+            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate(application)
-		WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate()
         }
 
-	private fun saveTunnel(tunnelConfig: TunnelConfig) = viewModelScope.launch {
+    private suspend fun saveTunnel(tunnelConfig: TunnelConfig) {
         appDataRepository.tunnels.save(tunnelConfig)
     }
 
@@ -345,12 +223,8 @@ constructor(
             val index = getDisplayNameColumnIndex(cursor)
             if (index != null) {
                 cursor.getString(index)
-			} else {
+            } else null
-				null
+        } else null
-			}
-		} else {
-			null
-		}
     }
 
     private fun isValidUriContentScheme(uri: Uri): Boolean {
@@ -365,16 +239,18 @@ constructor(
         return fileName.substring(0, fileName.lastIndexOf('.'))
     }
 
-	private fun getFileExtensionFromFileName(fileName: String): String? {
+    private fun getFileExtensionFromFileName(fileName: String): String {
         return try {
             fileName.substring(fileName.lastIndexOf('.'))
         } catch (e: Exception) {
             Timber.e(e)
-			null
+            ""
         }
     }
 
-	private fun saveSettings(settings: Settings) = viewModelScope.launch { appDataRepository.settings.save(settings) }
+    private fun saveSettings(settings: Settings) =
+        viewModelScope.launch(Dispatchers.IO) { appDataRepository.settings.save(settings) }
+
 
     fun onCopyTunnel(tunnel: TunnelConfig?) = viewModelScope.launch {
         tunnel?.let {

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

@@ -1,22 +1,17 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.options
 
-import android.annotation.SuppressLint
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.IntrinsicSize
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.KeyboardActions
@@ -29,10 +24,9 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.Scaffold
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.material3.surfaceColorAtElevation
+import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -45,21 +39,15 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
-import com.iamageo.multifablibrary.FabIcon
-import com.iamageo.multifablibrary.FabOption
-import com.iamageo.multifablibrary.MultiFabItem
-import com.iamageo.multifablibrary.MultiFloatingActionButton
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
@@ -67,13 +55,11 @@ import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.ClickableIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationToggle
 import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
-import com.zaneschepke.wireguardautotunnel.ui.screens.main.ConfigType
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.getMessage
+import com.zaneschepke.wireguardautotunnel.util.Result
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
-@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
 @OptIn(ExperimentalLayoutApi::class)
 @Composable
 fun OptionsScreen(
@@ -81,12 +67,10 @@ fun OptionsScreen(
     navController: NavController,
     appViewModel: AppViewModel,
     focusRequester: FocusRequester,
-	tunnelId: String,
+    tunnelId: String
 ) {
     val scrollState = rememberScrollState()
     val uiState by optionsViewModel.uiState.collectAsStateWithLifecycle()
-	val context = LocalContext.current
-
     val interactionSource = remember { MutableInteractionSource() }
     val scope = rememberCoroutineScope()
     val focusManager = LocalFocusManager.current
@@ -106,95 +90,16 @@ fun OptionsScreen(
     fun saveTrustedSSID() {
         if (currentText.isNotEmpty()) {
             scope.launch {
-				optionsViewModel.onSaveRunSSID(currentText).onSuccess {
+                optionsViewModel.onSaveRunSSID(currentText).let {
-					currentText = ""
+                    when (it) {
-				}.onFailure {
+                        is Result.Success -> currentText = ""
-					appViewModel.showSnackbarMessage(it.getMessage(context))
+                        is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
+                    }
                 }
             }
         }
     }
 
-	Scaffold(
-		floatingActionButton = {
-			val secondaryColor = MaterialTheme.colorScheme.secondary
-			val tvFobColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-			val fobColor =
-				if (WireGuardAutoTunnel.isRunningOnAndroidTv()) tvFobColor else secondaryColor
-			val fobIconColor =
-				if (WireGuardAutoTunnel.isRunningOnAndroidTv()) Color.White else MaterialTheme.colorScheme.background
-			AnimatedVisibility(
-				visible = true,
-				enter = slideInVertically(initialOffsetY = { it * 2 }),
-				exit = slideOutVertically(targetOffsetY = { it * 2 }),
-				modifier =
-				Modifier
-					.focusRequester(focusRequester)
-					.focusGroup(),
-			) {
-				MultiFloatingActionButton(
-					fabIcon =
-					FabIcon(
-						iconRes = R.drawable.edit,
-						iconResAfterRotate = R.drawable.close,
-						iconRotate = 180f,
-					),
-					fabOption =
-					FabOption(
-						iconTint = fobIconColor,
-						backgroundTint = fobColor,
-					),
-					itemsMultiFab =
-					listOf(
-						MultiFabItem(
-							label = {
-								Text(
-									stringResource(id = R.string.amnezia),
-									color = Color.White,
-									textAlign = TextAlign.Center,
-									modifier = Modifier.padding(end = 10.dp),
-								)
-							},
-							modifier =
-							Modifier
-								.size(40.dp),
-							icon = R.drawable.edit,
-							value = ConfigType.AMNEZIA.name,
-							miniFabOption =
-							FabOption(
-								backgroundTint = fobColor,
-								fobIconColor,
-							),
-						),
-						MultiFabItem(
-							label = {
-								Text(
-									stringResource(id = R.string.wireguard),
-									color = Color.White,
-									textAlign = TextAlign.Center,
-									modifier = Modifier.padding(end = 10.dp),
-								)
-							},
-							icon = R.drawable.edit,
-							value = ConfigType.WIREGUARD.name,
-							miniFabOption =
-							FabOption(
-								backgroundTint = fobColor,
-								fobIconColor,
-							),
-						),
-					),
-					onFabItemClicked = {
-						val configType = ConfigType.valueOf(it.value)
-						navController.navigate(
-							"${Screen.Config.route}/$tunnelId?configType=${configType.name}",
-						)
-					},
-					shape = RoundedCornerShape(16.dp),
-				)
-			}
-		},
-	) {
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.Top,
@@ -215,8 +120,7 @@ fun OptionsScreen(
             shape = RoundedCornerShape(12.dp),
             color = MaterialTheme.colorScheme.surface,
             modifier =
-				(
+            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                 Modifier
                     .height(IntrinsicSize.Min)
                     .fillMaxWidth(fillMaxWidth)
@@ -225,8 +129,7 @@ fun OptionsScreen(
                 Modifier
                     .fillMaxWidth(fillMaxWidth)
                     .padding(top = 20.dp)
-					}
+            })
-					)
                 .padding(bottom = 10.dp),
         ) {
             Column(
@@ -242,12 +145,28 @@ fun OptionsScreen(
                     stringResource(R.string.set_primary_tunnel),
                     enabled = true,
                     checked = uiState.isDefaultTunnel,
-						modifier =
+                    modifier = Modifier
-						Modifier
                         .focusRequester(focusRequester),
                     padding = screenPadding,
                     onCheckChanged = { optionsViewModel.onTogglePrimaryTunnel() },
                 )
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(top = 5.dp),
+                    horizontalArrangement = Arrangement.Center,
+                ) {
+                    TextButton(
+                        onClick = {
+                            navController.navigate(
+                                "${Screen.Config.route}/${tunnelId}",
+                            )
+                        },
+                    ) {
+                        Text(stringResource(R.string.edit_tunnel))
+                    }
+                }
             }
         }
         Surface(
@@ -256,8 +175,7 @@ fun OptionsScreen(
             shape = RoundedCornerShape(12.dp),
             color = MaterialTheme.colorScheme.surface,
             modifier =
-				(
+            (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                 Modifier
                     .height(IntrinsicSize.Min)
                     .fillMaxWidth(fillMaxWidth)
@@ -266,8 +184,7 @@ fun OptionsScreen(
                 Modifier
                     .fillMaxWidth(fillMaxWidth)
                     .padding(top = 20.dp)
-					}
+            })
-					)
                 .padding(bottom = 10.dp),
         ) {
             Column(
@@ -288,8 +205,7 @@ fun OptionsScreen(
                 )
                 Column {
                     FlowRow(
-							modifier =
+                        modifier = Modifier
-							Modifier
                             .padding(screenPadding)
                             .fillMaxWidth(),
                         horizontalArrangement = Arrangement.spacedBy(5.dp),
@@ -305,6 +221,7 @@ fun OptionsScreen(
                                 onIconClick = {
                                     if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
                                     optionsViewModel.onDeleteRunSSID(ssid)
+
                                 },
                                 text = ssid,
                                 icon = Icons.Filled.Close,
@@ -368,4 +285,3 @@ fun OptionsScreen(
         }
     }
 }
-}

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

@@ -1,9 +1,9 @@
 package com.zaneschepke.wireguardautotunnel.ui.screens.options
 
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 
 data class OptionsUiState(
     val id: String? = null,
     val tunnel: TunnelConfig? = null,
-	val isDefaultTunnel: Boolean = false,
+    val isDefaultTunnel: Boolean = false
 )

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

@@ -4,30 +4,30 @@ import androidx.compose.ui.util.fastFirstOrNull
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
+import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.util.Result
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
-import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 @HiltViewModel
-class OptionsViewModel
+class OptionsViewModel @Inject
-@Inject
 constructor(
-	private val appDataRepository: AppDataRepository,
+    private val appDataRepository: AppDataRepository
 ) : ViewModel() {
+
     private val _optionState = MutableStateFlow(OptionsUiState())
 
-	val uiState =
+    val uiState = combine(
-		combine(
         appDataRepository.tunnels.getTunnelConfigsFlow(),
         _optionState,
     ) { tunnels, optionState ->
@@ -35,9 +35,7 @@ constructor(
             val tunnelConfig = tunnels.fastFirstOrNull { it.id.toString() == optionState.id }
             val isPrimaryTunnel = tunnelConfig?.isPrimaryTunnel == true
             OptionsUiState(optionState.id, tunnelConfig, isPrimaryTunnel)
-			} else {
+        } else OptionsUiState()
-				OptionsUiState()
-			}
     }.stateIn(
         viewModelScope,
         SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
@@ -45,25 +43,22 @@ constructor(
     )
 
     fun init(tunnelId: String) {
-		_optionState.update {
+        _optionState.value = _optionState.value.copy(
-			it.copy(
             id = tunnelId,
         )
     }
-	}
 
-	fun onDeleteRunSSID(ssid: String) = viewModelScope.launch {
+    fun onDeleteRunSSID(ssid: String) = viewModelScope.launch(Dispatchers.IO) {
         uiState.value.tunnel?.let {
             appDataRepository.tunnels.save(
-				tunnelConfig =
+                tunnelConfig = it.copy(
-				it.copy(
                     tunnelNetworks = (uiState.value.tunnel!!.tunnelNetworks - ssid).toMutableList(),
                 ),
             )
         }
     }
 
-	private fun saveTunnel(tunnelConfig: TunnelConfig?) = viewModelScope.launch {
+    private fun saveTunnel(tunnelConfig: TunnelConfig?) = viewModelScope.launch(Dispatchers.IO) {
         tunnelConfig?.let {
             appDataRepository.tunnels.save(it)
         }
@@ -71,32 +66,28 @@ constructor(
 
     suspend fun onSaveRunSSID(ssid: String): Result<Unit> {
         val trimmed = ssid.trim()
-		val tunnelsWithName =
+        val tunnelsWithName = withContext(viewModelScope.coroutineContext) {
-			withContext(viewModelScope.coroutineContext) {
             appDataRepository.tunnels.findByTunnelNetworksName(trimmed)
         }
         return if (uiState.value.tunnel?.tunnelNetworks?.contains(trimmed) != true &&
-			tunnelsWithName.isEmpty()
+            tunnelsWithName.isEmpty()) {
-		) {
             uiState.value.tunnel?.tunnelNetworks?.add(trimmed)
             saveTunnel(uiState.value.tunnel)
-			Result.success(Unit)
+            Result.Success(Unit)
         } else {
-			Result.failure(WgTunnelExceptions.SsidConflict())
+            Result.Error(Event.Error.SsidConflict)
         }
     }
 
-	fun onToggleIsMobileDataTunnel() = viewModelScope.launch {
+    fun onToggleIsMobileDataTunnel() = viewModelScope.launch(Dispatchers.IO) {
         uiState.value.tunnel?.let {
             if (it.isMobileDataTunnel) {
                 appDataRepository.tunnels.updateMobileDataTunnel(null)
-			} else {
+            } else appDataRepository.tunnels.updateMobileDataTunnel(it)
-				appDataRepository.tunnels.updateMobileDataTunnel(it)
-			}
         }
     }
 
-	fun onTogglePrimaryTunnel() = viewModelScope.launch {
+    fun onTogglePrimaryTunnel() = viewModelScope.launch(Dispatchers.IO) {
         if (uiState.value.tunnel != null) {
             appDataRepository.tunnels.updatePrimaryTunnel(
                 when (uiState.value.isDefaultTunnel) {
@@ -104,7 +95,7 @@ constructor(
                     false -> uiState.value.tunnel
                 },
             )
-			WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
+            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(WireGuardAutoTunnel.instance)
         }
     }
 }

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

@@ -19,14 +19,9 @@ fun PinLockScreen(navController: NavController, appViewModel: AppViewModel) {
     PinLock(
         title = { pinExists ->
             Text(
-				text =
+                text = if (pinExists) stringResource(id = R.string.enter_pin) else stringResource(
-				if (pinExists) {
-					stringResource(id = R.string.enter_pin)
-				} else {
-					stringResource(
                     id = R.string.create_pin,
-					)
+                ),
-				},
             )
         },
         color = MaterialTheme.colorScheme.surface,
@@ -40,6 +35,7 @@ fun PinLockScreen(navController: NavController, appViewModel: AppViewModel) {
                     navController.navigate(Screen.Main.route)
                 }
             }
+
         },
         onPinIncorrect = {
             // pin is incorrect, show error

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

@@ -44,7 +44,6 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -71,19 +70,23 @@ import androidx.navigation.NavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
+import com.wireguard.android.backend.Tunnel
+import com.wireguard.android.backend.WgQuickBackend
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.ClickableIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationToggle
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.AuthorizationPrompt
 import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
-import com.zaneschepke.wireguardautotunnel.util.getMessage
+import com.zaneschepke.wireguardautotunnel.util.Event
+import com.zaneschepke.wireguardautotunnel.util.FileUtils
+import com.zaneschepke.wireguardautotunnel.util.Result
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import timber.log.Timber
+import xyz.teamgravity.pin_lock_compose.PinManager
 import java.io.File
 
 @OptIn(
@@ -97,14 +100,14 @@ fun SettingsScreen(
     navController: NavController,
     focusRequester: FocusRequester,
 ) {
+    val scope = rememberCoroutineScope { Dispatchers.IO }
     val context = LocalContext.current
     val focusManager = LocalFocusManager.current
-	val scope = rememberCoroutineScope()
     val scrollState = rememberScrollState()
     val interactionSource = remember { MutableInteractionSource() }
+    val pinExists = remember { mutableStateOf(PinManager.pinExists()) }
 
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-	val kernelSupport by viewModel.kernelSupport.collectAsStateWithLifecycle()
 
     val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
     var currentText by remember { mutableStateOf("") }
@@ -116,14 +119,8 @@ fun SettingsScreen(
     val screenPadding = 5.dp
     val fillMaxWidth = .85f
 
-	LaunchedEffect(Unit) {
-		viewModel.checkKernelSupport()
-	}
-
     val startForResult =
-		rememberLauncherForActivityResult(
+        rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
-			ActivityResultContracts.StartActivityForResult(),
-		) { result: ActivityResult ->
             if (result.resultCode == Activity.RESULT_OK) {
                 result.data
                 // Handle the Intent
@@ -133,38 +130,16 @@ fun SettingsScreen(
 
     fun exportAllConfigs() {
         try {
-			val wgFiles =
+            val files = uiState.tunnels.map { File(context.cacheDir, "${it.name}.conf") }
-				uiState.tunnels.map { config ->
+            files.forEachIndexed { index, file ->
-					val file = File(context.cacheDir, "${config.name}-wg.conf")
+                file.outputStream().use { it.write(uiState.tunnels[index].wgQuick.toByteArray()) }
-					file.outputStream().use {
-						it.write(config.wgQuick.toByteArray())
             }
-					file
+            FileUtils.saveFilesToZip(context, files)
-				}
-			val amFiles =
-				uiState.tunnels.mapNotNull { config ->
-					if (config.amQuick != TunnelConfig.AM_QUICK_DEFAULT) {
-						val file = File(context.cacheDir, "${config.name}-am.conf")
-						file.outputStream().use {
-							it.write(config.amQuick.toByteArray())
-						}
-						file
-					} else {
-						null
-					}
-				}
-			scope.launch {
-				viewModel.onExportTunnels(wgFiles + amFiles).onFailure {
-					appViewModel.showSnackbarMessage(it.getMessage(context))
-				}.onSuccess {
             didExportFiles = true
-					appViewModel.showSnackbarMessage(
+            appViewModel.showSnackbarMessage(Event.Message.ConfigsExported.message)
-						context.getString(R.string.exported_configs_message),
-					)
-				}
-			}
         } catch (e: Exception) {
             Timber.e(e)
+            appViewModel.showSnackbarMessage(Event.Error.Exception(e).message)
         }
     }
 
@@ -185,7 +160,7 @@ fun SettingsScreen(
     fun handleAutoTunnelToggle() {
         if (uiState.isBatteryOptimizeDisableShown || isBatteryOptimizationsDisabled()) {
             if (appViewModel.isRequiredPermissionGranted()) {
-				viewModel.onToggleAutoTunnel(context)
+                viewModel.onToggleAutoTunnel()
             }
         } else {
             requestBatteryOptimizationsDisabled()
@@ -194,19 +169,22 @@ fun SettingsScreen(
 
     fun saveTrustedSSID() {
         if (currentText.isNotEmpty()) {
-			viewModel.onSaveTrustedSSID(currentText).onSuccess {
+            viewModel.onSaveTrustedSSID(currentText).let {
-				currentText = ""
+                when (it) {
-			}.onFailure {
+                    is Result.Success -> currentText = ""
-				appViewModel.showSnackbarMessage(it.getMessage(context))
+                    is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
+                }
             }
         }
     }
 
     fun openSettings() {
+        scope.launch {
             val intentSettings = Intent(ACTION_APPLICATION_DETAILS_SETTINGS)
             intentSettings.data = Uri.fromParts("package", context.packageName, null)
             context.startActivity(intentSettings)
         }
+    }
 
     fun checkFineLocationGranted() {
         isBackgroundLocationGranted =
@@ -268,16 +246,14 @@ fun SettingsScreen(
         Column(
             horizontalAlignment = Alignment.CenterHorizontally,
             verticalArrangement = Arrangement.Top,
-			modifier =
+            modifier = Modifier
-			Modifier
                 .fillMaxSize()
                 .verticalScroll(scrollState),
         ) {
             Icon(
                 Icons.Rounded.LocationOff,
                 contentDescription = stringResource(id = R.string.map),
-				modifier =
+                modifier = Modifier
-				Modifier
                     .padding(30.dp)
                     .size(128.dp),
             )
@@ -331,15 +307,11 @@ fun SettingsScreen(
             },
             onError = { _ ->
                 showAuthPrompt = false
-				appViewModel.showSnackbarMessage(
+                appViewModel.showSnackbarMessage(Event.Error.AuthenticationFailed.message)
-					context.getString(R.string.error_authentication_failed),
-				)
             },
             onFailure = {
                 showAuthPrompt = false
-				appViewModel.showSnackbarMessage(
+                appViewModel.showSnackbarMessage(Event.Error.AuthorizationFailed.message)
-					context.getString(R.string.error_authorization_failed),
-				)
             },
         )
     }
@@ -379,8 +351,7 @@ fun SettingsScreen(
                 shape = RoundedCornerShape(12.dp),
                 color = MaterialTheme.colorScheme.surface,
                 modifier =
-				(
+                (if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-					if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                     Modifier
                         .height(IntrinsicSize.Min)
                         .fillMaxWidth(fillMaxWidth)
@@ -389,8 +360,7 @@ fun SettingsScreen(
                     Modifier
                         .fillMaxWidth(fillMaxWidth)
                         .padding(top = 20.dp)
-					}
+                })
-					)
                     .padding(bottom = 10.dp),
             ) {
                 Column(
@@ -405,26 +375,21 @@ fun SettingsScreen(
                     ConfigurationToggle(
                         stringResource(id = R.string.tunnel_on_wifi),
                         enabled =
-						!(
+                        !(uiState.settings.isAutoTunnelEnabled ||
-							uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
-								uiState.settings.isAlwaysOnVpnEnabled
-							),
                         checked = uiState.settings.isTunnelOnWifiEnabled,
                         padding = screenPadding,
                         onCheckChanged = { viewModel.onToggleTunnelOnWifi() },
                         modifier =
-						if (uiState.settings.isAutoTunnelEnabled) {
+                        if (uiState.settings.isAutoTunnelEnabled) Modifier
+                        else
                             Modifier
-						} else {
+                                .focusRequester(focusRequester),
-							Modifier
-								.focusRequester(focusRequester)
-						},
                     )
                     AnimatedVisibility(visible = uiState.settings.isTunnelOnWifiEnabled) {
                         Column {
                             FlowRow(
-								modifier =
+                                modifier = Modifier
-								Modifier
                                     .padding(screenPadding)
                                     .fillMaxWidth(),
                                 horizontalArrangement = Arrangement.spacedBy(5.dp),
@@ -440,14 +405,13 @@ fun SettingsScreen(
                                         onIconClick = {
                                             if (WireGuardAutoTunnel.isRunningOnAndroidTv()) focusRequester.requestFocus()
                                             viewModel.onDeleteTrustedSSID(ssid)
+
                                         },
                                         text = ssid,
                                         icon = Icons.Filled.Close,
                                         enabled =
-										!(
+                                        !(uiState.settings.isAutoTunnelEnabled ||
-											uiState.settings.isAutoTunnelEnabled ||
+                                            uiState.settings.isAlwaysOnVpnEnabled),
-												uiState.settings.isAlwaysOnVpnEnabled
-											),
                                     )
                                 }
                                 if (uiState.settings.trustedNetworkSSIDs.isEmpty()) {
@@ -460,10 +424,8 @@ fun SettingsScreen(
                             }
                             OutlinedTextField(
                                 enabled =
-								!(
+                                !(uiState.settings.isAutoTunnelEnabled ||
-									uiState.settings.isAutoTunnelEnabled ||
+                                    uiState.settings.isAlwaysOnVpnEnabled),
-										uiState.settings.isAlwaysOnVpnEnabled
-									),
                                 value = currentText,
                                 onValueChange = { currentText = it },
                                 label = { Text(stringResource(R.string.add_trusted_ssid)) },
@@ -511,10 +473,8 @@ fun SettingsScreen(
                     ConfigurationToggle(
                         stringResource(R.string.tunnel_mobile_data),
                         enabled =
-						!(
+                        !(uiState.settings.isAutoTunnelEnabled ||
-							uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
-								uiState.settings.isAlwaysOnVpnEnabled
-							),
                         checked = uiState.settings.isTunnelOnMobileDataEnabled,
                         padding = screenPadding,
                         onCheckChanged = { viewModel.onToggleTunnelOnMobileData() },
@@ -522,10 +482,8 @@ fun SettingsScreen(
                     ConfigurationToggle(
                         stringResource(id = R.string.tunnel_on_ethernet),
                         enabled =
-						!(
+                        !(uiState.settings.isAutoTunnelEnabled ||
-							uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
-								uiState.settings.isAlwaysOnVpnEnabled
-							),
                         checked = uiState.settings.isTunnelOnEthernetEnabled,
                         padding = screenPadding,
                         onCheckChanged = { viewModel.onToggleTunnelOnEthernet() },
@@ -533,10 +491,8 @@ fun SettingsScreen(
                     ConfigurationToggle(
                         stringResource(R.string.restart_on_ping),
                         enabled =
-						!(
+                        !(uiState.settings.isAutoTunnelEnabled ||
-							uiState.settings.isAutoTunnelEnabled ||
+                            uiState.settings.isAlwaysOnVpnEnabled),
-								uiState.settings.isAlwaysOnVpnEnabled
-							),
                         checked = uiState.settings.isPingEnabled,
                         padding = screenPadding,
                         onCheckChanged = { viewModel.onToggleRestartOnPing() },
@@ -544,15 +500,11 @@ fun SettingsScreen(
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
                         modifier =
-						(
+                        (if (!uiState.settings.isAutoTunnelEnabled) Modifier
-							if (!uiState.settings.isAutoTunnelEnabled) {
+                        else
-								Modifier
-							} else {
                             Modifier.focusRequester(
                                 focusRequester,
-								)
+                            ))
-							}
-							)
                             .fillMaxSize()
                             .padding(top = 5.dp),
                         horizontalArrangement = Arrangement.Center,
@@ -567,16 +519,12 @@ fun SettingsScreen(
                                     when (false) {
                                         isBackgroundLocationGranted ->
                                             appViewModel.showSnackbarMessage(
-												context.getString(
+                                                Event.Error.BackgroundLocationRequired.message,
-													R.string.background_location_required,
-												),
                                             )
 
                                         fineLocationState.status.isGranted ->
                                             appViewModel.showSnackbarMessage(
-												context.getString(
+                                                Event.Error.PreciseLocationRequired.message,
-													R.string.precise_location_required,
-												),
                                             )
 
                                         viewModel.isLocationEnabled(context) ->
@@ -602,13 +550,13 @@ fun SettingsScreen(
                     }
                 }
             }
+            if (WgQuickBackend.hasKernelSupport()) {
                 Surface(
                     tonalElevation = 2.dp,
                     shadowElevation = 2.dp,
                     shape = RoundedCornerShape(12.dp),
                     color = MaterialTheme.colorScheme.surface,
-				modifier =
+                    modifier = Modifier
-				Modifier
                         .fillMaxWidth(fillMaxWidth)
                         .padding(vertical = 10.dp),
                 ) {
@@ -618,38 +566,22 @@ fun SettingsScreen(
                         modifier = Modifier.padding(15.dp),
                     ) {
                         SectionTitle(
-						title = stringResource(id = R.string.backend),
+                            title = stringResource(id = R.string.kernel),
                             padding = screenPadding,
                         )
-					ConfigurationToggle(
-						stringResource(R.string.use_amnezia),
-						enabled =
-						!(
-							uiState.settings.isAutoTunnelEnabled ||
-								uiState.settings.isAlwaysOnVpnEnabled ||
-								(uiState.vpnState.status == TunnelState.UP) || uiState.settings.isKernelEnabled
-							),
-						checked = uiState.settings.isAmneziaEnabled,
-						padding = screenPadding,
-						onCheckChanged = {
-							viewModel.onToggleAmnezia()
-						},
-					)
-					if (kernelSupport) {
                         ConfigurationToggle(
                             stringResource(R.string.use_kernel),
                             enabled =
-							!(
+                            !(uiState.settings.isAutoTunnelEnabled ||
-								uiState.settings.isAutoTunnelEnabled ||
                                 uiState.settings.isAlwaysOnVpnEnabled ||
-									(uiState.vpnState.status == TunnelState.UP)
+                                (uiState.vpnState.status == Tunnel.State.UP)),
-								),
                             checked = uiState.settings.isKernelEnabled,
                             padding = screenPadding,
                             onCheckChanged = {
-								scope.launch {
+                                viewModel.onToggleKernelMode().let {
-									viewModel.onToggleKernelMode().onFailure {
+                                    when (it) {
-										appViewModel.showSnackbarMessage(it.getMessage(context))
+                                        is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
+                                        is Result.Success -> {}
                                     }
                                 }
                             },
@@ -693,25 +625,16 @@ fun SettingsScreen(
                             onCheckChanged = { viewModel.onToggleShortcutsEnabled() },
                         )
                     }
-					ConfigurationToggle(
-						stringResource(R.string.restart_at_boot),
-						enabled = true,
-						checked = uiState.settings.isRestoreOnBootEnabled,
-						padding = screenPadding,
-						onCheckChanged = {
-							viewModel.onToggleRestartAtBoot()
-						},
-					)
                     ConfigurationToggle(
                         stringResource(R.string.enable_app_lock),
                         enabled = true,
-						checked = uiState.isPinLockEnabled,
+                        checked = pinExists.value,
                         padding = screenPadding,
                         onCheckChanged = {
-							if (uiState.isPinLockEnabled) {
+                            if (pinExists.value) {
-								viewModel.onPinLockDisabled()
+                                PinManager.clearPin()
+                                pinExists.value = PinManager.pinExists()
                             } else {
-								viewModel.onPinLockEnabled()
                                 navController.navigate(Screen.Lock.route)
                             }
                         },
@@ -719,8 +642,7 @@ fun SettingsScreen(
                     if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
                         Row(
                             verticalAlignment = Alignment.CenterVertically,
-							modifier =
+                            modifier = Modifier
-							Modifier
                                 .fillMaxSize()
                                 .padding(top = 5.dp),
                             horizontalArrangement = Arrangement.Center,