feat: mobile data only auto-tunneling

Added support for configuring auto-tunneling to only tunnel on mobile data with no location permissions necessary.

Improved UI on support screen and updated support resource links.

Fixed UI bug where analytics expansion could show on deactivated tunnels.

.editorconfig

@@ -1,85 +0,0 @@
-[{*.kt,*.kts}]
-indent_style = space
-insert_final_newline = true
-max_line_length = 100
-indent_size = 4
-ij_continuation_indent_size = 4
-ij_java_names_count_to_use_import_on_demand = 9999
-ij_kotlin_align_in_columns_case_branch = false
-ij_kotlin_align_multiline_binary_operation = false
-ij_kotlin_align_multiline_extends_list = false
-ij_kotlin_align_multiline_method_parentheses = false
-ij_kotlin_align_multiline_parameters = true
-ij_kotlin_align_multiline_parameters_in_calls = false
-ij_kotlin_allow_trailing_comma = true
-ij_kotlin_allow_trailing_comma_on_call_site = true
-ij_kotlin_assignment_wrap = normal
-ij_kotlin_blank_lines_after_class_header = 0
-ij_kotlin_blank_lines_around_block_when_branches = 0
-ij_kotlin_blank_lines_before_declaration_with_comment_or_annotation_on_separate_line = 1
-ij_kotlin_block_comment_at_first_column = true
-ij_kotlin_call_parameters_new_line_after_left_paren = true
-ij_kotlin_call_parameters_right_paren_on_new_line = false
-ij_kotlin_call_parameters_wrap = on_every_item
-ij_kotlin_catch_on_new_line = false
-ij_kotlin_class_annotation_wrap = split_into_lines
-ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
-ij_kotlin_continuation_indent_for_chained_calls = true
-ij_kotlin_continuation_indent_for_expression_bodies = true
-ij_kotlin_continuation_indent_in_argument_lists = true
-ij_kotlin_continuation_indent_in_elvis = false
-ij_kotlin_continuation_indent_in_if_conditions = false
-ij_kotlin_continuation_indent_in_parameter_lists = false
-ij_kotlin_continuation_indent_in_supertype_lists = false
-ij_kotlin_else_on_new_line = false
-ij_kotlin_enum_constants_wrap = off
-ij_kotlin_extends_list_wrap = normal
-ij_kotlin_field_annotation_wrap = split_into_lines
-ij_kotlin_finally_on_new_line = false
-ij_kotlin_if_rparen_on_new_line = false
-ij_kotlin_import_nested_classes = false
-ij_kotlin_insert_whitespaces_in_simple_one_line_method = true
-ij_kotlin_keep_blank_lines_before_right_brace = 2
-ij_kotlin_keep_blank_lines_in_code = 2
-ij_kotlin_keep_blank_lines_in_declarations = 2
-ij_kotlin_keep_first_column_comment = true
-ij_kotlin_keep_indents_on_empty_lines = false
-ij_kotlin_keep_line_breaks = true
-ij_kotlin_lbrace_on_next_line = false
-ij_kotlin_line_comment_add_space = false
-ij_kotlin_line_comment_at_first_column = true
-ij_kotlin_method_annotation_wrap = split_into_lines
-ij_kotlin_method_call_chain_wrap = normal
-ij_kotlin_method_parameters_new_line_after_left_paren = true
-ij_kotlin_method_parameters_right_paren_on_new_line = true
-ij_kotlin_method_parameters_wrap = on_every_item
-ij_kotlin_name_count_to_use_star_import = 9999
-ij_kotlin_name_count_to_use_star_import_for_members = 9999
-ij_kotlin_parameter_annotation_wrap = off
-ij_kotlin_space_after_comma = true
-ij_kotlin_space_after_extend_colon = true
-ij_kotlin_space_after_type_colon = true
-ij_kotlin_space_before_catch_parentheses = true
-ij_kotlin_space_before_comma = false
-ij_kotlin_space_before_extend_colon = true
-ij_kotlin_space_before_for_parentheses = true
-ij_kotlin_space_before_if_parentheses = true
-ij_kotlin_space_before_lambda_arrow = true
-ij_kotlin_space_before_type_colon = false
-ij_kotlin_space_before_when_parentheses = true
-ij_kotlin_space_before_while_parentheses = true
-ij_kotlin_spaces_around_additive_operators = true
-ij_kotlin_spaces_around_assignment_operators = true
-ij_kotlin_spaces_around_equality_operators = true
-ij_kotlin_spaces_around_function_type_arrow = true
-ij_kotlin_spaces_around_logical_operators = true
-ij_kotlin_spaces_around_multiplicative_operators = true
-ij_kotlin_spaces_around_range = false
-ij_kotlin_spaces_around_relational_operators = true
-ij_kotlin_spaces_around_unary_operator = false
-ij_kotlin_spaces_around_when_arrow = true
-ij_kotlin_variable_annotation_wrap = off
-ij_kotlin_while_on_new_line = false
-ij_kotlin_wrap_elvis_expressions = 1
-ij_kotlin_wrap_expression_body_functions = 1
-ij_kotlin_wrap_first_method_in_call_chain = false

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -11,14 +11,12 @@ assignees: zaneschepke
 A clear and concise description of what the bug is.
 
 **Smartphone (please complete the following information):**
-
+ - Device: [e.g. iPhone6]
-- Device: [e.g. Pixel 4a]
+ - Android Version: [e.g. iOS8.1]
-- Android Version: [e.g. Android 13]
+ - App Version [e.g. 22]
-- App Version [e.g. 3.3.3]
 
 **To Reproduce**
 Steps to reproduce the behavior:
-
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'

.github/dependabot.yml

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

.github/workflows/android.yml

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

.github/workflows/release.yml

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

README.md

@@ -13,18 +13,22 @@ WG Tunnel
 
 
 [![Google Play](https://img.shields.io/badge/Google_Play-414141?style=for-the-badge&logo=google-play&logoColor=white)](https://play.google.com/store/apps/details?id=com.zaneschepke.wireguardautotunnel)
+[![Fire TV](https://img.shields.io/badge/fire%20tv-fc3b2d?style=for-the-badge&logo=amazon%20fire%20tv&logoColor=white)](https://www.amazon.com/gp/product/B0CFGGL7WK)
 [![F-Droid](https://img.shields.io/static/v1?style=for-the-badge&message=F-Droid&color=1976D2&logo=F-Droid&logoColor=FFFFFF&label=)](https://f-droid.org/packages/com.zaneschepke.wireguardautotunnel/)
 
 
+</div>
+
+<div align="center">
+
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/N4N8NMJN2)
+
 </div>
 
 
 <div align="left">
 
-This is an alternative Android Application for [WireGuard](https://www.wireguard.com/) with added
+This is an alternative Android Application for [WireGuard](https://www.wireguard.com/) with added features. Built using the [wireguard-android](https://github.com/WireGuard/wireguard-android) library and [Jetpack Compose](https://developer.android.com/jetpack/compose), this application was inspired by the official [WireGuard Android](https://github.com/WireGuard/wireguard-android) app.
-features. Built using the [wireguard-android](https://github.com/WireGuard/wireguard-android)
-library and [Jetpack Compose](https://developer.android.com/jetpack/compose), this application was
-inspired by the official [WireGuard Android](https://github.com/WireGuard/wireguard-android) app.
 
 </div>
 
@@ -33,52 +37,38 @@ inspired by the official [WireGuard Android](https://github.com/WireGuard/wiregu
 ## Screenshots
 
 <p float="center">
-  <img label="Main" style="padding-right:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/main_screen.png" width="200" />
+  <img label="Main" style="padding-right:25px" src="asset/main_screen.png" width="200" />
-  <img label="Config" style="padding-left:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/config_screen.png" width="200" />
+  <img label="Config" style="padding-left:25px" src="asset/config_screen.png" width="200" />
-  <img label="Settings" style="padding-left:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/settings_screen.png" width="200" />
+  <img label="Settings" style="padding-left:25px" src="asset/settings_screen.png" width="200" />
-  <img label="Support" style="padding-left:25px" src="fastlane/metadata/android/en-US/images/phoneScreenshots/support_screen.png" width="200" />
+  <img label="Support" style="padding-left:25px" src="asset/support_screen.png" width="200" />
 </p>
 
 <div align="left">
 
 ## Inspiration
 
-The original inspiration for this app came from the inconvenience of having to manually turn VPN off
+The original inspiration for this app came from the inconvenience of having to manually turn VPN off and on while on different networks. This app was created to offer a free solution to this problem. 
-and on while on different networks. This app was created to offer a free solution to this problem.
 
 ## Features
 
 * Add tunnels via .conf file, zip, manual entry, or QR code
-* Auto connect to tunnels based on Wi-Fi SSID, ethernet, or mobile data
+* Auto connect to VPN based on Wi-Fi SSID
 * Split tunneling by application with search
-* WireGuard support for kernel and userspace modes
+* Always-on VPN for Android support
-* Always-On VPN support
 * 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
+* Optional auto connect on mobile data, ethernet
-* Automatic tunnel restart after reboot
+* Automatic service restart after reboot
-* Battery preservation measures
+* Service will stay running in background after app has been closed
-* Restart tunnel on ping failure (beta)
 
-## Docs (WIP)
-
-Basic documentation of the feature and behaviors of this app can be
-found [here](https://zaneschepke.com/wgtunnel-docs/overview.html).
-
-The repository for these docs can be found [here](https://github.com/zaneschepke/wgtunnel-docs).
 
 ## Building
     
 ```
 $ git clone https://github.com/zaneschepke/wgtunnel
 $ cd wgtunnel
-```
-
-And then build the app:
-
-```
 $ ./gradlew assembleDebug
 ```
 

SECURITY.md

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

app/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.hilt.android)
-    alias(libs.plugins.kotlinxSerialization)
+    id("org.jetbrains.kotlin.plugin.serialization")
     alias(libs.plugins.ksp)
 }
 
@@ -19,74 +19,47 @@ android {
         versionCode = Constants.VERSION_CODE
         versionName = Constants.VERSION_NAME
 
-        ksp { arg("room.schemaLocation", "$projectDir/schemas") }
+        ksp {
-
+            arg("room.schemaLocation", "$projectDir/schemas")
-        sourceSets {
-            getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
         }
 
         resourceConfigurations.addAll(listOf("en"))
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
-        vectorDrawables { useSupportLibrary = true }
+        vectorDrawables {
+            useSupportLibrary = true
+        }
     }
 
     signingConfigs {
         create(Constants.RELEASE) {
-            val properties =
+            val properties = Properties().apply {
-                Properties().apply {
+                //created local file for signing details
-                    // created local file for signing details
+                try {
-                    try {
+                    load(file("signing.properties").reader())
-                        load(file("signing.properties").reader())
+                } catch (_ : Exception) {
-                    } catch (_: Exception) {
+                    load(file("signing_template.properties").reader())
-                        load(file("signing_template.properties").reader())
-                    }
                 }
+            }
 
-            // try to get secrets from env first for pipeline build, then properties file for local
+            //try to get secrets from env first for pipeline build, then properties file for local build
-            // build
+            storeFile = file(System.getenv().getOrDefault(Constants.KEY_STORE_PATH_VAR, properties.getProperty(Constants.KEY_STORE_PATH_VAR)))
-            storeFile =
+            storePassword = System.getenv().getOrDefault(Constants.STORE_PASS_VAR, properties.getProperty(Constants.STORE_PASS_VAR))
-                file(
+            keyAlias = System.getenv().getOrDefault(Constants.KEY_ALIAS_VAR, properties.getProperty(Constants.KEY_ALIAS_VAR))
-                    System.getenv()
+            keyPassword = System.getenv().getOrDefault(Constants.KEY_PASS_VAR, properties.getProperty(Constants.KEY_PASS_VAR))
-                        .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),
-                    )
         }
     }
 
     buildTypes {
-        // don't strip
+        //don't strip
-        packaging.jniLibs.keepDebugSymbols.addAll(
+        packaging.jniLibs.keepDebugSymbols.addAll(listOf("libwg-go.so", "libwg-quick.so", "libwg.so"))
-            listOf("libwg-go.so", "libwg-quick.so", "libwg.so"),
-        )
 
         applicationVariants.all {
             val variant = this
             variant.outputs
                 .map { it as com.android.build.gradle.internal.api.BaseVariantOutputImpl }
                 .forEach { output ->
-                    val outputFileName =
+                    val outputFileName = "${Constants.APP_NAME}-${variant.flavorName}-${variant.buildType.name}-${variant.versionName}.apk"
-                        "${Constants.APP_NAME}-${variant.flavorName}-${variant.buildType.name}-${variant.versionName}.apk"
                     output.outputFileName = outputFileName
                 }
         }
@@ -96,11 +69,13 @@ android {
             isShrinkResources = true
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro",
+                "proguard-rules.pro"
             )
             signingConfig = signingConfigs.getByName(Constants.RELEASE)
         }
-        debug { isDebuggable = true }
+        debug {
+            isDebuggable = true
+        }
     }
     flavorDimensions.add(Constants.TYPE)
     productFlavors {
@@ -110,8 +85,10 @@ android {
         }
         create("general") {
             dimension = Constants.TYPE
-            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
+            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle))
-                //any plugins general specific
+            {
+                apply(plugin = "com.google.gms.google-services")
+                apply(plugin = "com.google.firebase.crashlytics")
             }
         }
     }
@@ -120,24 +97,29 @@ android {
         targetCompatibility = JavaVersion.VERSION_17
         isCoreLibraryDesugaringEnabled = true
     }
-    kotlinOptions { jvmTarget = Constants.JVM_TARGET }
+    kotlinOptions {
+        jvmTarget = Constants.JVM_TARGET
+    }
     buildFeatures {
         compose = true
         buildConfig = true
+
+    }
+    composeOptions {
+        kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
+    }
+    packaging {
+        resources {
+            excludes += "/META-INF/{AL2.0,LGPL2.1}"
+        }
     }
-    composeOptions { kotlinCompilerExtensionVersion = Constants.COMPOSE_COMPILER_EXTENSION_VERSION }
-    packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
 val generalImplementation by configurations
-
 dependencies {
-
-    implementation(project(":logcatter"))
-
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)
-    // helpers for implementing LifecycleOwner in a Service
+    // optional - helpers for implementing LifecycleOwner in a Service
     implementation(libs.androidx.lifecycle.service)
     implementation(libs.androidx.activity.compose)
     implementation(platform(libs.androidx.compose.bom))
@@ -147,25 +129,22 @@ dependencies {
     implementation(libs.androidx.material3)
     implementation(libs.androidx.appcompat)
 
-    // test
+    //test
     testImplementation(libs.junit)
-    testImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.androidx.compose.ui.test)
-    androidTestImplementation(libs.androidx.room.testing)
     debugImplementation(libs.androidx.compose.ui.tooling)
     debugImplementation(libs.androidx.compose.manifest)
 
-    // get tunnel lib from github packages or mavenLocal
+    //wg
     implementation(libs.tunnel)
     coreLibraryDesugaring(libs.desugar.jdk.libs)
 
-    // logging
+    //logging
     implementation(libs.timber)
 
-
     // compose navigation
     implementation(libs.androidx.navigation.compose)
     implementation(libs.androidx.hilt.navigation.compose)
@@ -174,36 +153,41 @@ dependencies {
     implementation(libs.hilt.android)
     ksp(libs.hilt.android.compiler)
 
-    // accompanist
+    //accompanist
+    implementation(libs.accompanist.systemuicontroller)
     implementation(libs.accompanist.permissions)
     implementation(libs.accompanist.flowlayout)
     implementation(libs.accompanist.drawablepainter)
 
-    // storage
+    //room
     implementation(libs.androidx.room.runtime)
     ksp(libs.androidx.room.compiler)
     implementation(libs.androidx.room.ktx)
-    implementation(libs.androidx.datastore.preferences)
 
-    // lifecycle
+    //lifecycle
     implementation(libs.lifecycle.runtime.compose)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.lifecycle.process)
 
-    // icons
+
+    //icons
     implementation(libs.material.icons.extended)
-    // serialization
+    //serialization
     implementation(libs.kotlinx.serialization.json)
 
-    // barcode scanning
+    //firebase crashlytics
+    generalImplementation(platform(libs.firebase.bom))
+    generalImplementation(libs.google.firebase.crashlytics.ktx)
+    generalImplementation(libs.google.firebase.analytics.ktx)
+
+    //barcode scanning
     implementation(libs.zxing.android.embedded)
     implementation(libs.zxing.core)
 
-    // bio
+    //bio
     implementation(libs.androidx.biometric.ktx)
-    implementation(libs.pin.lock.compose)
 
-    // shortcuts
+    //shortcuts
     implementation(libs.androidx.core)
     implementation(libs.androidx.core.google.shortcuts)
 }

app/fdroid-rules.pro

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

app/google-services.json

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

app/proguard-rules.pro

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

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

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

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

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

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

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

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

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

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

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

app/src/main/AndroidManifest.xml

@@ -1,81 +1,68 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
-
     <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
-        android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="32" />
     <uses-permission
         android:name="android.permission.WRITE_EXTERNAL_STORAGE"
         android:maxSdkVersion="32"
         tools:ignore="ScopedStorage" />
-    <uses-permission
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"
-        android:name="android.permission.ACCESS_WIFI_STATE"
         android:maxSdkVersion="30"
         tools:ignore="LeanbackUsesWifi" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
-    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
-    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
-    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
-    <!--foreground service exempt android 14-->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING"/>
-    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
-
     <!--foreground service permissions-->
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
-    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
     <!--start service on boot permission-->
-    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <!--android tv support-->
-    <uses-feature
+    <uses-feature android:name="android.software.leanback"
-        android:name="android.software.leanback"
         android:required="false" />
-    <uses-feature
+    <uses-feature android:name="android.hardware.touchscreen"
-        android:name="android.hardware.touchscreen"
         android:required="false" />
     <uses-feature
         android:name="android.hardware.location.gps"
         android:required="false" />
     <uses-feature
-        android:name="android.hardware.screen.portrait"
+    android:name="android.hardware.screen.portrait"
-        android:required="false" />
+    android:required="false" />
-
     <queries>
         <intent>
             <action android:name="android.intent.action.MAIN" />
         </intent>
     </queries>
     <application
-        android:name=".WireGuardAutoTunnel"
         android:allowBackup="true"
-        android:banner="@drawable/ic_banner"
+        android:name=".WireGuardAutoTunnel"
         android:dataExtractionRules="@xml/data_extraction_rules"
-        android:enableOnBackInvokedCallback="true"
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
+        android:banner="@mipmap/ic_banner"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.WireguardAutoTunnel"
-        tools:targetApi="tiramisu">
+        tools:targetApi="31">
         <activity
             android:name=".ui.MainActivity"
             android:exported="true"
             android:theme="@style/Theme.WireguardAutoTunnel">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
-
                 <category android:name="android.intent.category.LAUNCHER" />
                 <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
-
+                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES"/>
-                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
             </intent-filter>
-            <meta-data
+            <meta-data android:name="android.app.shortcuts"
-                android:name="android.app.shortcuts"
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
@@ -83,94 +70,61 @@
             android:screenOrientation="fullSensor"
             android:stateNotNeeded="true"
             android:theme="@style/zxing_CaptureTheme"
-            android:windowSoftInputMode="stateAlwaysHidden"
+            android:windowSoftInputMode="stateAlwaysHidden" />
-            tools:ignore="DiscouragedApi" />
         <activity
-            android:name=".service.shortcut.ShortcutsActivity"
+            android:finishOnTaskLaunch="true"
             android:enabled="true"
             android:exported="true"
-            android:finishOnTaskLaunch="true"
+            android:theme="@android:style/Theme.NoDisplay"
-            android:theme="@android:style/Theme.NoDisplay" />
+            android:name=".service.shortcut.ShortcutsActivity"/>
-
         <service
             android:name=".service.foreground.ForegroundService"
             android:enabled="true"
-            android:exported="false"
+            android:foregroundServiceType="remoteMessaging"
-            android:foregroundServiceType="systemExempted"
+            android:exported="false">
-            tools:node="merge" />
-        <service
-            android:name=".service.tile.TunnelControlTile"
-            android:exported="true"
-            android:icon="@drawable/ic_launcher"
-            android:label="Tunnel control"
-            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
-            <meta-data
-                android:name="android.service.quicksettings.ACTIVE_TILE"
-                android:value="true" />
-            <meta-data
-                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
-                android:value="true" />
-
-            <intent-filter>
-                <action android:name="android.service.quicksettings.action.QS_TILE" />
-            </intent-filter>
         </service>
         <service
-            android:name=".service.tile.AutoTunnelControlTile"
             android:exported="true"
-            android:icon="@drawable/ic_launcher"
+            android:name=".service.tile.TunnelControlTile"
-            android:label="Auto-tunnel"
+            android:icon="@drawable/shield"
+            android:label="WG Tunnel"
             android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
-            <meta-data
+            <meta-data android:name="android.service.quicksettings.ACTIVE_TILE"
-                android:name="android.service.quicksettings.ACTIVE_TILE"
                 android:value="true" />
-            <meta-data
+            <meta-data android:name="android.service.quicksettings.TOGGLEABLE_TILE"
-                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
                 android:value="true" />
-
             <intent-filter>
                 <action android:name="android.service.quicksettings.action.QS_TILE" />
             </intent-filter>
         </service>
         <service
             android:name=".service.foreground.WireGuardTunnelService"
-            android:enabled="true"
-            android:exported="false"
-            android:foregroundServiceType="systemExempted"
             android:permission="android.permission.BIND_VPN_SERVICE"
+            android:enabled="true"
             android:persistent="true"
-            tools:node="merge">
+            android:foregroundServiceType="remoteMessaging"
+            android:exported="false">
             <intent-filter>
-                <action android:name="android.net.VpnService" />
+                <action android:name="android.net.VpnService"/>
             </intent-filter>
-            <meta-data
+            <meta-data android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
-                android:name="android.net.VpnService.SUPPORTS_ALWAYS_ON"
                 android:value="true" />
         </service>
         <service
             android:name=".service.foreground.WireGuardConnectivityWatcherService"
             android:enabled="true"
-            android:exported="false"
-            android:foregroundServiceType="systemExempted"
-            android:persistent="true"
             android:stopWithTask="false"
-            tools:node="merge" />
+            android:persistent="true"
-
+            android:foregroundServiceType="location"
-        <receiver
+            android:permission=""
-            android:name=".receiver.BootReceiver"
-            android:enabled="true"
             android:exported="false">
+        </service>
+        <receiver android:enabled="true" android:name=".receiver.BootReceiver"
+            android:exported="true">
             <intent-filter>
-                <category android:name="android.intent.category.DEFAULT" />
+                <action android:name="android.intent.action.BOOT_COMPLETED"/>
-
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-                <action android:name="android.intent.action.ACTION_BOOT_COMPLETED" />
-                <action android:name="android.intent.action.QUICKBOOT_POWERON" />
-                <action android:name="com.htc.intent.action.QUICKBOOT_POWERON" />
             </intent-filter>
         </receiver>
-        <receiver
+        <receiver android:exported="false" android:name=".receiver.NotificationActionReceiver"/>
-            android:name=".receiver.NotificationActionReceiver"
-            android:exported="false" />
     </application>
 </manifest>

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

@@ -0,0 +1,20 @@
+package com.zaneschepke.wireguardautotunnel
+
+object Constants {
+    const val MANUAL_TUNNEL_CONFIG_ID = "0"
+    const val WATCHER_SERVICE_WAKE_LOCK_TIMEOUT = 10*60*1000L /*10 minute*/
+    const val VPN_CONNECTIVITY_CHECK_INTERVAL = 3000L
+    const val VPN_STATISTIC_CHECK_INTERVAL = 1000L
+    const val TOGGLE_TUNNEL_DELAY = 500L
+    const val FADE_IN_ANIMATION_DURATION = 1000
+    const val SLIDE_IN_ANIMATION_DURATION = 500
+    const val SLIDE_IN_TRANSITION_OFFSET = 1000
+    const val CONF_FILE_EXTENSION = ".conf"
+    const val ZIP_FILE_EXTENSION = ".zip"
+    const val URI_CONTENT_SCHEME = "content"
+    const val URI_PACKAGE_SCHEME = "package"
+    const val ALLOWED_FILE_TYPES = "*/*"
+    const val GOOGLE_TV_EXPLORER_STUB = "com.google.android.tv.frameworkpackagestubs"
+    const val ANDROID_TV_EXPLORER_STUB = "com.android.tv.frameworkpackagestubs"
+    const val EMAIL_MIME_TYPE = "message/rfc822"
+}

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

@@ -0,0 +1,31 @@
+package com.zaneschepke.wireguardautotunnel
+
+import android.content.BroadcastReceiver
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import java.math.BigDecimal
+import java.text.DecimalFormat
+import kotlin.coroutines.CoroutineContext
+import kotlin.coroutines.EmptyCoroutineContext
+
+fun BroadcastReceiver.goAsync(
+    context: CoroutineContext = EmptyCoroutineContext,
+    block: suspend CoroutineScope.() -> Unit
+) {
+    val pendingResult = goAsync()
+    @OptIn(DelicateCoroutinesApi::class) // Must run globally; there's no teardown callback.
+    GlobalScope.launch(context) {
+        try {
+            block()
+        } finally {
+            pendingResult.finish()
+        }
+    }
+}
+
+fun BigDecimal.toThreeDecimalPlaceString() : String {
+    val df = DecimalFormat("#.###")
+    return df.format(this)
+}

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

@@ -1,46 +1,46 @@
 package com.zaneschepke.wireguardautotunnel
 
 import android.app.Application
-import android.content.ComponentName
 import android.content.Context
 import android.content.pm.PackageManager
-import android.service.quicksettings.TileService
+import androidx.lifecycle.ProcessLifecycleOwner
-import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
+import androidx.lifecycle.lifecycleScope
-import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
-import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
+import com.zaneschepke.wireguardautotunnel.repository.model.Settings
 import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.launch
 import timber.log.Timber
-import xyz.teamgravity.pin_lock_compose.PinManager
+import javax.inject.Inject
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
+
+    @Inject
+    lateinit var settingsRepo : SettingsDoa
+
     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)
+        }
+        initSettings()
     }
 
+    private fun initSettings() {
+        with(ProcessLifecycleOwner.get()) {
+            lifecycleScope.launch {
+                if(settingsRepo.getAll().isEmpty()) {
+                    settingsRepo.save(Settings())
+                }
+            }
+        }
+    }
+
+
+
     companion object {
-        lateinit var instance: WireGuardAutoTunnel
+        fun isRunningOnAndroidTv(context : Context) : Boolean {
-            private set
+            return context.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
-
-        fun isRunningOnAndroidTv(): Boolean {
-            return instance.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
-        }
-
-        fun requestTunnelTileServiceStateUpdate(context: Context) {
-            TileService.requestListeningState(
-                context,
-                ComponentName(instance, TunnelControlTile::class.java),
-            )
-        }
-
-        fun requestAutoTunnelTileServiceUpdate(context: Context) {
-            TileService.requestListeningState(
-                context,
-                ComponentName(instance, AutoTunnelControlTile::class.java),
-            )
         }
     }
 }

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

@@ -1,54 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data
-
-import androidx.room.AutoMigration
-import androidx.room.Database
-import androidx.room.DeleteColumn
-import androidx.room.RoomDatabase
-import androidx.room.TypeConverters
-import androidx.room.migration.AutoMigrationSpec
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-
-@Database(
-    entities = [Settings::class, TunnelConfig::class],
-    version = 7,
-    autoMigrations =
-    [
-        AutoMigration(from = 1, to = 2),
-        AutoMigration(from = 2, to = 3),
-        AutoMigration(
-            from = 3,
-            to = 4,
-        ),
-        AutoMigration(
-            from = 4,
-            to = 5,
-        ),
-        AutoMigration(
-            from = 5,
-            to = 6,
-        ),
-        AutoMigration(
-            from = 6,
-            to = 7,
-            spec = RemoveLegacySettingColumnsMigration::class,
-        ),
-    ],
-    exportSchema = true,
-)
-@TypeConverters(DatabaseListConverters::class)
-abstract class AppDatabase : RoomDatabase() {
-    abstract fun settingDao(): SettingsDao
-
-    abstract fun tunnelConfigDoa(): TunnelConfigDao
-}
-
-@DeleteColumn(
-    tableName = "Settings",
-    columnName = "default_tunnel",
-)
-@DeleteColumn(
-    tableName = "Settings",
-    columnName = "is_battery_saver_enabled",
-)
-class RemoveLegacySettingColumnsMigration : AutoMigrationSpec

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

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

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

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

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

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

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

@@ -1,70 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.datastore
-
-import android.content.Context
-import androidx.datastore.preferences.core.Preferences
-import androidx.datastore.preferences.core.booleanPreferencesKey
-import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.intPreferencesKey
-import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.runBlocking
-import timber.log.Timber
-import java.io.IOException
-
-class DataStoreManager(private val context: Context) {
-    companion object {
-        val LOCATION_DISCLOSURE_SHOWN = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
-        val BATTERY_OPTIMIZE_DISABLE_SHOWN = booleanPreferencesKey("BATTERY_OPTIMIZE_DISABLE_SHOWN")
-        val TUNNEL_RUNNING_FROM_MANUAL_START =
-            booleanPreferencesKey("TUNNEL_RUNNING_FROM_MANUAL_START")
-        val ACTIVE_TUNNEL = intPreferencesKey("ACTIVE_TUNNEL")
-        val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
-    }
-
-    // preferences
-    private val preferencesKey = "preferences"
-    private val Context.dataStore by
-    preferencesDataStore(
-        name = preferencesKey,
-    )
-
-    suspend fun init() {
-        try {
-            context.dataStore.data.first()
-        } catch (e: IOException) {
-            Timber.e(e)
-        }
-    }
-
-    suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) {
-        try {
-            context.dataStore.edit { it[key] = value }
-        } catch (e: IOException) {
-            Timber.e(e)
-        } catch (e: Exception) {
-            Timber.e(e)
-        }
-    }
-
-
-    fun <T> getFromStoreFlow(key: Preferences.Key<T>) = context.dataStore.data.map { it[key] }
-
-    suspend fun <T> getFromStore(key: Preferences.Key<T>): T? {
-        return try {
-            context.dataStore.data.map { it[key] }.first()
-        } catch (e: IOException) {
-            Timber.e(e)
-            null
-        }
-    }
-
-
-    fun <T> getFromStoreBlocking(key: Preferences.Key<T>) = runBlocking {
-        context.dataStore.data.map { it[key] }.first()
-    }
-
-    val preferencesFlow: Flow<Preferences?> = context.dataStore.data
-}

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

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

@@ -1,53 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-@Entity
-data class Settings(
-    @PrimaryKey(autoGenerate = true) val id: Int = 0,
-    @ColumnInfo(name = "is_tunnel_enabled") 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

@@ -1,38 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.model
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.Index
-import androidx.room.PrimaryKey
-import com.wireguard.config.Config
-import 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,14 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.repository
-
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-
-interface AppDataRepository {
-    suspend fun getPrimaryOrFirstTunnel(): TunnelConfig?
-    suspend fun getStartTunnelConfig(): TunnelConfig?
-
-    suspend fun toggleWatcherServicePause()
-
-    val settings: SettingsRepository
-    val tunnels: TunnelConfigRepository
-    val appState: AppStateRepository
-}

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

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

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

@@ -1,26 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.repository
-
-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 isBatteryOptimizationDisableShown(): Boolean
-    suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
-
-    suspend fun isTunnelRunningFromManualStart(): Boolean
-    suspend fun setTunnelRunningFromManualStart(id: Int)
-
-    suspend fun setManualStop()
-
-    suspend fun getActiveTunnelId(): Int?
-
-    suspend fun getCurrentSsid(): String?
-
-    suspend fun setCurrentSsid(ssid: String)
-
-    val generalStateFlow: Flow<GeneralState>
-
-}

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

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

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

@@ -1,24 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.repository
-
-import com.zaneschepke.wireguardautotunnel.data.SettingsDao
-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)
-    }
-
-    override fun getSettingsFlow(): Flow<Settings> {
-        return settingsDoa.getSettingsFlow()
-    }
-
-    override suspend fun getSettings(): Settings {
-        return settingsDoa.getAll().firstOrNull() ?: Settings()
-    }
-
-    override suspend fun getAll(): List<Settings> {
-        return settingsDoa.getAll()
-    }
-}

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

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

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

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

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

@@ -1,30 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.data.repository
-
-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
-
-    suspend fun save(tunnelConfig: TunnelConfig)
-
-    suspend fun updatePrimaryTunnel(tunnelConfig: TunnelConfig?)
-
-    suspend fun updateMobileDataTunnel(tunnelConfig: TunnelConfig?)
-
-    suspend fun delete(tunnelConfig: TunnelConfig)
-
-    suspend fun getById(id: Int): TunnelConfig?
-
-    suspend fun count(): Int
-
-    suspend fun findByTunnelNetworksName(name: String): TunnelConfigs
-
-    suspend fun findByMobileDataTunnel(): TunnelConfigs
-
-    suspend fun findPrimary(): TunnelConfigs
-}

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

@@ -3,8 +3,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.repository.AppDatabase
-import com.zaneschepke.wireguardautotunnel.data.DatabaseCallback
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -17,14 +16,11 @@ import javax.inject.Singleton
 class DatabaseModule {
     @Provides
     @Singleton
-    fun provideDatabase(@ApplicationContext context: Context): AppDatabase {
+    fun provideDatabase(@ApplicationContext context : Context) : AppDatabase {
         return Room.databaseBuilder(
             context,
-            AppDatabase::class.java,
+            AppDatabase::class.java, context.getString(R.string.db_name))
-            context.getString(R.string.db_name),
-        )
             .fallbackToDestructiveMigration()
-            .addCallback(DatabaseCallback())
             .build()
     }
 }

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

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

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

@@ -1,73 +1,27 @@
 package com.zaneschepke.wireguardautotunnel.module
 
-import android.content.Context
+import com.zaneschepke.wireguardautotunnel.repository.AppDatabase
-import com.zaneschepke.wireguardautotunnel.data.AppDatabase
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
-import com.zaneschepke.wireguardautotunnel.data.SettingsDao
+import com.zaneschepke.wireguardautotunnel.repository.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRoomRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.DataStoreAppStateRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.RoomSettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.RoomTunnelConfigRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.data.repository.TunnelConfigRepository
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import javax.inject.Singleton
 
 @Module
 @InstallIn(SingletonComponent::class)
 class RepositoryModule {
+
     @Singleton
     @Provides
-    fun provideSettingsDoa(appDatabase: AppDatabase): SettingsDao {
+    fun provideSettingsRepository(appDatabase: AppDatabase) : SettingsDoa {
         return appDatabase.settingDao()
     }
 
     @Singleton
     @Provides
-    fun provideTunnelConfigDoa(appDatabase: AppDatabase): TunnelConfigDao {
+    fun provideTunnelConfigRepository(appDatabase: AppDatabase) : TunnelConfigDao {
         return appDatabase.tunnelConfigDoa()
     }
-
-    @Singleton
-    @Provides
-    fun provideTunnelConfigRepository(tunnelConfigDao: TunnelConfigDao): TunnelConfigRepository {
-        return RoomTunnelConfigRepository(tunnelConfigDao)
-    }
-
-    @Singleton
-    @Provides
-    fun provideSettingsRepository(settingsDao: SettingsDao): SettingsRepository {
-        return RoomSettingsRepository(settingsDao)
-    }
-
-    @Singleton
-    @Provides
-    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStoreManager {
-        return DataStoreManager(context)
-    }
-
-    @Provides
-    @Singleton
-    fun provideGeneralStateRepository(dataStoreManager: DataStoreManager): AppStateRepository {
-        return DataStoreAppStateRepository(dataStoreManager)
-    }
-
-    @Provides
-    @Singleton
-    fun provideAppDataRepository(
-        settingsRepository: SettingsRepository,
-        tunnelConfigRepository: TunnelConfigRepository,
-        appStateRepository: AppStateRepository
-    ): AppDataRepository {
-        return AppDataRoomRepository(settingsRepository, tunnelConfigRepository, appStateRepository)
-    }
-
-
 }

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

@@ -15,25 +15,20 @@ import dagger.hilt.android.scopes.ServiceScoped
 @Module
 @InstallIn(ServiceComponent::class)
 abstract class ServiceModule {
-    @Binds
-    @ServiceScoped
-    abstract fun provideNotificationService(
-        wireGuardNotification: WireGuardNotification
-    ): NotificationService
 
     @Binds
     @ServiceScoped
-    abstract fun provideWifiService(wifiService: WifiService): NetworkService<WifiService>
+    abstract fun provideNotificationService(wireGuardNotification: WireGuardNotification) : NotificationService
 
     @Binds
     @ServiceScoped
-    abstract fun provideMobileDataService(
+    abstract fun provideWifiService(wifiService: WifiService) : NetworkService<WifiService>
-        mobileDataService: MobileDataService
-    ): NetworkService<MobileDataService>
 
     @Binds
     @ServiceScoped
-    abstract fun provideEthernetService(
+    abstract fun provideMobileDataService(mobileDataService : MobileDataService) : NetworkService<MobileDataService>
-        ethernetService: EthernetService
+
-    ): NetworkService<EthernetService>
+    @Binds
+    @ServiceScoped
+    abstract fun provideEthernetService(ethernetService: EthernetService) : NetworkService<EthernetService>
 }

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

@@ -3,11 +3,6 @@ package com.zaneschepke.wireguardautotunnel.module
 import android.content.Context
 import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.GoBackend
-import com.wireguard.android.backend.WgQuickBackend
-import com.wireguard.android.util.RootShell
-import com.wireguard.android.util.ToolsInstaller
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
@@ -20,39 +15,16 @@ import javax.inject.Singleton
 @Module
 @InstallIn(SingletonComponent::class)
 class TunnelModule {
-    @Provides
-    @Singleton
-    fun provideRootShell(@ApplicationContext context: Context): RootShell {
-        return RootShell(context)
-    }
 
     @Provides
     @Singleton
-    @Userspace
+    fun provideBackend(@ApplicationContext context : Context) : Backend {
-    fun provideUserspaceBackend(@ApplicationContext context: Context): Backend {
         return GoBackend(context)
     }
 
     @Provides
     @Singleton
-    @Kernel
+    fun provideVpnService(backend: Backend) : VpnService {
-    fun provideKernelBackend(@ApplicationContext context: Context, rootShell: RootShell): Backend {
+        return WireGuardTunnel(backend)
-        return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
-    }
-
-    @Provides
-    @Singleton
-    fun provideVpnService(
-        @Userspace userspaceBackend: Backend,
-        @Kernel kernelBackend: Backend,
-        appDataRepository: AppDataRepository
-    ): VpnService {
-        return WireGuardTunnel(userspaceBackend, kernelBackend, appDataRepository)
-    }
-
-    @Provides
-    @Singleton
-    fun provideServiceManager(appDataRepository: AppDataRepository): ServiceManager {
-        return ServiceManager(appDataRepository)
     }
 }

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

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

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

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

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

@@ -3,32 +3,31 @@ package com.zaneschepke.wireguardautotunnel.receiver
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
+import com.zaneschepke.wireguardautotunnel.Constants
+import com.zaneschepke.wireguardautotunnel.goAsync
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
-import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class NotificationActionReceiver : BroadcastReceiver() {
-    @Inject
-    lateinit var settingsRepository: SettingsRepository
 
     @Inject
-    lateinit var serviceManager: ServiceManager
+    lateinit var settingsRepo : SettingsDoa
-
     override fun onReceive(context: Context, intent: Intent?) = goAsync {
         try {
-            //TODO fix for manual start changes when enabled
+            val settings = settingsRepo.getAll()
-            serviceManager.stopVpnService(context)
+            if (settings.isNotEmpty()) {
-            delay(Constants.TOGGLE_TUNNEL_DELAY)
+                val setting = settings.first()
-            serviceManager.startVpnServiceForeground(context)
+                if (setting.defaultTunnel != null) {
-        } catch (e: Exception) {
+                    ServiceManager.stopVpnService(context)
-            Timber.e(e)
+                    delay(Constants.TOGGLE_TUNNEL_DELAY)
+                    ServiceManager.startVpnService(context, setting.defaultTunnel.toString())
+                }
+            }
         } finally {
             cancel()
         }

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

@@ -0,0 +1,17 @@
+package com.zaneschepke.wireguardautotunnel.repository
+
+import androidx.room.AutoMigration
+import androidx.room.Database
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import com.zaneschepke.wireguardautotunnel.repository.model.Settings
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
+
+@Database(entities = [Settings::class, TunnelConfig::class], version = 3, autoMigrations = [
+    AutoMigration(from = 1, to = 2), AutoMigration(from = 2, to = 3)
+], exportSchema = true)
+@TypeConverters(DatabaseListConverters::class)
+abstract class AppDatabase : RoomDatabase() {
+    abstract fun settingDao(): SettingsDoa
+    abstract fun tunnelConfigDoa() : TunnelConfigDao
+}

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

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

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

@@ -1,15 +1,16 @@
-package com.zaneschepke.wireguardautotunnel.data
+package com.zaneschepke.wireguardautotunnel.repository
 
 import androidx.room.Dao
 import androidx.room.Delete
 import androidx.room.Insert
 import androidx.room.OnConflictStrategy
 import androidx.room.Query
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.repository.model.Settings
 import kotlinx.coroutines.flow.Flow
 
 @Dao
-interface SettingsDao {
+interface SettingsDoa {
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun save(t: Settings)
 
@@ -22,9 +23,6 @@ interface SettingsDao {
     @Query("SELECT * FROM settings")
     suspend fun getAll(): List<Settings>
 
-    @Query("SELECT * FROM settings LIMIT 1")
-    fun getSettingsFlow(): Flow<Settings>
-
     @Query("SELECT * FROM settings")
     fun getAllFlow(): Flow<MutableList<Settings>>
 

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

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

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

@@ -0,0 +1,28 @@
+package com.zaneschepke.wireguardautotunnel.repository.model
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity
+data class Settings(
+    @PrimaryKey(autoGenerate = true) val id : Int = 0,
+    @ColumnInfo(name = "is_tunnel_enabled") var isAutoTunnelEnabled : Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled") var isTunnelOnMobileDataEnabled : Boolean = false,
+    @ColumnInfo(name = "trusted_network_ssids") var trustedNetworkSSIDs : MutableList<String> = mutableListOf(),
+    @ColumnInfo(name = "default_tunnel") var defaultTunnel : String? = null,
+    @ColumnInfo(name = "is_always_on_vpn_enabled") var isAlwaysOnVpnEnabled : Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_ethernet_enabled") var isTunnelOnEthernetEnabled : Boolean = false,
+    @ColumnInfo(name = "is_shortcuts_enabled", defaultValue = "false") var isShortcutsEnabled : Boolean = false,
+    @ColumnInfo(name = "is_battery_saver_enabled", defaultValue = "false") var isBatterySaverEnabled : Boolean = false,
+    @ColumnInfo(name = "is_tunnel_on_wifi_enabled", defaultValue = "false") var isTunnelOnWifiEnabled : Boolean = false,
+) {
+    fun isTunnelConfigDefault(tunnelConfig: TunnelConfig) : Boolean {
+        return if (defaultTunnel != null) {
+            val defaultConfig = TunnelConfig.from(defaultTunnel!!)
+            (tunnelConfig.id == defaultConfig.id)
+        } else {
+            false
+        }
+    }
+}

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

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

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

@@ -4,10 +4,11 @@ import android.content.Intent
 import android.os.Bundle
 import android.os.IBinder
 import androidx.lifecycle.LifecycleService
-import com.zaneschepke.wireguardautotunnel.util.Constants
 import timber.log.Timber
 
+
 open class ForegroundService : LifecycleService() {
+
     private var isServiceStarted = false
 
     override fun onBind(intent: Intent): IBinder? {
@@ -21,45 +22,44 @@ open class ForegroundService : LifecycleService() {
         Timber.d("onStartCommand executed with startId: $startId")
         if (intent != null) {
             val action = intent.action
+            Timber.d("using an intent with action $action")
             when (action) {
-                Action.START.name,
+                Action.START.name, Action.START_FOREGROUND.name -> startService(intent.extras)
-                Action.START_FOREGROUND.name -> startService(intent.extras)
+                Action.STOP.name -> stopService(intent.extras)
-
+                "android.net.VpnService" -> {
-                Constants.ALWAYS_ON_VPN_ACTION -> {
+                    Timber.d("Always-on VPN starting service")
-                    Timber.i("Always-on VPN starting service")
                     startService(intent.extras)
                 }
-
                 else -> Timber.d("This should never happen. No action in the received intent")
             }
         } else {
             Timber.d(
-                "with a null intent. It has been probably restarted by the system.",
+                "with a null intent. It has been probably restarted by the system."
             )
         }
         // by returning this we make sure the service is restarted if the system kills the service
         return START_STICKY
     }
 
+
     override fun onDestroy() {
         super.onDestroy()
         Timber.d("The service has been destroyed")
-        stopService()
     }
 
-    protected open fun startService(extras: Bundle?) {
+    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)
+            Timber.d("Service stopped without being started: ${e.message}")
         }
         isServiceStarted = false
     }

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

@@ -1,108 +1,101 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground
 
+import android.app.ActivityManager
 import android.app.Service
 import android.content.Context
+import android.content.Context.ACTIVITY_SERVICE
 import android.content.Intent
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.util.Constants
 import timber.log.Timber
 
-class ServiceManager(private val appDataRepository: AppDataRepository) {
+object ServiceManager {
+    @Suppress("DEPRECATION")
+    private // Deprecated for third party Services.
+    fun <T> Context.isServiceRunning(service: Class<T>) =
+        (getSystemService(ACTIVITY_SERVICE) as ActivityManager)
+            .getRunningServices(Integer.MAX_VALUE)
+            .any { it.service.className == service.name }
 
-    private fun <T : Service> actionOnService(
+    fun <T : Service> getServiceState(context: Context, cls : Class<T>): ServiceState {
-        action: Action,
+        val isServiceRunning = context.isServiceRunning(cls)
-        context: Context,
+        return if(isServiceRunning) ServiceState.STARTED else ServiceState.STOPPED
-        cls: Class<T>,
+    }
-        extras: Map<String, Int>? = null
+
-    ) {
+    private fun <T : Service> actionOnService(action: Action, context: Context, cls : Class<T>, extras : Map<String,String>? = null) {
-        val intent =
+        if (getServiceState(context, cls) == ServiceState.STOPPED && action == Action.STOP) return
-            Intent(context, cls).also {
+        if (getServiceState(context, cls) == ServiceState.STARTED && action == Action.START) return
-                it.action = action.name
+        val intent = Intent(context, cls).also {
-                extras?.forEach { (k, v) -> it.putExtra(k, v) }
+            it.action = action.name
+            extras?.forEach {(k, v) ->
+                it.putExtra(k, v)
             }
+        }
         intent.component?.javaClass
         try {
-            when (action) {
+            when(action) {
-                Action.START_FOREGROUND -> context.startForegroundService(intent)
+                Action.START_FOREGROUND -> {
-                Action.START -> context.startService(intent)
+                    context.startForegroundService(intent)
-                Action.STOP -> context.stopService(intent)
+                }
+                Action.START -> {
+                    context.startService(intent)
+                }
+                Action.STOP -> context.startService(intent)
             }
-        } catch (e: Exception) {
+        } catch (e : Exception) {
             Timber.e(e.message)
         }
     }
 
-    suspend fun startVpnService(
+    fun startVpnService(context : Context, tunnelConfig : String) {
-        context: Context,
-        tunnelId: Int? = null,
-        isManualStart: Boolean = false
-    ) {
-        if (isManualStart) onManualStart(tunnelId)
         actionOnService(
             Action.START,
             context,
             WireGuardTunnelService::class.java,
-            tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
+            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig))
-        )
     }
-
+    fun stopVpnService(context : Context) {
-    suspend fun stopVpnService(context: Context, isManualStop: Boolean = false) {
-        if (isManualStop) onManualStop()
-        Timber.i("Stopping vpn service")
         actionOnService(
             Action.STOP,
             context,
-            WireGuardTunnelService::class.java,
+            WireGuardTunnelService::class.java
         )
     }
 
-    private suspend fun onManualStop() {
+    fun startVpnServiceForeground(context : Context, tunnelConfig : String) {
-        appDataRepository.appState.setManualStop()
+        actionOnService(
+            Action.START_FOREGROUND,
+            context,
+            WireGuardTunnelService::class.java,
+            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig))
     }
 
-    private suspend fun onManualStart(tunnelId: Int?) {
+    private fun startWatcherServiceForeground(context : Context, tunnelConfig : String) {
-        tunnelId?.let {
+        actionOnService(
-            appDataRepository.appState.setTunnelRunningFromManualStart(it)
+            Action.START, context,
+            WireGuardConnectivityWatcherService::class.java, mapOf(context.
+            getString(R.string.tunnel_extras_key) to
+                    tunnelConfig))
+    }
+
+    fun startWatcherService(context : Context, tunnelConfig : String) {
+        actionOnService(
+            Action.START, context,
+            WireGuardConnectivityWatcherService::class.java, mapOf(context.
+            getString(R.string.tunnel_extras_key) to
+                    tunnelConfig))
+    }
+
+    fun stopWatcherService(context : Context) {
+        actionOnService(
+            Action.STOP, context,
+            WireGuardConnectivityWatcherService::class.java)
+    }
+
+    fun toggleWatcherServiceForeground(context: Context, tunnelConfig : String) {
+        when(getServiceState( context,
+            WireGuardConnectivityWatcherService::class.java,)) {
+            ServiceState.STARTED -> stopWatcherService(context)
+            ServiceState.STOPPED -> startWatcherServiceForeground(context, tunnelConfig)
         }
     }
-
-    suspend fun startVpnServiceForeground(
-        context: Context,
-        tunnelId: Int? = null,
-        isManualStart: Boolean = false
-    ) {
-        if (isManualStart) onManualStart(tunnelId)
-        actionOnService(
-            Action.START_FOREGROUND,
-            context,
-            WireGuardTunnelService::class.java,
-            tunnelId?.let { mapOf(Constants.TUNNEL_EXTRA_KEY to it) },
-        )
-    }
-
-    fun startWatcherServiceForeground(
-        context: Context,
-    ) {
-        actionOnService(
-            Action.START_FOREGROUND,
-            context,
-            WireGuardConnectivityWatcherService::class.java,
-        )
-    }
-
-    fun startWatcherService(context: Context) {
-        actionOnService(
-            Action.START,
-            context,
-            WireGuardConnectivityWatcherService::class.java,
-        )
-    }
-
-    fun stopWatcherService(context: Context) {
-        actionOnService(
-            Action.STOP,
-            context,
-            WireGuardConnectivityWatcherService::class.java,
-        )
-    }
 }

app/src/main/java/com/zaneschepke/wireguardautotunnel/service/foreground/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,84 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.foreground
-
-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()
-) {
-
-    private fun isVpnConnected() = vpnStatus == Tunnel.State.UP
-    fun isEthernetConditionMet(): Boolean {
-        return (isEthernetConnected &&
-            settings.isTunnelOnEthernetEnabled &&
-            !isVpnConnected())
-    }
-
-    fun isMobileDataConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            settings.isTunnelOnMobileDataEnabled &&
-            !isWifiConnected &&
-            isMobileDataConnected &&
-            !isVpnConnected())
-    }
-
-    fun isTunnelNotMobileDataPreferredConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            settings.isTunnelOnMobileDataEnabled &&
-            !isWifiConnected &&
-            isMobileDataConnected &&
-            config?.isMobileDataTunnel == false && isVpnConnected())
-    }
-
-    fun isTunnelOffOnMobileDataConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            !settings.isTunnelOnMobileDataEnabled &&
-            isMobileDataConnected &&
-            !isWifiConnected &&
-            isVpnConnected())
-    }
-
-    fun isUntrustedWifiConditionMet(): Boolean {
-        return (!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 (!isEthernetConnected &&
-            (isWifiConnected &&
-                settings.trustedNetworkSSIDs.contains(currentNetworkSSID)) &&
-            (isVpnConnected()))
-    }
-
-    fun isTunnelOffOnWifiConditionMet(): Boolean {
-        return (!isEthernetConnected &&
-            (isWifiConnected &&
-                !settings.isTunnelOnWifiEnabled &&
-                (isVpnConnected())))
-    }
-
-    fun isTunnelOffOnNoConnectivityMet(): Boolean {
-        return (!isEthernetConnected &&
-            !isWifiConnected &&
-            !isMobileDataConnected &&
-            (isVpnConnected()))
-    }
-}
-

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

@@ -1,14 +1,18 @@
 package com.zaneschepke.wireguardautotunnel.service.foreground
 
+import android.app.AlarmManager
+import android.app.PendingIntent
 import android.content.Context
+import android.content.Intent
 import android.os.Bundle
 import android.os.PowerManager
-import androidx.core.app.ServiceCompat
+import android.os.SystemClock
 import androidx.lifecycle.lifecycleScope
 import com.wireguard.android.backend.Tunnel
+import com.zaneschepke.wireguardautotunnel.Constants
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.repository.model.Settings
 import com.zaneschepke.wireguardautotunnel.service.network.EthernetService
 import com.zaneschepke.wireguardautotunnel.service.network.MobileDataService
 import com.zaneschepke.wireguardautotunnel.service.network.NetworkService
@@ -16,21 +20,18 @@ import com.zaneschepke.wireguardautotunnel.service.network.NetworkStatus
 import com.zaneschepke.wireguardautotunnel.service.network.WifiService
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.util.Constants
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import timber.log.Timber
-import java.net.InetAddress
 import javax.inject.Inject
 
-
 @AndroidEntryPoint
 class WireGuardConnectivityWatcherService : ForegroundService() {
+
     private val foregroundId = 122
 
     @Inject
@@ -43,7 +44,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     lateinit var ethernetService: NetworkService<EthernetService>
 
     @Inject
-    lateinit var appDataRepository: AppDataRepository
+    lateinit var settingsRepo: SettingsDoa
 
     @Inject
     lateinit var notificationService: NotificationService
@@ -51,48 +52,47 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     @Inject
     lateinit var vpnService: VpnService
 
-    @Inject
+    private var isWifiConnected = false
-    lateinit var serviceManager: ServiceManager
+    private var isEthernetConnected = false
-
+    private var isMobileDataConnected = false
-    private val networkEventsFlow = MutableStateFlow(WatcherState())
+    private var currentNetworkSSID = ""
 
     private lateinit var watcherJob: Job
+    private lateinit var setting: Settings
+    private lateinit var tunnelConfig: String
 
     private var wakeLock: PowerManager.WakeLock? = null
     private val tag = this.javaClass.name
 
+
     override fun onCreate() {
         super.onCreate()
         lifecycleScope.launch(Dispatchers.Main) {
-            try {
+            launchWatcherNotification()
-                if (appDataRepository.settings.getSettings().isAutoTunnelPaused) {
-                    launchWatcherPausedNotification()
-                } else launchWatcherNotification()
-            } catch (e: Exception) {
-                Timber.e("Failed to start watcher service, not enough permissions")
-            }
         }
     }
 
-    override fun onDestroy() {
-        super.onDestroy()
-        stopService()
-    }
-
     override fun startService(extras: Bundle?) {
         super.startService(extras)
-        try {
+        launchWatcherNotification()
-            // we need this lock so our service gets not affected by Doze Mode
+        val tunnelId = extras?.getString(getString(R.string.tunnel_extras_key))
-            lifecycleScope.launch { initWakeLock() }
+        if (tunnelId != null) {
-            cancelWatcherJob()
+            this.tunnelConfig = tunnelId
+        }
+        // we need this lock so our service gets not affected by Doze Mode
+        lifecycleScope.launch {
+            initWakeLock()
+        }
+        cancelWatcherJob()
+        if (this::tunnelConfig.isInitialized) {
             startWatcherJob()
-        } catch (e: Exception) {
+        } else {
-            Timber.e("Failed to launch watcher service, no permissions")
+            stopService(extras)
         }
     }
 
-    override fun stopService() {
+    override fun stopService(extras: Bundle?) {
-        super.stopService()
+        super.stopService(extras)
         wakeLock?.let {
             if (it.isHeld) {
                 it.release()
@@ -102,37 +102,47 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         stopSelf()
     }
 
-    private fun launchWatcherNotification(
+    private fun launchWatcherNotification() {
-        description: String = getString(R.string.watcher_notification_text_active)
+        val notification = notificationService.createNotification(
-    ) {
+            channelId = getString(R.string.watcher_channel_id),
-        val notification =
+            channelName = getString(R.string.watcher_channel_name),
-            notificationService.createNotification(
+            description = getString(R.string.watcher_notification_text),
-                channelId = getString(R.string.watcher_channel_id),
+            vibration = false
-                channelName = getString(R.string.watcher_channel_name),
+        )
-                title = getString(R.string.auto_tunnel_title),
+        super.startForeground(foregroundId, notification)
-                description = description,
+    }
-            )
+
-        ServiceCompat.startForeground(
+    //try to start task again if killed
-            this,
+    override fun onTaskRemoved(rootIntent: Intent) {
-            foregroundId,
+        Timber.d("Task Removed called")
-            notification,
+        val restartServiceIntent = Intent(rootIntent)
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
+        val restartServicePendingIntent: PendingIntent = PendingIntent.getService(
+            this, 1, restartServiceIntent,
+            PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE
+        )
+        applicationContext.getSystemService(Context.ALARM_SERVICE)
+        val alarmService: AlarmManager =
+            applicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        alarmService.set(
+            AlarmManager.ELAPSED_REALTIME,
+            SystemClock.elapsedRealtime() + 1000,
+            restartServicePendingIntent
         )
     }
 
-    private fun launchWatcherPausedNotification() {
+    private suspend fun initWakeLock() {
-        launchWatcherNotification(getString(R.string.watcher_notification_text_paused))
+        val isBatterySaverOn = withContext(lifecycleScope.coroutineContext) {
-    }
+            settingsRepo.getAll().firstOrNull()?.isBatterySaverEnabled ?: false
-
+        }
-    private fun initWakeLock() {
         wakeLock =
             (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
                 newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
-                    try {
+                    if (isBatterySaverOn) {
-                        Timber.i("Initiating wakelock with 10 min timeout")
+                        Timber.d("Initiating wakelock with timeout")
-                        acquire(Constants.BATTERY_SAVER_WATCHER_WAKE_LOCK_TIMEOUT)
+                        acquire(Constants.WATCHER_SERVICE_WAKE_LOCK_TIMEOUT)
-                    } finally {
+                    } else {
-                        release()
+                        Timber.d("Initiating wakelock with zero timeout")
+                        acquire()
                     }
                 }
             }
@@ -145,161 +155,67 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     }
 
     private fun startWatcherJob() {
-        watcherJob =
+        watcherJob = lifecycleScope.launch(Dispatchers.IO) {
-            lifecycleScope.launch(Dispatchers.IO) {
+            val settings = settingsRepo.getAll()
-                val setting = appDataRepository.settings.getSettings()
+            if (settings.isNotEmpty()) {
-                launch {
+                setting = settings[0]
-                    Timber.i("Starting wifi watcher")
-                    watchForWifiConnectivityChanges()
-                }
-                if (setting.isTunnelOnMobileDataEnabled) {
-                    launch {
-                        Timber.i("Starting mobile data watcher")
-                        watchForMobileDataConnectivityChanges()
-                    }
-                }
-                if (setting.isTunnelOnEthernetEnabled) {
-                    launch {
-                        Timber.i("Starting ethernet data watcher")
-                        watchForEthernetConnectivityChanges()
-                    }
-                }
-                launch {
-                    Timber.i("Starting vpn state watcher")
-                    watchForVpnConnectivityChanges()
-                }
-                launch {
-                    Timber.i("Starting settings watcher")
-                    watchForSettingsChanges()
-                }
-                if (setting.isPingEnabled) {
-                    launch {
-                        Timber.i("Starting ping watcher")
-                        watchForPingFailure()
-                    }
-                }
-                launch {
-                    Timber.i("Starting management watcher")
-                    manageVpn()
-                }
-
             }
+            launch {
+                watchForWifiConnectivityChanges()
+            }
+            if (setting.isTunnelOnMobileDataEnabled) {
+                launch {
+                    watchForMobileDataConnectivityChanges()
+                }
+            }
+            if (setting.isTunnelOnEthernetEnabled) {
+                launch {
+                    watchForEthernetConnectivityChanges()
+                }
+            }
+            launch {
+                manageVpn()
+            }
+        }
     }
 
     private suspend fun watchForMobileDataConnectivityChanges() {
         mobileDataService.networkStatus.collect {
             when (it) {
                 is NetworkStatus.Available -> {
-                    Timber.i("Gained Mobile data connection")
+                    Timber.d("Gained Mobile data connection")
-                    networkEventsFlow.value =
+                    isMobileDataConnected = true
-                        networkEventsFlow.value.copy(
-                            isMobileDataConnected = true,
-                        )
                 }
 
                 is NetworkStatus.CapabilitiesChanged -> {
-                    networkEventsFlow.value =
+                    isMobileDataConnected = true
-                        networkEventsFlow.value.copy(
+                    Timber.d("Mobile data capabilities changed")
-                            isMobileDataConnected = true,
-                        )
-                    Timber.i("Mobile data capabilities changed")
                 }
 
                 is NetworkStatus.Unavailable -> {
-                    networkEventsFlow.value =
+                    isMobileDataConnected = false
-                        networkEventsFlow.value.copy(
+                    Timber.d("Lost mobile data connection")
-                            isMobileDataConnected = false,
-                        )
-                    Timber.i("Lost mobile data connection")
                 }
             }
         }
     }
 
-    private suspend fun watchForPingFailure() {
-        try {
-            do {
-                if (vpnService.vpnState.value.status == Tunnel.State.UP) {
-                    val tunnelConfig = vpnService.vpnState.value.tunnelConfig
-                    tunnelConfig?.let {
-                        val config = TunnelConfig.configFromQuick(it.wgQuick)
-                        val results = config.peers.map { peer ->
-                            val host = if (peer.endpoint.isPresent &&
-                                peer.endpoint.get().resolved.isPresent)
-                                peer.endpoint.get().resolved.get().host
-                            else Constants.BACKUP_PING_HOST
-                            Timber.i("Checking reachability of: $host")
-                            val reachable = InetAddress.getByName(host)
-                                .isReachable(Constants.PING_TIMEOUT.toInt())
-                            Timber.i("Result: reachable - $reachable")
-                            reachable
-                        }
-                        if (results.contains(false)) {
-                            Timber.i("Restarting VPN for ping failure")
-                            serviceManager.stopVpnService(this)
-                            delay(Constants.VPN_RESTART_DELAY)
-                            serviceManager.startVpnServiceForeground(this)
-                            delay(Constants.PING_COOLDOWN)
-                        }
-                    }
-                }
-                delay(Constants.PING_INTERVAL)
-            } while (true)
-        } catch (e: Exception) {
-            Timber.e(e)
-        }
-    }
-
-    private suspend fun watchForSettingsChanges() {
-        appDataRepository.settings.getSettingsFlow().collect {
-            if (networkEventsFlow.value.settings.isAutoTunnelPaused != it.isAutoTunnelPaused) {
-                when (it.isAutoTunnelPaused) {
-                    true -> launchWatcherPausedNotification()
-                    false -> launchWatcherNotification()
-                }
-            }
-            networkEventsFlow.value =
-                networkEventsFlow.value.copy(
-                    settings = it,
-                )
-        }
-    }
-
-    private suspend fun watchForVpnConnectivityChanges() {
-        vpnService.vpnState.collect {
-            networkEventsFlow.value =
-                networkEventsFlow.value.copy(
-                    vpnStatus = it.status,
-                    config = it.tunnelConfig,
-                )
-        }
-    }
-
     private suspend fun watchForEthernetConnectivityChanges() {
         ethernetService.networkStatus.collect {
             when (it) {
                 is NetworkStatus.Available -> {
-                    Timber.i("Gained Ethernet connection")
+                    Timber.d("Gained Ethernet connection")
-                    networkEventsFlow.value =
+                    isEthernetConnected = true
-                        networkEventsFlow.value.copy(
-                            isEthernetConnected = true,
-                        )
                 }
 
                 is NetworkStatus.CapabilitiesChanged -> {
-                    Timber.i("Ethernet capabilities changed")
+                    Timber.d("Ethernet capabilities changed")
-                    networkEventsFlow.value =
+                    isEthernetConnected = true
-                        networkEventsFlow.value.copy(
-                            isEthernetConnected = true,
-                        )
                 }
 
                 is NetworkStatus.Unavailable -> {
-                    networkEventsFlow.value =
+                    isEthernetConnected = false
-                        networkEventsFlow.value.copy(
+                    Timber.d("Lost Ethernet connection")
-                            isEthernetConnected = false,
-                        )
-                    Timber.i("Lost Ethernet connection")
                 }
             }
         }
@@ -309,122 +225,58 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
         wifiService.networkStatus.collect {
             when (it) {
                 is NetworkStatus.Available -> {
-                    Timber.i("Gained Wi-Fi connection")
+                    Timber.d("Gained Wi-Fi connection")
-                    networkEventsFlow.value =
+                    isWifiConnected = true
-                        networkEventsFlow.value.copy(
-                            isWifiConnected = true,
-                        )
                 }
 
                 is NetworkStatus.CapabilitiesChanged -> {
-                    Timber.i("Wifi capabilities changed")
+                    Timber.d("Wifi capabilities changed")
-                    networkEventsFlow.value =
+                    isWifiConnected = true
-                        networkEventsFlow.value.copy(
+                    currentNetworkSSID = wifiService.getNetworkName(it.networkCapabilities) ?: ""
-                            isWifiConnected = true,
-                        )
-                    val ssid = wifiService.getNetworkName(it.networkCapabilities)
-                    ssid?.let {
-                        Timber.i("Detected SSID: $ssid")
-                        appDataRepository.appState.setCurrentSsid(ssid)
-                        networkEventsFlow.value =
-                            networkEventsFlow.value.copy(
-                                currentNetworkSSID = ssid,
-                            )
-                    } ?: Timber.w("Failed to read ssid")
                 }
 
                 is NetworkStatus.Unavailable -> {
-                    networkEventsFlow.value =
+                    isWifiConnected = false
-                        networkEventsFlow.value.copy(
+                    Timber.d("Lost Wi-Fi connection")
-                            isWifiConnected = false,
-                        )
-                    Timber.i("Lost Wi-Fi connection")
                 }
             }
         }
     }
 
-    private suspend fun getMobileDataTunnel(): TunnelConfig? {
-        return appDataRepository.tunnels.findByMobileDataTunnel().firstOrNull()
-    }
-
-    private suspend fun getSsidTunnel(ssid: String): TunnelConfig? {
-        return appDataRepository.tunnels.findByTunnelNetworksName(ssid).firstOrNull()
-    }
-
     private suspend fun manageVpn() {
-        networkEventsFlow.collectLatest { watcherState ->
+        while (true) {
-            val autoTunnel = "Auto-tunnel watcher"
+            if (isEthernetConnected && setting.isTunnelOnEthernetEnabled && vpnService.getState() == Tunnel.State.DOWN) {
-            if (!watcherState.settings.isAutoTunnelPaused) {
+                ServiceManager.startVpnService(this, tunnelConfig)
-                //delay for rapid network state changes and then collect latest
-                delay(Constants.WATCHER_COLLECTION_DELAY)
-                when {
-                    watcherState.isEthernetConditionMet() -> {
-                        Timber.i("$autoTunnel - tunnel on on ethernet condition met")
-                        serviceManager.startVpnServiceForeground(this)
-                    }
-
-                    watcherState.isMobileDataConditionMet() -> {
-                        Timber.i("$autoTunnel - tunnel on on mobile data condition met")
-                        serviceManager.startVpnServiceForeground(this, getMobileDataTunnel()?.id)
-                    }
-
-                    watcherState.isTunnelNotMobileDataPreferredConditionMet() -> {
-                        getMobileDataTunnel()?.let {
-                            Timber.i("$autoTunnel - tunnel connected on mobile data is not preferred condition met, switching to preferred")
-                            serviceManager.startVpnServiceForeground(
-                                this,
-                                getMobileDataTunnel()?.id,
-                            )
-                        }
-                    }
-
-                    watcherState.isTunnelOffOnMobileDataConditionMet() -> {
-                        Timber.i("$autoTunnel - tunnel off on mobile data met, turning vpn off")
-                        serviceManager.stopVpnService(this)
-                    }
-
-                    watcherState.isTunnelNotWifiNamePreferredMet(watcherState.currentNetworkSSID) -> {
-                        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")
-                            serviceManager.startVpnServiceForeground(this, it.id)
-                        } ?: suspend {
-                            Timber.i("No tunnel associated with this SSID, using defaults")
-                            if (appDataRepository.getPrimaryOrFirstTunnel()?.name != vpnService.name) {
-                                serviceManager.startVpnServiceForeground(this)
-                            }
-                        }.invoke()
-                    }
-
-                    watcherState.isUntrustedWifiConditionMet() -> {
-                        Timber.i("$autoTunnel - tunnel on untrusted wifi condition met")
-                        serviceManager.startVpnServiceForeground(
-                            this,
-                            getSsidTunnel(watcherState.currentNetworkSSID)?.id,
-                        )
-                    }
-
-                    watcherState.isTrustedWifiConditionMet() -> {
-                        Timber.i("$autoTunnel - tunnel off on trusted wifi condition met, turning vpn off")
-                        serviceManager.stopVpnService(this)
-                    }
-
-                    watcherState.isTunnelOffOnWifiConditionMet() -> {
-                        Timber.i("$autoTunnel - tunnel off on wifi condition met, turning vpn off")
-                        serviceManager.stopVpnService(this)
-                    }
-
-                    watcherState.isTunnelOffOnNoConnectivityMet() -> {
-                        Timber.i("$autoTunnel - tunnel off on no connectivity met, turning vpn off")
-                        serviceManager.stopVpnService(this)
-                    }
-
-                    else -> {
-                        Timber.i("$autoTunnel - no condition met")
-                    }
-                }
             }
+            if (!isEthernetConnected && setting.isTunnelOnMobileDataEnabled &&
+                !isWifiConnected &&
+                isMobileDataConnected
+                && vpnService.getState() == Tunnel.State.DOWN
+            ) {
+                ServiceManager.startVpnService(this, tunnelConfig)
+            } else if (!isEthernetConnected && !setting.isTunnelOnMobileDataEnabled &&
+                !isWifiConnected &&
+                vpnService.getState() == Tunnel.State.UP
+            ) {
+                ServiceManager.stopVpnService(this)
+            } else if (!isEthernetConnected && isWifiConnected &&
+                !setting.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
+                setting.isTunnelOnWifiEnabled &&
+                (vpnService.getState() != Tunnel.State.UP)
+            ) {
+                ServiceManager.startVpnService(this, tunnelConfig)
+            } else if (!isEthernetConnected && (isWifiConnected &&
+                        setting.trustedNetworkSSIDs.contains(currentNetworkSSID)) &&
+                (vpnService.getState() == Tunnel.State.UP)
+            ) {
+                ServiceManager.stopVpnService(this)
+            } else if (!isEthernetConnected && (isWifiConnected &&
+                        !setting.isTunnelOnWifiEnabled &&
+                (vpnService.getState() == Tunnel.State.UP)
+            )) {
+                ServiceManager.stopVpnService(this)
+            }
+            delay(Constants.VPN_CONNECTIVITY_CHECK_INTERVAL)
         }
     }
 }

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

@@ -3,186 +3,162 @@ package com.zaneschepke.wireguardautotunnel.service.foreground
 import android.app.PendingIntent
 import android.content.Intent
 import android.os.Bundle
-import androidx.core.app.ServiceCompat
 import androidx.lifecycle.lifecycleScope
-import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.handshakeStatus
-import com.zaneschepke.wireguardautotunnel.util.mapPeerStats
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class WireGuardTunnelService : ForegroundService() {
+
     private val foregroundId = 123
 
     @Inject
-    lateinit var vpnService: VpnService
+    lateinit var vpnService : VpnService
 
     @Inject
-    lateinit var appDataRepository: AppDataRepository
+    lateinit var settingsRepo: SettingsDoa
 
     @Inject
-    lateinit var notificationService: NotificationService
+    lateinit var notificationService : NotificationService
 
-    private lateinit var job: Job
+    private lateinit var job : Job
 
-    private var didShowConnected = false
+    private var tunnelName : String = ""
 
     override fun onCreate() {
         super.onCreate()
         lifecycleScope.launch(Dispatchers.Main) {
-            //TODO fix this to not launch if AOVPN
+            launchVpnStartingNotification()
-            if (appDataRepository.tunnels.count() != 0) {
-                launchVpnNotification()
-            }
         }
     }
 
-    override fun onDestroy() {
+    override fun startService(extras : Bundle?) {
-        super.onDestroy()
-
-    }
-
-    override fun startService(extras: Bundle?) {
         super.startService(extras)
+        launchVpnStartingNotification()
+        val tunnelConfigString = extras?.getString(getString(R.string.tunnel_extras_key))
         cancelJob()
-        job =
+        job = lifecycleScope.launch(Dispatchers.IO) {
-            lifecycleScope.launch(Dispatchers.IO) {
+            launch {
-                launch {
+                if(tunnelConfigString != null) {
-                    val tunnelId = extras?.getInt(Constants.TUNNEL_EXTRA_KEY)
+                    try {
-                    if (vpnService.getState() == Tunnel.State.UP) {
+                        val tunnelConfig = TunnelConfig.from(tunnelConfigString)
-                        vpnService.stopTunnel()
+                        tunnelName = tunnelConfig.name
+                        vpnService.startTunnel(tunnelConfig)
+                    } catch (e : Exception) {
+                        Timber.e("Problem starting tunnel: ${e.message}")
+                        stopService(extras)
+                    }
+                } else {
+                    Timber.d("Tunnel config null, starting default tunnel")
+                    val settings = settingsRepo.getAll()
+                    if(settings.isNotEmpty()) {
+                        val setting = settings[0]
+                        if(setting.defaultTunnel != null && setting.isAlwaysOnVpnEnabled) {
+                            val tunnelConfig = TunnelConfig.from(setting.defaultTunnel!!)
+                            tunnelName = tunnelConfig.name
+                            vpnService.startTunnel(tunnelConfig)
+                        }
                     }
-                    vpnService.startTunnel(
-                        tunnelId?.let {
-                            appDataRepository.tunnels.getById(it)
-                        },
-                    )
-                }
-                launch {
-                    handshakeNotifications()
                 }
             }
-    }
+            launch {
-
+                var didShowConnected = false
-    //TODO improve tunnel notifications
+                var didShowFailedHandshakeNotification = false
-    private suspend fun handshakeNotifications() {
+                vpnService.handshakeStatus.collect {
-        var tunnelName: String? = null
+                    when(it) {
-        vpnService.vpnState.collect { state ->
+                        HandshakeStatus.NOT_STARTED -> {
-            state.statistics
+                        }
-                ?.mapPeerStats()
+                        HandshakeStatus.NEVER_CONNECTED -> {
-                ?.map { it.value?.handshakeStatus() }
+                            if(!didShowFailedHandshakeNotification) {
-                .let { statuses ->
+                                launchVpnConnectionFailedNotification(getString(R.string.initial_connection_failure_message))
-                    when {
+                                didShowFailedHandshakeNotification = true
-                        statuses?.all { it == HandshakeStatus.HEALTHY } == true -> {
+                                didShowConnected = false
-                            if (!didShowConnected) {
+                            }
-                                delay(Constants.VPN_CONNECTED_NOTIFICATION_DELAY)
+                        }
-                                tunnelName = state.tunnelConfig?.name
+                        HandshakeStatus.HEALTHY -> {
-                                launchVpnNotification(
+                            if(!didShowConnected) {
-                                    getString(R.string.tunnel_start_title),
+                                launchVpnConnectedNotification()
-                                    "${getString(R.string.tunnel_start_text)} - $tunnelName",
-                                )
                                 didShowConnected = true
                             }
                         }
-
+                        HandshakeStatus.UNHEALTHY -> {
-                        statuses?.any { it == HandshakeStatus.STALE } == true -> {}
+                            if(!didShowFailedHandshakeNotification) {
-                        statuses?.all { it == HandshakeStatus.NOT_STARTED } ==
+                                launchVpnConnectionFailedNotification(getString(R.string.lost_connection_failure_message))
-                            true -> {
+                                didShowFailedHandshakeNotification = true
+                                didShowConnected = false
+                            }
                         }
-
-                        else -> {}
                     }
                 }
-            if (state.status == Tunnel.State.UP && state.tunnelConfig?.name != tunnelName) {
-                tunnelName = state.tunnelConfig?.name
-                launchVpnNotification(
-                    getString(R.string.tunnel_start_title),
-                    "${getString(R.string.tunnel_start_text)} - $tunnelName",
-                )
             }
         }
     }
 
-    private fun launchAlwaysOnDisabledNotification() {
+    override fun stopService(extras : Bundle?) {
-        launchVpnNotification(
+        super.stopService(extras)
-            title = this.getString(R.string.vpn_connection_failed),
-            description = this.getString(R.string.always_on_disabled),
-        )
-    }
-
-    override fun stopService() {
-        super.stopService()
         lifecycleScope.launch(Dispatchers.IO) {
             vpnService.stopTunnel()
-            didShowConnected = false
         }
         cancelJob()
         stopSelf()
     }
 
-    private fun launchVpnNotification(
+    private fun launchVpnConnectedNotification() {
-        title: String = getString(R.string.vpn_starting),
+        val notification = notificationService.createNotification(
-        description: String = getString(R.string.attempt_connection)
+            channelId = getString(R.string.vpn_channel_id),
-    ) {
+            channelName = getString(R.string.vpn_channel_name),
-        val notification =
+            title = getString(R.string.tunnel_start_title),
-            notificationService.createNotification(
+            onGoing = false,
-                channelId = getString(R.string.vpn_channel_id),
+            vibration = false,
-                channelName = getString(R.string.vpn_channel_name),
+            showTimestamp = true,
-                title = title,
+            description = "${getString(R.string.tunnel_start_text)} $tunnelName"
-                onGoing = false,
-                vibration = false,
-                showTimestamp = true,
-                description = description,
-            )
-        ServiceCompat.startForeground(
-            this,
-            foregroundId,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
         )
+        super.startForeground(foregroundId, notification)
     }
 
-    private fun launchVpnConnectionFailedNotification(message: String) {
+    private fun launchVpnStartingNotification() {
-        val notification =
+        val notification = notificationService.createNotification(
-            notificationService.createNotification(
+            channelId = getString(R.string.vpn_channel_id),
-                channelId = getString(R.string.vpn_channel_id),
+            channelName = getString(R.string.vpn_channel_name),
-                channelName = getString(R.string.vpn_channel_name),
+            title = getString(R.string.vpn_starting),
-                action =
+            onGoing = false,
-                PendingIntent.getBroadcast(
+            vibration = false,
-                    this,
+            showTimestamp = true,
-                    0,
+            description = getString(R.string.attempt_connection)
-                    Intent(this, NotificationActionReceiver::class.java),
-                    PendingIntent.FLAG_IMMUTABLE,
-                ),
-                actionText = getString(R.string.restart),
-                title = getString(R.string.vpn_connection_failed),
-                onGoing = false,
-                vibration = true,
-                showTimestamp = true,
-                description = message,
-            )
-        ServiceCompat.startForeground(
-            this,
-            foregroundId,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID,
         )
+        super.startForeground(foregroundId, notification)
     }
 
+    private fun launchVpnConnectionFailedNotification(message : String) {
+        val notification = notificationService.createNotification(
+            channelId = getString(R.string.vpn_channel_id),
+            channelName = getString(R.string.vpn_channel_name),
+            action = PendingIntent.getBroadcast(this,0,
+                Intent(this, NotificationActionReceiver::class.java),PendingIntent.FLAG_IMMUTABLE),
+            actionText = getString(R.string.restart),
+            title = getString(R.string.vpn_connection_failed),
+            onGoing = false,
+            vibration = true,
+            showTimestamp = true,
+            description = message
+        )
+        super.startForeground(foregroundId, notification)
+    }
+
+
     private fun cancelJob() {
-        if (this::job.isInitialized) {
+        if(this::job.isInitialized) {
             job.cancel()
         }
     }

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

@@ -14,10 +14,8 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.callbackFlow
 import kotlinx.coroutines.flow.map
 
-abstract class BaseNetworkService<T : BaseNetworkService<T>>(
+
-    val context: Context,
+abstract class BaseNetworkService<T : BaseNetworkService<T>>(val context: Context, networkCapability : Int) : NetworkService<T> {
-    networkCapability: Int
-) : NetworkService<T> {
     private val connectivityManager =
         context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
 
@@ -25,70 +23,61 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
         context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
 
     override val networkStatus = callbackFlow {
-        val networkStatusCallback =
+        val networkStatusCallback = when (Build.VERSION.SDK_INT) {
-            when (Build.VERSION.SDK_INT) {
+            in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
-                in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
+                object : ConnectivityManager.NetworkCallback(
-                    object :
+                    FLAG_INCLUDE_LOCATION_INFO
-                        ConnectivityManager.NetworkCallback(
+                ) {
-                            FLAG_INCLUDE_LOCATION_INFO,
+                    override fun onAvailable(network: Network) {
-                        ) {
+                        trySend(NetworkStatus.Available(network))
-                        override fun onAvailable(network: Network) {
-                            trySend(NetworkStatus.Available(network))
-                        }
-
-                        override fun onLost(network: Network) {
-                            trySend(NetworkStatus.Unavailable(network))
-                        }
-
-                        override fun onCapabilitiesChanged(
-                            network: Network,
-                            networkCapabilities: NetworkCapabilities
-                        ) {
-                            trySend(
-                                NetworkStatus.CapabilitiesChanged(
-                                    network,
-                                    networkCapabilities,
-                                ),
-                            )
-                        }
                     }
-                }
 
-                else -> {
+                    override fun onLost(network: Network) {
-                    object : ConnectivityManager.NetworkCallback() {
+                        trySend(NetworkStatus.Unavailable(network))
-                        override fun onAvailable(network: Network) {
+                    }
-                            trySend(NetworkStatus.Available(network))
-                        }
 
-                        override fun onLost(network: Network) {
+                    override fun onCapabilitiesChanged(
-                            trySend(NetworkStatus.Unavailable(network))
+                        network: Network,
-                        }
+                        networkCapabilities: NetworkCapabilities
-
+                    ) {
-                        override fun onCapabilitiesChanged(
+                        trySend(NetworkStatus.CapabilitiesChanged(network, networkCapabilities))
-                            network: Network,
-                            networkCapabilities: NetworkCapabilities
-                        ) {
-                            trySend(
-                                NetworkStatus.CapabilitiesChanged(
-                                    network,
-                                    networkCapabilities,
-                                ),
-                            )
-                        }
                     }
                 }
             }
-        val request =
+
-            NetworkRequest.Builder()
+            else -> {
-                .addTransportType(networkCapability)
+                object : ConnectivityManager.NetworkCallback() {
-                .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+
-                .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+                    override fun onAvailable(network: Network) {
-                .build()
+                        trySend(NetworkStatus.Available(network))
+                    }
+
+                    override fun onLost(network: Network) {
+                        trySend(NetworkStatus.Unavailable(network))
+                    }
+
+                    override fun onCapabilitiesChanged(
+                        network: Network,
+                        networkCapabilities: NetworkCapabilities
+                    ) {
+                        trySend(NetworkStatus.CapabilitiesChanged(network, networkCapabilities))
+                    }
+                }
+            }
+        }
+        val request = NetworkRequest.Builder()
+            .addTransportType(networkCapability)
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+            .build()
         connectivityManager.registerNetworkCallback(request, networkStatusCallback)
 
-        awaitClose { connectivityManager.unregisterNetworkCallback(networkStatusCallback) }
+        awaitClose {
+            connectivityManager.unregisterNetworkCallback(networkStatusCallback)
+        }
     }
 
+
     override fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
         var ssid: String? = getWifiNameFromCapabilities(networkCapabilities)
         if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) {
@@ -100,6 +89,7 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
         return ssid?.trim('"')
     }
 
+
     companion object {
         private fun getWifiNameFromCapabilities(networkCapabilities: NetworkCapabilities): String? {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
@@ -115,18 +105,13 @@ abstract class BaseNetworkService<T : BaseNetworkService<T>>(
 }
 
 inline fun <Result> Flow<NetworkStatus>.map(
-    crossinline onUnavailable: suspend (network: Network) -> Result,
+    crossinline onUnavailable: suspend (network : Network) -> Result,
-    crossinline onAvailable: suspend (network: Network) -> Result,
+    crossinline onAvailable: suspend (network : Network) -> Result,
-    crossinline onCapabilitiesChanged:
+    crossinline onCapabilitiesChanged: suspend (network : Network, networkCapabilities : NetworkCapabilities) -> Result,
-    suspend (network: Network, networkCapabilities: NetworkCapabilities) -> Result
 ): Flow<Result> = map { status ->
     when (status) {
         is NetworkStatus.Unavailable -> onUnavailable(status.network)
         is NetworkStatus.Available -> onAvailable(status.network)
-        is NetworkStatus.CapabilitiesChanged ->
+        is NetworkStatus.CapabilitiesChanged -> onCapabilitiesChanged(status.network, status.networkCapabilities)
-            onCapabilitiesChanged(
-                status.network,
-                status.networkCapabilities,
-            )
     }
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -12,11 +12,10 @@ interface NotificationService {
         action: PendingIntent? = null,
         actionText: String? = null,
         description: String,
-        showTimestamp: Boolean = false,
+        showTimestamp : Boolean = false,
         importance: Int = NotificationManager.IMPORTANCE_HIGH,
         vibration: Boolean = false,
         onGoing: Boolean = true,
-        lights: Boolean = true,
+        lights: Boolean = true
-        onlyAlertOnce: Boolean = true,
     ): Notification
 }

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

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

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

@@ -3,64 +3,64 @@ 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.repository.SettingsDoa
+import com.zaneschepke.wireguardautotunnel.repository.TunnelConfigDao
+import com.zaneschepke.wireguardautotunnel.repository.model.Settings
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 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 com.zaneschepke.wireguardautotunnel.util.WgTunnelException
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class ShortcutsActivity : ComponentActivity() {
 
     @Inject
-    lateinit var appDataRepository: AppDataRepository
+    lateinit var settingsRepo : SettingsDoa
 
     @Inject
-    lateinit var serviceManager: ServiceManager
+    lateinit var tunnelConfigRepo : TunnelConfigDao
+
+    private fun attemptWatcherServiceToggle(tunnelConfig : String) {
+        lifecycleScope.launch(Dispatchers.Main) {
+            val settings = getSettings()
+            if(settings.isAutoTunnelEnabled) {
+                ServiceManager.toggleWatcherServiceForeground(this@ShortcutsActivity, tunnelConfig)
+            }
+        }
+    }
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        lifecycleScope.launch(Dispatchers.Main) {
+        if(intent.getStringExtra(CLASS_NAME_EXTRA_KEY)
-            val settings = appDataRepository.settings.getSettings()
+            .equals(WireGuardTunnelService::class.java.simpleName)) {
-            if (settings.isShortcutsEnabled) {
+            lifecycleScope.launch(Dispatchers.Main) {
-                when (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)) {
+                val settings = getSettings()
-                    WireGuardTunnelService::class.java.simpleName -> {
+                if(settings.isShortcutsEnabled) {
+                    try {
                         val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
-                        val tunnelConfig = tunnelName?.let {
+                        val tunnelConfig = if(tunnelName != null) {
-                            appDataRepository.tunnels.getAll().firstOrNull {
+                            tunnelConfigRepo.getAll().firstOrNull { it.name == tunnelName }
-                                it.name == tunnelName
+                        } else {
+                            if(settings.defaultTunnel == null) {
+                                tunnelConfigRepo.getAll().first()
+                            } else {
+                                TunnelConfig.from(settings.defaultTunnel!!)
                             }
                         }
-                        when (intent.action) {
+                        tunnelConfig ?: return@launch
-                            Action.START.name -> serviceManager.startVpnServiceForeground(
+                        attemptWatcherServiceToggle(tunnelConfig.toString())
-                                this@ShortcutsActivity, tunnelConfig?.id, isManualStart = true,
+                        when(intent.action){
-                            )
+                            Action.STOP.name -> ServiceManager.stopVpnService(this@ShortcutsActivity)
-
+                            Action.START.name -> ServiceManager.startVpnService(this@ShortcutsActivity, tunnelConfig.toString())
-                            Action.STOP.name -> serviceManager.stopVpnService(
-                                this@ShortcutsActivity,
-                                isManualStop = true,
-                            )
-                        }
-                    }
-
-                    WireGuardConnectivityWatcherService::class.java.simpleName -> {
-                        when (intent.action) {
-                            Action.START.name -> appDataRepository.settings.save(
-                                settings.copy(
-                                    isAutoTunnelPaused = false,
-                                ),
-                            )
-
-                            Action.STOP.name -> appDataRepository.settings.save(
-                                settings.copy(
-                                    isAutoTunnelPaused = true,
-                                ),
-                            )
                         }
+                    } catch (e : Exception) {
+                        Timber.e(e.message)
                     }
                 }
             }
@@ -68,6 +68,14 @@ class ShortcutsActivity : ComponentActivity() {
         finish()
     }
 
+    private suspend fun getSettings() : Settings {
+        val settings = settingsRepo.getAll()
+        return if (settings.isNotEmpty()) {
+            settings.first()
+        } else {
+            throw WgTunnelException("Settings empty")
+        }
+    }
     companion object {
         const val TUNNEL_NAME_EXTRA_KEY = "tunnelName"
         const val CLASS_NAME_EXTRA_KEY = "className"

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

@@ -1,111 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.service.tile
-
-import android.os.Build
-import android.service.quicksettings.Tile
-import android.service.quicksettings.TileService
-import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.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() {
-
-    @Inject
-    lateinit var appDataRepository: AppDataRepository
-
-    @Inject
-    lateinit var serviceManager: ServiceManager
-
-    private val scope = CoroutineScope(Dispatchers.IO)
-
-    private var manualStartConfig: TunnelConfig? = null
-
-    override fun onStartListening() {
-        super.onStartListening()
-        scope.launch {
-            appDataRepository.settings.getSettingsFlow().collectLatest {
-                when (it.isAutoTunnelEnabled) {
-                    true -> {
-                        if (it.isAutoTunnelPaused) {
-                            setInactive()
-                            setTileDescription(this@AutoTunnelControlTile.getString(R.string.paused))
-                        } else {
-                            setActive()
-                            setTileDescription(this@AutoTunnelControlTile.getString(R.string.active))
-                        }
-                    }
-
-                    false -> {
-                        setTileDescription(this@AutoTunnelControlTile.getString(R.string.disabled))
-                        setUnavailable()
-                    }
-                }
-            }
-        }
-    }
-
-    override fun onTileAdded() {
-        super.onTileAdded()
-        onStartListening()
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        scope.cancel()
-    }
-
-    override fun onTileRemoved() {
-        super.onTileRemoved()
-        scope.cancel()
-    }
-
-    override fun onClick() {
-        super.onClick()
-        unlockAndRun {
-            scope.launch {
-                try {
-                    appDataRepository.toggleWatcherServicePause()
-                } catch (e: Exception) {
-                    Timber.e(e.message)
-                } finally {
-                    cancel()
-                }
-            }
-        }
-    }
-
-    private fun setActive() {
-        qsTile.state = Tile.STATE_ACTIVE
-        qsTile.updateTile()
-    }
-
-    private fun setInactive() {
-        qsTile.state = Tile.STATE_INACTIVE
-        qsTile.updateTile()
-    }
-
-    private fun setUnavailable() {
-        manualStartConfig = null
-        qsTile.state = Tile.STATE_UNAVAILABLE
-        qsTile.updateTile()
-    }
-
-    private fun setTileDescription(description: String) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-            qsTile.subtitle = description
-        }
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            qsTile.stateDescription = description
-        }
-        qsTile.updateTile()
-    }
-}

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

@@ -4,13 +4,16 @@ import android.os.Build
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
 import com.wireguard.android.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
+import com.zaneschepke.wireguardautotunnel.repository.TunnelConfigDao
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
@@ -20,43 +23,28 @@ import javax.inject.Inject
 class TunnelControlTile : TileService() {
 
     @Inject
-    lateinit var appDataRepository: AppDataRepository
+    lateinit var settingsRepo : SettingsDoa
 
     @Inject
-    lateinit var vpnService: VpnService
+    lateinit var configRepo : TunnelConfigDao
 
     @Inject
-    lateinit var serviceManager: ServiceManager
+    lateinit var vpnService : VpnService
 
-    private val scope = CoroutineScope(Dispatchers.IO)
+    private val scope = CoroutineScope(Dispatchers.Main)
 
-    private var manualStartConfig: TunnelConfig? = null
+    private lateinit var job : Job
 
     override fun onStartListening() {
-        super.onStartListening()
+        job = scope.launch {
-        Timber.d("On start listening called")
+            updateTileState()
-        scope.launch {
-            vpnService.vpnState.collect { it ->
-                when (it.status) {
-                    Tunnel.State.UP -> {
-                        setActive()
-                        it.tunnelConfig?.name?.let { name -> setTileDescription(name) }
-                    }
-
-                    Tunnel.State.DOWN -> {
-                        setInactive()
-                        val config = appDataRepository.getStartTunnelConfig()?.also { config ->
-                            manualStartConfig = config
-                        } ?: appDataRepository.getPrimaryOrFirstTunnel()
-                        config?.let {
-                            setTileDescription(it.name)
-                        } ?: setUnavailable()
-                    }
-
-                    else -> setInactive()
-                }
-            }
         }
+        super.onStartListening()
+    }
+
+    override fun onTileRemoved() {
+        super.onTileRemoved()
+        cancelJob()
     }
 
     override fun onDestroy() {
@@ -64,32 +52,21 @@ class TunnelControlTile : TileService() {
         scope.cancel()
     }
 
-    override fun onTileRemoved() {
-        super.onTileRemoved()
-        scope.cancel()
-    }
-
-    override fun onTileAdded() {
-        super.onTileAdded()
-        onStartListening()
-    }
-
     override fun onClick() {
         super.onClick()
         unlockAndRun {
             scope.launch {
                 try {
-                    if (vpnService.getState() == Tunnel.State.UP) {
+                    val tunnel = determineTileTunnel()
-                        serviceManager.stopVpnService(
+                    if(tunnel != null) {
-                            this@TunnelControlTile,
+                        attemptWatcherServiceToggle(tunnel.toString())
-                            isManualStop = true,
+                        if(vpnService.getState() == Tunnel.State.UP) {
-                        )
+                            ServiceManager.stopVpnService(this@TunnelControlTile)
-                    } else {
+                        } else {
-                        serviceManager.startVpnServiceForeground(
+                            ServiceManager.startVpnServiceForeground(this@TunnelControlTile, tunnel.toString())
-                            this@TunnelControlTile, manualStartConfig?.id, isManualStart = true,
+                        }
-                        )
                     }
-                } catch (e: Exception) {
+                } catch (e : Exception) {
                     Timber.e(e.message)
                 } finally {
                     cancel()
@@ -98,29 +75,74 @@ class TunnelControlTile : TileService() {
         }
     }
 
-    private fun setActive() {
+    private suspend fun determineTileTunnel() : TunnelConfig? {
-        qsTile.state = Tile.STATE_ACTIVE
+        var tunnelConfig : TunnelConfig? = null
-        qsTile.updateTile()
+        val settings = settingsRepo.getAll()
+        if (settings.isNotEmpty()) {
+            val setting = settings.first()
+            tunnelConfig = if (setting.defaultTunnel != null) {
+                TunnelConfig.from(setting.defaultTunnel!!)
+            } else {
+                val configs = configRepo.getAll()
+                val config  = if(configs.isNotEmpty()) {
+                    configs.first()
+                } else {
+                    null
+                }
+                config
+            }
+        }
+        return tunnelConfig
     }
 
-    private fun setInactive() {
+
-        qsTile.state = Tile.STATE_INACTIVE
+    private fun attemptWatcherServiceToggle(tunnelConfig : String) {
-        qsTile.updateTile()
+        scope.launch {
+            val settings = settingsRepo.getAll()
+            if (settings.isNotEmpty()) {
+                val setting = settings.first()
+                if(setting.isAutoTunnelEnabled) {
+                    ServiceManager.toggleWatcherServiceForeground(this@TunnelControlTile, tunnelConfig)
+                }
+            }
+        }
     }
 
-    private fun setUnavailable() {
+    private suspend fun updateTileState() {
-        manualStartConfig = null
+        vpnService.state.collect {
-        qsTile.state = Tile.STATE_UNAVAILABLE
+            try {
-        qsTile.updateTile()
+                when(it) {
+                    Tunnel.State.UP -> {
+                        qsTile.state = Tile.STATE_ACTIVE
+                    }
+                    Tunnel.State.DOWN -> {
+                        qsTile.state = Tile.STATE_INACTIVE
+                    }
+                    else -> {
+                        qsTile.state = Tile.STATE_UNAVAILABLE
+                    }
+                }
+                val config = determineTileTunnel()
+                setTileDescription(config?.name ?: this.resources.getString(R.string.no_tunnel_available))
+                qsTile.updateTile()
+            } catch (e : Exception) {
+                Timber.e("Unable to update tile state")
+            }
+        }
     }
 
-    private fun setTileDescription(description: String) {
+    private fun setTileDescription(description : String) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             qsTile.subtitle = description
         }
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
             qsTile.stateDescription = description
         }
-        qsTile.updateTile()
+    }
+
+    private fun cancelJob() {
+        if(this::job.isInitialized) {
+            job.cancel()
+        }
     }
 }

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

@@ -2,15 +2,13 @@ package com.zaneschepke.wireguardautotunnel.service.tunnel
 
 enum class HandshakeStatus {
     HEALTHY,
-    STALE,
+    UNHEALTHY,
-    UNKNOWN,
+    NEVER_CONNECTED,
     NOT_STARTED;
 
     companion object {
-        private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 180
+        private const val WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC = 120
-        const val STATUS_CHANGE_TIME_BUFFER = 30
+        const val UNHEALTHY_TIME_LIMIT_SEC = WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + 60
-        const val STALE_TIME_LIMIT_SEC =
-            WG_TYPICAL_HANDSHAKE_INTERVAL_WHEN_HEALTHY_SEC + STATUS_CHANGE_TIME_BUFFER
         const val NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC = 30
     }
 }

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

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

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

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

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

@@ -3,140 +3,140 @@ package com.zaneschepke.wireguardautotunnel.service.tunnel
 import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.BackendException
 import com.wireguard.android.backend.Statistics
-import com.wireguard.android.backend.Tunnel.State
+import com.wireguard.android.backend.Tunnel
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.wireguard.crypto.Key
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.Constants
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.module.Kernel
+import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import com.zaneschepke.wireguardautotunnel.module.Userspace
-import com.zaneschepke.wireguardautotunnel.util.Constants
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
-class WireGuardTunnel
+
-@Inject
+class WireGuardTunnel @Inject constructor(private val backend : Backend) : VpnService {
-constructor(
+
-    @Userspace private val userspaceBackend: Backend,
+    private val _tunnelName = MutableStateFlow("")
-    @Kernel private val kernelBackend: Backend,
+    override val tunnelName get() = _tunnelName.asStateFlow()
-    private val appDataRepository: AppDataRepository,
+
-) : VpnService {
+    private val _state = MutableSharedFlow<Tunnel.State>(
-    private val _vpnState = MutableStateFlow(VpnState())
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
-    override val vpnState: StateFlow<VpnState> = _vpnState.asStateFlow()
+        replay = 1)
+
+    private val _handshakeStatus = MutableSharedFlow<HandshakeStatus>(replay = 1,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST)
+    override val state get() = _state.asSharedFlow()
+
+    private val _statistics = MutableSharedFlow<Statistics>(replay = 1)
+    override val statistics get() = _statistics.asSharedFlow()
+
+    private val _lastHandshake = MutableSharedFlow<Map<Key, Long>>(replay = 1)
+    override val lastHandshake get() = _lastHandshake.asSharedFlow()
+
+    override val handshakeStatus: SharedFlow<HandshakeStatus>
+        get() = _handshakeStatus.asSharedFlow()
 
     private val scope = CoroutineScope(Dispatchers.IO)
 
-    private lateinit var statsJob: Job
+    private lateinit var statsJob : Job
 
-    private var backend: Backend = userspaceBackend
 
-    private var backendIsUserspace = true
+    override suspend fun startTunnel(tunnelConfig: TunnelConfig) : Tunnel.State{
-
-    init {
-        scope.launch {
-            appDataRepository.settings.getSettingsFlow().collect {
-                if (it.isKernelEnabled && backendIsUserspace) {
-                    Timber.d("Setting kernel backend")
-                    backend = kernelBackend
-                    backendIsUserspace = false
-                } else if (!it.isKernelEnabled && !backendIsUserspace) {
-                    Timber.d("Setting userspace backend")
-                    backend = userspaceBackend
-                    backendIsUserspace = true
-                }
-            }
-        }
-    }
-
-    override suspend fun startTunnel(tunnelConfig: TunnelConfig?): State {
         return try {
-            //TODO we need better error handling here
+            stopTunnelOnConfigChange(tunnelConfig)
-            val config = tunnelConfig ?: appDataRepository.getPrimaryOrFirstTunnel()
+            emitTunnelName(tunnelConfig.name)
-            if (config != null) {
+            val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-                emitTunnelConfig(config)
+            val state = backend.setState(
-                val wgConfig = TunnelConfig.configFromQuick(config.wgQuick)
+                this, Tunnel.State.UP, config)
-                val state =
+            _state.emit(state)
-                    backend.setState(
+            state
-                        this,
+        } catch (e : Exception) {
-                        State.UP,
-                        wgConfig,
-                    )
-                state
-            } else throw Exception("No tunnels")
-        } catch (e: BackendException) {
             Timber.e("Failed to start tunnel with error: ${e.message}")
-            State.DOWN
+            Tunnel.State.DOWN
         }
     }
 
-    private fun emitTunnelState(state: State) {
+    private suspend fun emitTunnelName(name : String) {
-        _vpnState.tryEmit(
+        _tunnelName.emit(name)
-            _vpnState.value.copy(
-                status = state,
-            ),
-        )
     }
 
-    private fun emitBackendStatistics(statistics: Statistics) {
+    private suspend fun stopTunnelOnConfigChange(tunnelConfig: TunnelConfig) {
-        _vpnState.tryEmit(
+        if(getState() == Tunnel.State.UP && _tunnelName.value != tunnelConfig.name) {
-            _vpnState.value.copy(
+            stopTunnel()
-                statistics = statistics,
+        }
-            ),
-        )
     }
 
-    private suspend fun emitTunnelConfig(tunnelConfig: TunnelConfig?) {
+    override fun getName(): String {
-        _vpnState.emit(
+        return _tunnelName.value
-            _vpnState.value.copy(
-                tunnelConfig = tunnelConfig,
-            ),
-        )
     }
 
     override suspend fun stopTunnel() {
         try {
-            if (getState() == State.UP) {
+            if(getState() == Tunnel.State.UP) {
-                val state = backend.setState(this, State.DOWN, null)
+                val state = backend.setState(this, Tunnel.State.DOWN, null)
-                emitTunnelState(state)
+                _state.emit(state)
             }
-        } catch (e: BackendException) {
+        } catch (e : BackendException) {
             Timber.e("Failed to stop tunnel with error: ${e.message}")
         }
     }
 
-    override fun getState(): State {
+    override fun getState(): Tunnel.State {
         return backend.getState(this)
     }
 
-    override fun getName(): String {
+    override fun onStateChange(state : Tunnel.State) {
-        return _vpnState.value.tunnelConfig?.name ?: ""
-    }
-
-    override fun onStateChange(state: State) {
         val tunnel = this
-        emitTunnelState(state)
+        _state.tryEmit(state)
-        WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(WireGuardAutoTunnel.instance)
+        if(state == Tunnel.State.UP) {
-        if (state == State.UP) {
+            statsJob = scope.launch {
-            statsJob =
+                val handshakeMap = HashMap<Key, Long>()
-                scope.launch {
+                var neverHadHandshakeCounter = 0
-                    while (true) {
+                while (true) {
-                        val statistics = backend.getStatistics(tunnel)
+                    val statistics = backend.getStatistics(tunnel)
-                        emitBackendStatistics(statistics)
+                    _statistics.emit(statistics)
-                        delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
+                    statistics.peers().forEach {
+                        val handshakeEpoch = statistics.peer(it)?.latestHandshakeEpochMillis ?: 0L
+                        handshakeMap[it] = handshakeEpoch
+                        if(handshakeEpoch == 0L) {
+                            if(neverHadHandshakeCounter >= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
+                                _handshakeStatus.emit(HandshakeStatus.NEVER_CONNECTED)
+                            } else {
+                                _handshakeStatus.emit(HandshakeStatus.NOT_STARTED)
+                            }
+                            if(neverHadHandshakeCounter <= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
+                                neverHadHandshakeCounter += (1 * Constants.VPN_STATISTIC_CHECK_INTERVAL/1000).toInt()
+                            }
+                            return@forEach
+                        }
+                        if((NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch) ?: 0L) >= HandshakeStatus.UNHEALTHY_TIME_LIMIT_SEC) {
+                            _handshakeStatus.emit(HandshakeStatus.UNHEALTHY)
+                        } else {
+                            _handshakeStatus.emit(HandshakeStatus.HEALTHY)
+                        }
                     }
+                    _lastHandshake.emit(handshakeMap)
+                    delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
                 }
-        }
-        if (state == State.DOWN) {
-            if (this::statsJob.isInitialized) {
-                statsJob.cancel()
             }
         }
+        if(state == Tunnel.State.DOWN) {
+            if(this::statsJob.isInitialized) {
+                statsJob.cancel()
+            }
+            _handshakeStatus.tryEmit(HandshakeStatus.NOT_STARTED)
+            _lastHandshake.tryEmit(emptyMap())
+        }
     }
+
+
 }

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

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

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

@@ -1,148 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import android.app.Application
-import android.content.ActivityNotFoundException
-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.launch
-import timber.log.Timber
-import java.time.Instant
-import javax.inject.Inject
-
-@HiltViewModel
-class AppViewModel
-@Inject
-constructor(
-    private val application: Application,
-) : ViewModel() {
-
-    val vpnIntent: Intent? = GoBackend.VpnService.prepare(WireGuardAutoTunnel.instance)
-
-    private val _appUiState = MutableStateFlow(
-        AppUiState(
-            vpnPermissionAccepted = vpnIntent == null,
-        ),
-    )
-    val appUiState = _appUiState.asStateFlow()
-
-
-    fun isRequiredPermissionGranted(): Boolean {
-        val allAccepted =
-            (_appUiState.value.vpnPermissionAccepted && _appUiState.value.vpnPermissionAccepted)
-        if (!allAccepted) requestPermissions()
-        return allAccepted
-    }
-
-    private fun requestPermissions() {
-        _appUiState.value = _appUiState.value.copy(
-            requestPermissions = true,
-        )
-    }
-
-    fun permissionsRequested() {
-        _appUiState.value = _appUiState.value.copy(
-            requestPermissions = false,
-        )
-    }
-
-    fun openWebPage(url: String) {
-        try {
-            val webpage: Uri = Uri.parse(url)
-            val intent = Intent(Intent.ACTION_VIEW, webpage).apply {
-                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-            }
-            application.startActivity(intent)
-        } catch (e: ActivityNotFoundException) {
-            Timber.e(e)
-            showSnackbarMessage(application.getString(R.string.no_browser_detected))
-        }
-    }
-
-    fun onVpnPermissionAccepted() {
-        _appUiState.value = _appUiState.value.copy(
-            vpnPermissionAccepted = true,
-        )
-    }
-
-    fun launchEmail() {
-        try {
-            val intent =
-                Intent(Intent.ACTION_SENDTO).apply {
-                    type = Constants.EMAIL_MIME_TYPE
-                    putExtra(Intent.EXTRA_EMAIL, arrayOf(application.getString(R.string.my_email)))
-                    putExtra(Intent.EXTRA_SUBJECT, application.getString(R.string.email_subject))
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                }
-            application.startActivity(
-                Intent.createChooser(intent, application.getString(R.string.email_chooser)).apply {
-                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                },
-            )
-        } catch (e: ActivityNotFoundException) {
-            Timber.e(e)
-            showSnackbarMessage(application.getString(R.string.no_email_detected))
-        }
-    }
-
-    fun showSnackbarMessage(message: String) {
-        _appUiState.value = _appUiState.value.copy(
-            snackbarMessage = message,
-            snackbarMessageConsumed = false,
-        )
-    }
-
-    fun snackbarMessageConsumed() {
-        _appUiState.value = _appUiState.value.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.value = _appUiState.value.copy(
-            notificationPermissionAccepted = accepted,
-        )
-    }
-}

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

@@ -1,17 +1,21 @@
 package com.zaneschepke.wireguardautotunnel.ui
 
 import android.Manifest
+import android.content.Intent
+import android.net.Uri
 import android.os.Build
 import android.os.Bundle
-import androidx.activity.SystemBarStyle
+import android.provider.Settings
+import android.view.KeyEvent
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.foundation.focusable
+import androidx.compose.animation.ExitTransition
-import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.animation.ExperimentalAnimationApi
-import androidx.compose.foundation.layout.padding
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.slideInHorizontally
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarData
@@ -22,243 +26,209 @@ import androidx.compose.material3.SnackbarResult
 import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.input.key.onKeyEvent
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.toArgb
 import androidx.compose.ui.unit.dp
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
-import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
+import com.wireguard.android.backend.GoBackend
+import com.zaneschepke.wireguardautotunnel.Constants
 import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.ui.common.PermissionRequestFailedScreen
-import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
-import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
-import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.CustomSnackBar
 import com.zaneschepke.wireguardautotunnel.ui.screens.config.ConfigScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.main.MainScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.options.OptionsScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.pinlock.PinLockScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsScreen
 import com.zaneschepke.wireguardautotunnel.ui.screens.support.SupportScreen
-import com.zaneschepke.wireguardautotunnel.ui.screens.support.logs.LogsScreen
+import com.zaneschepke.wireguardautotunnel.ui.theme.TransparentSystemBars
 import com.zaneschepke.wireguardautotunnel.ui.theme.WireguardAutoTunnelTheme
-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 timber.log.Timber
-import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
 
-    @Inject
+    @OptIn(ExperimentalAnimationApi::class,
-    lateinit var dataStoreManager: DataStoreManager
+        ExperimentalPermissionsApi::class
-
-    @Inject
-    lateinit var settingsRepository: SettingsRepository
-
-    @Inject
-    lateinit var serviceManager: ServiceManager
-
-    @OptIn(
-        ExperimentalPermissionsApi::class,
     )
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-
-        enableEdgeToEdge(navigationBarStyle = SystemBarStyle.dark(Color.Transparent.toArgb()))
-
-        // load preferences into memory and init data
-        lifecycleScope.launch {
-            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()
+            val focusRequester = remember { FocusRequester() }
 
-            val notificationPermissionState =
+            WireguardAutoTunnelTheme {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
+                TransparentSystemBars()
-                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS) else null
 
-            val snackbarHostState = remember { SnackbarHostState() }
+                val snackbarHostState = remember { SnackbarHostState() }
 
-            val vpnActivityResultState =
+                val notificationPermissionState =
-                rememberLauncherForActivityResult(
+                    rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS)
+
+                fun requestNotificationPermission() {
+                    if (!notificationPermissionState.status.isGranted && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        notificationPermissionState.launchPermissionRequest()
+                    }
+                }
+
+                var vpnIntent by remember { mutableStateOf(GoBackend.VpnService.prepare(this)) }
+                val vpnActivityResultState = rememberLauncherForActivityResult(
                     ActivityResultContracts.StartActivityForResult(),
                     onResult = {
                         val accepted = (it.resultCode == RESULT_OK)
                         if (accepted) {
-                            appViewModel.onVpnPermissionAccepted()
+                            vpnIntent = null
                         }
-                    },
+                    })
-                )
+                LaunchedEffect(vpnIntent) {
+                    if (vpnIntent != null) {
+                        vpnActivityResultState.launch(vpnIntent)
+                    } else requestNotificationPermission()
+                }
 
-            fun showSnackBarMessage(message: StringValue) {
+                fun showSnackBarMessage(message : String) {
-                lifecycleScope.launch(Dispatchers.Main) {
+                    lifecycleScope.launch(Dispatchers.Main) {
-                    val result =
+                        val result = snackbarHostState.showSnackbar(
-                        snackbarHostState.showSnackbar(
+                            message = message,
-                            message = message.asString(this@MainActivity),
+                            actionLabel = applicationContext.getString(R.string.okay),
                             duration = SnackbarDuration.Short,
                         )
-                    when (result) {
+                        when (result) {
-                        SnackbarResult.ActionPerformed,
+                            SnackbarResult.ActionPerformed -> { snackbarHostState.currentSnackbarData?.dismiss() }
-                        SnackbarResult.Dismissed -> {
+                            SnackbarResult.Dismissed -> { snackbarHostState.currentSnackbarData?.dismiss() }
-                            snackbarHostState.currentSnackbarData?.dismiss()
                         }
                     }
                 }
-            }
 
-            LaunchedEffect(appUiState.requestPermissions) {
+                Scaffold(snackbarHost = {
-                if (appUiState.requestPermissions) {
-                    appViewModel.permissionsRequested()
-                    if (notificationPermissionState != null && !notificationPermissionState.status.isGranted
-                    ) {
-                        showSnackBarMessage(StringValue.StringResource(R.string.notification_permission_required))
-                        return@LaunchedEffect notificationPermissionState.launchPermissionRequest()
-                    }
-                    if (!appUiState.vpnPermissionAccepted) {
-                        return@LaunchedEffect vpnActivityResultState.launch(appViewModel.vpnIntent)
-                    }
-                }
-            }
-
-            WireguardAutoTunnelTheme {
-                LaunchedEffect(Unit) {
-                    appViewModel.setNotificationPermissionAccepted(
-                        notificationPermissionState?.status?.isGranted ?: true,
-                    )
-                    if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) appViewModel.readLogCatOutput()
-                }
-
-                LaunchedEffect(appUiState.snackbarMessageConsumed) {
-                    if (!appUiState.snackbarMessageConsumed) {
-                        showSnackBarMessage(StringValue.DynamicString(appUiState.snackbarMessage))
-                        appViewModel.snackbarMessageConsumed()
-                    }
-                }
-
-                val focusRequester = remember { FocusRequester() }
-
-                Scaffold(
-                    snackbarHost = {
                         SnackbarHost(snackbarHostState) { snackbarData: SnackbarData ->
                             CustomSnackBar(
                                 snackbarData.visuals.message,
                                 isRtl = false,
-                                containerColor =
+                                containerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-                                MaterialTheme.colorScheme.surfaceColorAtElevation(
-                                    2.dp,
-                                ),
                             )
                         }
                     },
-                    //TODO refactor
+                    modifier = Modifier.onKeyEvent {
-                    modifier = Modifier
+                        if (it.nativeKeyEvent.action == KeyEvent.ACTION_UP) {
-                        .focusable()
+                            when (it.nativeKeyEvent.keyCode) {
-                        .focusProperties {
+                                KeyEvent.KEYCODE_DPAD_UP -> {
-                            when (navBackStackEntry?.destination?.route) {
+                                    try {
-                                Screen.Lock.route -> Unit
+                                        focusRequester.requestFocus()
-                                else -> up = focusRequester
+                                    } catch(e : IllegalStateException) {
+                                        Timber.e("No D-Pad focus request modifier added to element on screen")
+                                    }
+                                    false
+                                } else -> {
+                                   false
+                                }
                             }
-                        },
+                        } else {
-                    bottomBar = {
+                            false
-                        BottomNavBar(
+                        }
-                            navController,
+                    },
-                            listOf(
+                    bottomBar = if (vpnIntent == null && notificationPermissionState.status.isGranted) {
-                                Screen.Main.navItem,
+                        { BottomNavBar(navController, Routes.navItems) }
-                                Screen.Settings.navItem,
+                    } else {
-                                Screen.Support.navItem,
+                        {}
-                            ),
+                    },
+                )
+                { padding ->
+                    if (vpnIntent != null) {
+                        PermissionRequestFailedScreen(
+                            padding = padding,
+                            onRequestAgain = { vpnActivityResultState.launch(vpnIntent) },
+                            message = getString(R.string.vpn_permission_required),
+                            getString(R.string.retry)
                         )
-                    },
+                        return@Scaffold
-                ) { padding ->
+                    }
-                    NavHost(
+                    if (!notificationPermissionState.status.isGranted) {
-                        navController,
+                        PermissionRequestFailedScreen(
-                        startDestination =
+                            padding = padding,
-                        (if (PinManager.pinExists()) Screen.Lock.route else Screen.Main.route),
+                            onRequestAgain = {
-                        modifier =
+                                val intentSettings =
-                        Modifier
+                                    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
-                            .padding(padding)
+                                intentSettings.data =
-                            .fillMaxSize(),
+                                    Uri.fromParts(Constants.URI_PACKAGE_SCHEME, this.packageName, null)
-                    ) {
+                                startActivity(intentSettings)
-                        composable(
+                            },
-                            Screen.Main.route,
+                            message = getString(R.string.notification_permission_required),
-                        ) {
+                            getString(R.string.open_settings)
-                            MainScreen(
+                        )
-                                focusRequester = focusRequester,
+                        return@Scaffold
-                                appViewModel = appViewModel,
+                    }
-                                navController = navController,
+
-                            )
+                    NavHost(navController, startDestination = Routes.Main.name) {
-                        }
+                        composable(Routes.Main.name, enterTransition = {
-                        composable(
+                            when (initialState.destination.route) {
-                            Screen.Settings.route,
+                                Routes.Settings.name, Routes.Support.name ->
-                        ) {
+                                    slideInHorizontally(
-                            SettingsScreen(
+                                        initialOffsetX = { -Constants.SLIDE_IN_TRANSITION_OFFSET },
-                                appViewModel = appViewModel,
+                                        animationSpec = tween(Constants.SLIDE_IN_ANIMATION_DURATION)
-                                navController = navController,
+                                    )
-                                focusRequester = focusRequester,
+
-                            )
+                                else -> {
-                        }
+                                    fadeIn(animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION))
-                        composable(
+                                }
-                            Screen.Support.route,
-                        ) {
-                            SupportScreen(
-                                focusRequester = focusRequester,
-                                appViewModel = appViewModel,
-                                navController = navController,
-                            )
-                        }
-                        composable(Screen.Support.Logs.route) {
-                            LogsScreen(appViewModel)
-                        }
-                        composable("${Screen.Config.route}/{id}") {
-                            val id = it.arguments?.getString("id")
-                            if (!id.isNullOrBlank()) {
-                                ConfigScreen(
-                                    navController = navController,
-                                    tunnelId = id,
-                                    appViewModel = appViewModel,
-                                    focusRequester = focusRequester,
-                                )
                             }
+                        }, exitTransition = {
+                            ExitTransition.None
                         }
-                        composable("${Screen.Option.route}/{id}") {
+                            ) {
-                            val id = it.arguments?.getString("id")
+                            MainScreen(padding = padding, showSnackbarMessage = { message -> showSnackBarMessage(message) }, navController = navController)
-                            if (!id.isNullOrBlank()) {
+                        }
-                                OptionsScreen(
+                        composable(Routes.Settings.name, enterTransition = {
-                                    navController = navController,
+                            when (initialState.destination.route) {
-                                    tunnelId = id,
+                                Routes.Main.name ->
-                                    appViewModel = appViewModel,
+                                    slideInHorizontally(
-                                    focusRequester = focusRequester,
+                                        initialOffsetX = { Constants.SLIDE_IN_TRANSITION_OFFSET },
-                                )
+                                        animationSpec = tween(Constants.SLIDE_IN_ANIMATION_DURATION)
+                                    )
+
+                                Routes.Support.name -> {
+                                    slideInHorizontally(
+                                        initialOffsetX = { -Constants.SLIDE_IN_TRANSITION_OFFSET },
+                                        animationSpec = tween(Constants.SLIDE_IN_ANIMATION_DURATION)
+                                    )
+                                }
+
+                                else -> {
+                                    fadeIn(animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION))
+                                }
                             }
-                        }
+                        }) { SettingsScreen(padding = padding, showSnackbarMessage = { message -> showSnackBarMessage(message) }, focusRequester = focusRequester) }
-                        composable(Screen.Lock.route) {
+                        composable(Routes.Support.name, enterTransition = {
-                            PinLockScreen(
+                            when (initialState.destination.route) {
-                                navController = navController,
+                                Routes.Settings.name, Routes.Main.name ->
-                                appViewModel = appViewModel,
+                                    slideInHorizontally(
-                            )
+                                        initialOffsetX = { Constants.SLIDE_IN_ANIMATION_DURATION },
+                                        animationSpec = tween(Constants.SLIDE_IN_ANIMATION_DURATION)
+                                    )
+
+                                else -> {
+                                    fadeIn(animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION))
+                                }
+                            }
+                        }) { SupportScreen(padding = padding, focusRequester) }
+                        composable("${Routes.Config.name}/{id}", enterTransition = {
+                            fadeIn(animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION))
+                        }) { it ->
+                            val id = it.arguments?.getString("id")
+                            if(!id.isNullOrBlank()) {
+                                ConfigScreen(navController = navController, id = id, showSnackbarMessage = { message -> showSnackBarMessage(message) }, focusRequester = focusRequester)}
                         }
                     }
                 }

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

@@ -6,38 +6,30 @@ import androidx.compose.material.icons.rounded.QuestionMark
 import androidx.compose.material.icons.rounded.Settings
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavItem
 
-sealed class Screen(val route: String) {
+enum class Routes {
-    data object Main : Screen("main") {
+    Main,
-        val navItem =
+    Settings,
+    Support,
+    Config;
+
+
+    companion object {
+        val navItems = listOf(
             BottomNavItem(
                 name = "Tunnels",
-                route = route,
+                route = Main.name,
                 icon = Icons.Rounded.Home,
-            )
+            ),
-    }
-
-    data object Settings : Screen("settings") {
-        val navItem =
             BottomNavItem(
                 name = "Settings",
-                route = route,
+                route = Settings.name,
                 icon = Icons.Rounded.Settings,
-            )
+            ),
-    }
-
-    data object Support : Screen("support") {
-        val navItem =
             BottomNavItem(
                 name = "Support",
-                route = route,
+                route = Support.name,
                 icon = Icons.Rounded.QuestionMark,
             )
-
+        )
-        data object Logs : Screen("support/logs")
     }
-
-    data object Config : Screen("config")
-    data object Lock : Screen("lock")
-
-    data object Option : Screen("option")
 }

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

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

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

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

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

@@ -18,65 +18,57 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.wireguard.android.backend.Statistics
+import com.zaneschepke.wireguardautotunnel.toThreeDecimalPlaceString
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import com.zaneschepke.wireguardautotunnel.util.toThreeDecimalPlaceString
 
 @OptIn(ExperimentalFoundationApi::class)
 @Composable
-fun RowListItem(
+fun RowListItem(icon : @Composable () -> Unit, text : String, onHold : () -> Unit,
-    icon: @Composable () -> Unit,
+                onClick: () -> Unit, rowButton : @Composable () -> Unit,
-    text: String,
+                expanded : Boolean, statistics: Statistics?
-    onHold: () -> Unit,
+                ) {
-    onClick: () -> Unit,
-    rowButton: @Composable () -> Unit,
-    expanded: Boolean,
-    statistics: Statistics?
-) {
     Box(
-        modifier =
+        modifier = Modifier
-        Modifier
             .animateContentSize()
             .clip(RoundedCornerShape(30.dp))
             .combinedClickable(
-                onClick = { onClick() },
+                onClick = {
-                onLongClick = { onHold() },
+                    onClick()
-            ),
+                },
+                onLongClick = {
+                    onHold()
+                }
+            )
     ) {
         Column {
             Row(
                 modifier = Modifier
                     .fillMaxWidth()
-                    .padding(horizontal = 15.dp, vertical = 5.dp),
+                    .padding(horizontal = 14.dp, vertical = 5.dp),
                 verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween,
+                horizontalArrangement = Arrangement.SpaceBetween
             ) {
-                Row(
+                Row(verticalAlignment = Alignment.CenterVertically,) {
-                    verticalAlignment = Alignment.CenterVertically,
-                ) {
                     icon()
                     Text(text)
                 }
                 rowButton()
             }
-            if (expanded) {
+            if(expanded) {
                 statistics?.peers()?.forEach {
                     Row(
-                        modifier =
+                        modifier = Modifier
-                        Modifier
                             .fillMaxWidth()
                             .padding(end = 10.dp, bottom = 10.dp, start = 10.dp),
                         verticalAlignment = Alignment.CenterVertically,
-                        horizontalArrangement = Arrangement.SpaceEvenly,
+                        horizontalArrangement = Arrangement.SpaceEvenly
                     ) {
-                        //TODO change these to string resources
                         val handshakeEpoch = statistics.peer(it)!!.latestHandshakeEpochMillis
                         val peerTx = statistics.peer(it)!!.txBytes
                         val peerRx = statistics.peer(it)!!.rxBytes
-                        val peerId = it.toBase64().subSequence(0, 3).toString() + "***"
+                        val peerId = it.toBase64().subSequence(0,3).toString() + "***"
-                        val handshakeSec =
+                        val handshakeSec = NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch)
-                            NumberUtils.getSecondsBetweenTimestampAndNow(handshakeEpoch)
+                        val handshake = if(handshakeSec == null) "never" else "$handshakeSec secs ago"
-                        val handshake =
-                            if (handshakeSec == null) "never" else "$handshakeSec secs ago"
                         val peerTxMB = NumberUtils.bytesToMB(peerTx).toThreeDecimalPlaceString()
                         val peerRxMB = NumberUtils.bytesToMB(peerRx).toThreeDecimalPlaceString()
                         val fontSize = 9.sp

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

@@ -25,7 +25,9 @@ import androidx.compose.ui.text.input.KeyboardType
 import com.zaneschepke.wireguardautotunnel.R
 
 @Composable
-fun SearchBar(onQuery: (queryString: String) -> Unit) {
+fun SearchBar(
+    onQuery : (queryString : String) -> Unit
+) {
     // Immediately update and keep track of query from text field changes.
     var query: String by rememberSaveable { mutableStateOf("") }
     var showClearIcon by rememberSaveable { mutableStateOf(false) }
@@ -47,7 +49,7 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
             Icon(
                 imageVector = Icons.Rounded.Search,
                 tint = MaterialTheme.colorScheme.onBackground,
-                contentDescription = stringResource(id = R.string.search_icon),
+                contentDescription = stringResource(id = R.string.search_icon)
             )
         },
         trailingIcon = {
@@ -56,14 +58,13 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
                     Icon(
                         imageVector = Icons.Rounded.Clear,
                         tint = MaterialTheme.colorScheme.onBackground,
-                        contentDescription = stringResource(id = R.string.clear_icon),
+                        contentDescription = stringResource(id = R.string.clear_icon)
                     )
                 }
             }
         },
         maxLines = 1,
-        colors =
+        colors = TextFieldDefaults.colors(
-        TextFieldDefaults.colors(
             focusedContainerColor = Color.Transparent,
             unfocusedContainerColor = Color.Transparent,
             disabledContainerColor = Color.Transparent,
@@ -72,9 +73,8 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
         textStyle = MaterialTheme.typography.bodySmall,
         singleLine = true,
         keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Text),
-        modifier =
+        modifier = Modifier
-        Modifier
             .fillMaxWidth()
-            .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape),
+            .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape)
     )
 }

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

@@ -10,26 +10,23 @@ import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardCapitalization
 
 @Composable
-fun ConfigurationTextBox(
+fun
-    value: String,
+        ConfigurationTextBox(value : String, hint : String, onValueChange : (String) -> Unit, keyboardActions : KeyboardActions, label : String, modifier: Modifier) {
-    hint: String,
+   OutlinedTextField(
-    onValueChange: (String) -> Unit,
-    keyboardActions: KeyboardActions,
-    label: String,
-    modifier: Modifier
-) {
-    OutlinedTextField(
         modifier = modifier,
         value = value,
         singleLine = true,
-        onValueChange = { onValueChange(it) },
+        onValueChange = {
+            onValueChange(it)
+        },
         label = { Text(label) },
         maxLines = 1,
-        placeholder = { Text(hint) },
+        placeholder = {
-        keyboardOptions =
+            Text(hint)
-        KeyboardOptions(
+        },
+        keyboardOptions = KeyboardOptions(
             capitalization = KeyboardCapitalization.None,
-            imeAction = ImeAction.Done,
+            imeAction = ImeAction.Done
         ),
         keyboardActions = keyboardActions,
     )

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

@@ -9,31 +9,26 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.Dp
 
 @Composable
-fun ConfigurationToggle(
+fun ConfigurationToggle(label : String, enabled : Boolean, checked : Boolean, padding : Dp,
-    label: String,
+                        onCheckChanged : () -> Unit, modifier : Modifier = Modifier) {
-    enabled: Boolean,
-    checked: Boolean,
-    padding: Dp,
-    onCheckChanged: () -> Unit,
-    modifier: Modifier = Modifier
-) {
     Row(
         modifier = Modifier
             .fillMaxWidth()
             .padding(padding),
         verticalAlignment = Alignment.CenterVertically,
-        horizontalArrangement = Arrangement.SpaceBetween,
+        horizontalArrangement = Arrangement.SpaceBetween
     ) {
-        Text(label, textAlign = TextAlign.Start)
+        Text(label)
         Switch(
             modifier = modifier,
             enabled = enabled,
             checked = checked,
-            onCheckedChange = { onCheckChanged() },
+            onCheckedChange = {
+                onCheckChanged()
+            }
         )
     }
 }

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

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

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

@@ -11,79 +11,69 @@ import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentActivity
 
 @Composable
-fun AuthorizationPrompt(onSuccess: () -> Unit, onFailure: () -> Unit, onError: (String) -> Unit) {
+fun AuthorizationPrompt(onSuccess : () -> Unit, onFailure : () -> Unit, onError : (String) -> Unit) {
     val context = LocalContext.current
     val biometricManager = BiometricManager.from(context)
     val bio = biometricManager.canAuthenticate(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
     val isBiometricAvailable = remember {
-        when (bio) {
+        when(bio){
             BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
                 onError("Biometrics not available")
                 false
             }
-
             BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> {
                 onError("Biometrics not created")
                 false
             }
-
             BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> {
                 onError("Biometric hardware not found")
                 false
             }
-
             BiometricManager.BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED -> {
                 onError("Biometric security update required")
                 false
             }
-
             BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED -> {
                 onError("Biometrics not supported")
                 false
             }
-
             BiometricManager.BIOMETRIC_STATUS_UNKNOWN -> {
                 onError("Biometrics status unknown")
                 false
             }
-
             BiometricManager.BIOMETRIC_SUCCESS -> true
             else -> false
         }
     }
-    if (isBiometricAvailable) {
+    if(isBiometricAvailable) {
         val executor = remember { ContextCompat.getMainExecutor(context) }
 
-        val promptInfo =
+        val promptInfo = BiometricPrompt.PromptInfo.Builder()
-            BiometricPrompt.PromptInfo.Builder()
+            .setAllowedAuthenticators(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
-                .setAllowedAuthenticators(BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
+            .setTitle("Biometric Authentication")
-                .setTitle("Biometric Authentication")
+            .setSubtitle("Log in using your biometric credential")
-                .setSubtitle("Log in using your biometric credential")
+            .build()
-                .build()
 
-        val biometricPrompt =
+        val biometricPrompt = BiometricPrompt(
-            BiometricPrompt(
+            context as FragmentActivity,
-                context as FragmentActivity,
+            executor,
-                executor,
+            object : BiometricPrompt.AuthenticationCallback() {
-                object : BiometricPrompt.AuthenticationCallback() {
+                override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
-                    override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
+                    super.onAuthenticationError(errorCode, errString)
-                        super.onAuthenticationError(errorCode, errString)
+                    onFailure()
-                        onFailure()
+                }
-                    }
 
-                    override fun onAuthenticationSucceeded(
+                override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
-                        result: BiometricPrompt.AuthenticationResult
+                    super.onAuthenticationSucceeded(result)
-                    ) {
+                    onSuccess()
-                        super.onAuthenticationSucceeded(result)
+                }
-                        onSuccess()
-                    }
 
-                    override fun onAuthenticationFailed() {
+                override fun onAuthenticationFailed() {
-                        super.onAuthenticationFailed()
+                    super.onAuthenticationFailed()
-                        onFailure()
+                    onFailure()
-                    }
+                }
-                },
+            }
-            )
+        )
         biometricPrompt.authenticate(promptInfo)
     }
 }

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

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

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

@@ -1,26 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.common.screen
-
-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.CircularProgressIndicator
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-
-@Composable
-fun LoadingScreen() {
-    Column(
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Top,
-        modifier = Modifier
-            .fillMaxSize()
-            .focusable()
-            .padding(),
-    ) {
-        Column(modifier = Modifier.padding(120.dp)) { CircularProgressIndicator() }
-    }
-}

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

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

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

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

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

@@ -3,27 +3,22 @@ package com.zaneschepke.wireguardautotunnel.ui.models
 import com.wireguard.config.Interface
 
 data class InterfaceProxy(
-    var privateKey: String = "",
+    var privateKey : String = "",
-    var publicKey: String = "",
+    var publicKey : String = "",
-    var addresses: String = "",
+    var addresses : String = "",
-    var dnsServers: String = "",
+    var dnsServers : String = "",
-    var listenPort: String = "",
+    var listenPort : String = "",
-    var mtu: String = ""
+    var mtu : String = "",
-) {
+){
     companion object {
-        fun from(i: Interface): InterfaceProxy {
+        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 =
+                listenPort = if(i.listenPort.isPresent) i.listenPort.get().toString().trim() else "",
-                if (i.listenPort.isPresent) {
+                mtu = if(i.mtu.isPresent) i.mtu.get().toString().trim() else ""
-                    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

@@ -3,71 +3,30 @@ package com.zaneschepke.wireguardautotunnel.ui.models
 import com.wireguard.config.Peer
 
 data class PeerProxy(
-    var publicKey: String = "",
+    var publicKey : String = "",
-    var preSharedKey: String = "",
+    var preSharedKey : String = "",
-    var persistentKeepalive: String = "",
+    var persistentKeepalive : String = "",
-    var endpoint: String = "",
+    var endpoint : String = "",
     var allowedIps: String = IPV4_WILDCARD.joinToString(", ").trim()
-) {
+){
     companion object {
-        fun from(peer: Peer): PeerProxy {
+        fun from(peer : Peer) : PeerProxy {
             return PeerProxy(
                 publicKey = peer.publicKey.toBase64(),
-                preSharedKey =
+                preSharedKey = if(peer.preSharedKey.isPresent) peer.preSharedKey.get().toBase64().trim() else "",
-                if (peer.preSharedKey.isPresent) {
+                persistentKeepalive = if(peer.persistentKeepalive.isPresent) peer.persistentKeepalive.get().toString().trim() else "",
-                    peer.preSharedKey.get().toBase64().trim()
+                endpoint = if(peer.endpoint.isPresent) peer.endpoint.get().toString().trim() else "",
-                } else {
+                allowedIps = peer.allowedIps.joinToString(", ").trim()
-                    ""
-                },
-                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(
-        val IPV4_PUBLIC_NETWORKS =
+            "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",
-            setOf(
+            "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",
-                "0.0.0.0/5",
+            "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",
-                "8.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",
-                "11.0.0.0/8",
+            "192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10",
-                "12.0.0.0/6",
+            "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"
-                "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/ConfigUiState.kt

@@ -1,18 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.config
-
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
-import com.zaneschepke.wireguardautotunnel.ui.models.InterfaceProxy
-import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
-import com.zaneschepke.wireguardautotunnel.util.Packages
-
-data class ConfigUiState(
-    val proxyPeers: List<PeerProxy> = arrayListOf(PeerProxy()),
-    val interfaceProxy: InterfaceProxy = InterfaceProxy(),
-    val packages: Packages = emptyList(),
-    val checkedPackageNames: List<String> = emptyList(),
-    val include: Boolean = true,
-    val isAllApplicationsEnabled: Boolean = false,
-    val loading: Boolean = true,
-    val tunnel: TunnelConfig? = null,
-    val tunnelName: String = ""
-)

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

@@ -5,6 +5,8 @@ import android.app.Application
 import android.content.pm.PackageInfo
 import android.content.pm.PackageManager
 import android.os.Build
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.toMutableStateList
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wireguard.config.Config
@@ -12,338 +14,382 @@ import com.wireguard.config.Interface
 import com.wireguard.config.Peer
 import com.wireguard.crypto.Key
 import com.wireguard.crypto.KeyPair
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.Constants
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.repository.TunnelConfigDao
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.ui.models.InterfaceProxy
 import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
-import com.zaneschepke.wireguardautotunnel.util.Constants
-import com.zaneschepke.wireguardautotunnel.util.Event
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import com.zaneschepke.wireguardautotunnel.util.Result
+import com.zaneschepke.wireguardautotunnel.util.WgTunnelException
-import com.zaneschepke.wireguardautotunnel.util.removeAt
-import com.zaneschepke.wireguardautotunnel.util.update
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
-import timber.log.Timber
 import javax.inject.Inject
 
 @HiltViewModel
-class ConfigViewModel
+class ConfigViewModel @Inject constructor(private val application : Application,
-@Inject
+                                          private val tunnelRepo : TunnelConfigDao,
-constructor(
+                                          private val settingsRepo : SettingsDoa
-    private val application: Application,
-    private val appDataRepository: AppDataRepository
 ) : ViewModel() {
 
+    private val _tunnel = MutableStateFlow<TunnelConfig?>(null)
+    private val _tunnelName = MutableStateFlow("")
+    val tunnelName get() = _tunnelName.asStateFlow()
+    val tunnel get() = _tunnel.asStateFlow()
+
+    private var _proxyPeers = MutableStateFlow(mutableStateListOf<PeerProxy>())
+    val proxyPeers get() = _proxyPeers.asStateFlow()
+
+    private var _interface = MutableStateFlow(InterfaceProxy())
+    val interfaceProxy = _interface.asStateFlow()
+
+    private val _packages = MutableStateFlow(emptyList<PackageInfo>())
+    val packages get() = _packages.asStateFlow()
     private val packageManager = application.packageManager
 
-    private val _uiState = MutableStateFlow(ConfigUiState())
+    private val _checkedPackages = MutableStateFlow(mutableStateListOf<String>())
-    val uiState = _uiState.asStateFlow()
+    val checkedPackages get() = _checkedPackages.asStateFlow()
+    private val _include = MutableStateFlow(true)
+    val include get() = _include.asStateFlow()
 
-    fun init(tunnelId: String) =
+    private val _isAllApplicationsEnabled = MutableStateFlow(false)
+    val isAllApplicationsEnabled get() = _isAllApplicationsEnabled.asStateFlow()
+    private val _isDefaultTunnel = MutableStateFlow(false)
+    val isDefaultTunnel = _isDefaultTunnel.asStateFlow()
+
+    private lateinit var tunnelConfig: TunnelConfig
+
+    suspend fun onScreenLoad(id : String) {
+        if(id != Constants.MANUAL_TUNNEL_CONFIG_ID) {
+            tunnelConfig = getTunnelConfigById(id) ?: throw WgTunnelException("Config not found")
+            emitScreenData()
+        } else {
+            emitEmptyScreenData()
+        }
+    }
+
+    private fun emitEmptyScreenData() {
+        tunnelConfig = TunnelConfig(name = NumberUtils.generateRandomTunnelName(), wgQuick = "")
+        viewModelScope.launch {
+            emitTunnelConfig()
+            emitPeerProxy(PeerProxy())
+            emitInterfaceProxy(InterfaceProxy())
+            emitTunnelConfigName()
+            emitDefaultTunnelStatus()
+            emitQueriedPackages("")
+            emitTunnelAllApplicationsEnabled()
+        }
+    }
+
+
+    private suspend fun emitScreenData() {
+        emitTunnelConfig()
+        emitPeersFromConfig()
+        emitInterfaceFromConfig()
+        emitTunnelConfigName()
+        emitDefaultTunnelStatus()
+        emitQueriedPackages("")
+        emitCurrentPackageConfigurations()
+    }
+
+    private suspend fun emitDefaultTunnelStatus() {
+        val settings = settingsRepo.getAll()
+        if(settings.isNotEmpty()) {
+            _isDefaultTunnel.value = settings.first().isTunnelConfigDefault(tunnelConfig)
+        }
+    }
+
+    private fun emitInterfaceFromConfig() {
+        val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
+        _interface.value = InterfaceProxy.from(config.`interface`)
+    }
+
+    private fun emitPeersFromConfig() {
+        val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
+        config.peers.forEach{
+            _proxyPeers.value.add(PeerProxy.from(it))
+        }
+    }
+
+    private fun emitPeerProxy(peerProxy: PeerProxy) {
+        _proxyPeers.value.add(peerProxy)
+    }
+
+    private fun emitInterfaceProxy(interfaceProxy: InterfaceProxy) {
+        _interface.value = interfaceProxy
+    }
+
+    private suspend fun getTunnelConfigById(id : String) : TunnelConfig? {
+        return try {
+            tunnelRepo.getById(id.toLong())
+        } catch (_ : Exception) {
+            null
+        }
+    }
+
+    private suspend fun emitTunnelConfig() {
+        _tunnel.emit(tunnelConfig)
+    }
+
+    private  suspend fun emitTunnelConfigName() {
+        _tunnelName.emit(tunnelConfig.name)
+    }
+
+    fun onTunnelNameChange(name : String) {
+        _tunnelName.value = name
+    }
+
+    fun onIncludeChange(include : Boolean) {
+        _include.value = include
+    }
+    fun onAddCheckedPackage(packageName : String) {
+        _checkedPackages.value.add(packageName)
+    }
+
+    fun onAllApplicationsChange(isAllApplicationsEnabled : Boolean) {
+        _isAllApplicationsEnabled.value = isAllApplicationsEnabled
+    }
+
+    fun onRemoveCheckedPackage(packageName : String) {
+        _checkedPackages.value.remove(packageName)
+    }
+
+    private suspend fun emitSplitTunnelConfiguration(config : Config) {
+        val excludedApps = config.`interface`.excludedApplications
+        val includedApps = config.`interface`.includedApplications
+        if (excludedApps.isNotEmpty() || includedApps.isNotEmpty()) {
+            emitTunnelAllApplicationsDisabled()
+            determineAppInclusionState(excludedApps, includedApps)
+        } else {
+            emitTunnelAllApplicationsEnabled()
+        }
+    }
+
+    private suspend fun determineAppInclusionState(excludedApps : Set<String>, includedApps : Set<String>) {
+        if (excludedApps.isEmpty()) {
+            emitIncludedAppsExist()
+            emitCheckedApps(includedApps)
+        } else {
+            emitExcludedAppsExist()
+            emitCheckedApps(excludedApps)
+        }
+    }
+
+    private suspend fun emitIncludedAppsExist() {
+        _include.emit(true)
+    }
+
+    private suspend fun emitExcludedAppsExist() {
+        _include.emit(false)
+    }
+
+    private suspend fun emitCheckedApps(apps : Set<String>) {
+        _checkedPackages.emit(apps.toMutableStateList())
+    }
+
+    private suspend fun emitTunnelAllApplicationsEnabled() {
+        _isAllApplicationsEnabled.emit(true)
+    }
+
+    private suspend fun emitTunnelAllApplicationsDisabled() {
+        _isAllApplicationsEnabled.emit(false)
+    }
+
+    private fun emitCurrentPackageConfigurations() {
         viewModelScope.launch(Dispatchers.IO) {
-            val packages = getQueriedPackages("")
+            val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val state =
+            emitSplitTunnelConfiguration(config)
-                if (tunnelId != Constants.MANUAL_TUNNEL_CONFIG_ID) {
-                    val tunnelConfig =
-                        appDataRepository.tunnels.getAll()
-                            .firstOrNull { it.id.toString() == tunnelId }
-                    if (tunnelConfig != null) {
-                        val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-                        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()
-                            }
-                        ConfigUiState(
-                            proxyPeers,
-                            proxyInterface,
-                            packages,
-                            checkedPackages.toList(),
-                            include,
-                            isAllApplicationsEnabled,
-                            false,
-                            tunnelConfig,
-                            tunnelConfig.name,
-                        )
-                    } else {
-                        ConfigUiState(loading = false, packages = packages)
-                    }
-                } else {
-                    ConfigUiState(loading = false, packages = packages)
-                }
-            _uiState.value = state
-        }
-
-    fun onTunnelNameChange(name: String) {
-        _uiState.value = _uiState.value.copy(tunnelName = name)
-    }
-
-    fun onIncludeChange(include: Boolean) {
-        _uiState.value = _uiState.value.copy(include = include)
-    }
-
-    fun onAddCheckedPackage(packageName: String) {
-        _uiState.value =
-            _uiState.value.copy(
-                checkedPackageNames = _uiState.value.checkedPackageNames + packageName,
-            )
-    }
-
-    fun onAllApplicationsChange(isAllApplicationsEnabled: Boolean) {
-        _uiState.value = _uiState.value.copy(isAllApplicationsEnabled = isAllApplicationsEnabled)
-    }
-
-    fun onRemoveCheckedPackage(packageName: String) {
-        _uiState.value =
-            _uiState.value.copy(
-                checkedPackageNames = _uiState.value.checkedPackageNames - packageName,
-            )
-    }
-
-    private fun getQueriedPackages(query: String): List<PackageInfo> {
-        return getAllInternetCapablePackages().filter {
-            getPackageLabel(it).lowercase().contains(query.lowercase())
         }
     }
 
-    fun getPackageLabel(packageInfo: PackageInfo): String {
+    fun emitQueriedPackages(query : String) {
+        viewModelScope.launch(Dispatchers.IO) {
+            val packages = getAllInternetCapablePackages().filter {
+                getPackageLabel(it).lowercase().contains(query.lowercase())
+            }
+            _packages.emit(packages)
+        }
+    }
+
+    fun getPackageLabel(packageInfo : PackageInfo) : String {
         return packageInfo.applicationInfo.loadLabel(application.packageManager).toString()
     }
 
-    private fun getAllInternetCapablePackages(): List<PackageInfo> {
+
+    private fun getAllInternetCapablePackages() : List<PackageInfo> {
         return getPackagesHoldingPermissions(arrayOf(Manifest.permission.INTERNET))
     }
 
     private fun getPackagesHoldingPermissions(permissions: Array<String>): List<PackageInfo> {
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            packageManager.getPackagesHoldingPermissions(
+            packageManager.getPackagesHoldingPermissions(permissions, PackageManager.PackageInfoFlags.of(0L))
-                permissions,
-                PackageManager.PackageInfoFlags.of(0L),
-            )
         } else {
             packageManager.getPackagesHoldingPermissions(permissions, 0)
         }
     }
 
-    private fun isAllApplicationsEnabled(): Boolean {
+    private fun isAllApplicationsEnabled() : Boolean {
-        return _uiState.value.isAllApplicationsEnabled
+        return _isAllApplicationsEnabled.value
     }
 
-    private fun saveConfig(tunnelConfig: TunnelConfig) =
+    private fun isIncludeApplicationsEnabled() : Boolean {
-        viewModelScope.launch { appDataRepository.tunnels.save(tunnelConfig) }
+        return _include.value
+    }
 
-    private fun updateTunnelConfig(tunnelConfig: TunnelConfig?) =
+    private suspend fun saveConfig(tunnelConfig: TunnelConfig) {
-        viewModelScope.launch {
+        tunnelRepo.save(tunnelConfig)
-            if (tunnelConfig != null) {
+    }
-                saveConfig(tunnelConfig).join()
+    private suspend fun updateTunnelConfig(tunnelConfig: TunnelConfig?) {
-                WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
+        if(tunnelConfig != null) {
+            saveConfig(tunnelConfig)
+            updateSettingsDefaultTunnel(tunnelConfig)
+        }
+    }
+
+    private suspend fun updateSettingsDefaultTunnel(tunnelConfig: TunnelConfig) {
+        val settings = settingsRepo.getAll()
+        if(settings.isNotEmpty()) {
+            val setting = settings[0]
+            if(setting.defaultTunnel != null) {
+                if(tunnelConfig.id == TunnelConfig.from(setting.defaultTunnel!!).id) {
+                    settingsRepo.save(setting.copy(
+                        defaultTunnel = tunnelConfig.toString()
+                    ))
+                }
             }
         }
+    }
 
-    private fun buildPeerListFromProxyPeers(): List<Peer> {
+    fun buildPeerListFromProxyPeers() : List<Peer> {
-        return _uiState.value.proxyPeers.map {
+        return _proxyPeers.value.map {
             val builder = 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()) {
+            if (it.persistentKeepalive.isNotEmpty()) builder.parsePersistentKeepalive(it.persistentKeepalive.trim())
-                builder.parsePersistentKeepalive(it.persistentKeepalive.trim())
-            }
             builder.build()
         }
     }
 
-    private fun emptyCheckedPackagesList() {
+    fun buildInterfaceListFromProxyInterface() : Interface {
-        _uiState.value = _uiState.value.copy(checkedPackageNames = emptyList())
-    }
-
-    private fun buildInterfaceListFromProxyInterface(): Interface {
         val builder = Interface.Builder()
-        builder.parsePrivateKey(_uiState.value.interfaceProxy.privateKey.trim())
+        builder.parsePrivateKey(_interface.value.privateKey.trim())
-        builder.parseAddresses(_uiState.value.interfaceProxy.addresses.trim())
+        builder.parseAddresses(_interface.value.addresses.trim())
-        if (_uiState.value.interfaceProxy.dnsServers.isNotEmpty()) {
+        builder.parseDnsServers(_interface.value.dnsServers.trim())
-            builder.parseDnsServers(_uiState.value.interfaceProxy.dnsServers.trim())
+        if(_interface.value.mtu.isNotEmpty()) builder.parseMtu(_interface.value.mtu.trim())
-        }
+        if(_interface.value.listenPort.isNotEmpty()) builder.parseListenPort(_interface.value.listenPort.trim())
-        if (_uiState.value.interfaceProxy.mtu.isNotEmpty())
+        if(isAllApplicationsEnabled()) _checkedPackages.value.clear()
-            builder.parseMtu(_uiState.value.interfaceProxy.mtu.trim())
+        if(_include.value) builder.includeApplications(_checkedPackages.value)
-        if (_uiState.value.interfaceProxy.listenPort.isNotEmpty()) {
+        if(!_include.value) builder.excludeApplications(_checkedPackages.value)
-            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)
         return builder.build()
     }
 
-    fun onSaveAllChanges(): Result<Event> {
+
-        return try {
+
+    suspend fun onSaveAllChanges() {
+        try {
             val peerList = buildPeerListFromProxyPeers()
             val wgInterface = buildInterfaceListFromProxyInterface()
             val config = Config.Builder().addPeers(peerList).setInterface(wgInterface).build()
-            val tunnelConfig = when (uiState.value.tunnel) {
+            val tunnelConfig = _tunnel.value?.copy(
-                null -> TunnelConfig(
+                name = _tunnelName.value,
-                    name = _uiState.value.tunnelName,
+                wgQuick = config.toWgQuickString()
-                    wgQuick = config.toWgQuickString(),
+            )
-                )
-
-                else -> uiState.value.tunnel!!.copy(
-                    name = _uiState.value.tunnelName,
-                    wgQuick = config.toWgQuickString(),
-                )
-            }
             updateTunnelConfig(tunnelConfig)
-            Result.Success(Event.Message.ConfigSaved)
+        } catch (e : Exception) {
-        } catch (e: Exception) {
+            throw WgTunnelException("Error: ${e.cause?.message?.lowercase() ?: "unknown error occurred"}")
-            Timber.e(e)
-            val message = e.message?.substringAfter(":", missingDelimiterValue = "")
-            Result.Error(Event.Error.ConfigParseError(message ?: ""))
         }
     }
 
-    fun onPeerPublicKeyChange(index: Int, value: String) {
+    fun onPeerPublicKeyChange(index: Int, publicKey: String) {
-        _uiState.value =
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-            _uiState.value.copy(
+            publicKey = publicKey
-                proxyPeers =
+        )
-                _uiState.value.proxyPeers.update(
-                    index,
-                    _uiState.value.proxyPeers[index].copy(publicKey = value),
-                ),
-            )
     }
 
     fun onPreSharedKeyChange(index: Int, value: String) {
-        _uiState.value =
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-            _uiState.value.copy(
+            preSharedKey = value
-                proxyPeers =
+        )
-                _uiState.value.proxyPeers.update(
-                    index,
-                    _uiState.value.proxyPeers[index].copy(preSharedKey = value),
-                ),
-            )
     }
 
     fun onEndpointChange(index: Int, value: String) {
-        _uiState.value =
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-            _uiState.value.copy(
+            endpoint = value
-                proxyPeers =
+        )
-                _uiState.value.proxyPeers.update(
-                    index,
-                    _uiState.value.proxyPeers[index].copy(endpoint = value),
-                ),
-            )
     }
 
     fun onAllowedIpsChange(index: Int, value: String) {
-        _uiState.value =
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-            _uiState.value.copy(
+            allowedIps = value
-                proxyPeers =
+        )
-                _uiState.value.proxyPeers.update(
-                    index,
-                    _uiState.value.proxyPeers[index].copy(allowedIps = value),
-                ),
-            )
     }
 
-    fun onPersistentKeepaliveChanged(index: Int, value: String) {
+    fun onPersistentKeepaliveChanged(index : Int, value : String) {
-        _uiState.value =
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-            _uiState.value.copy(
+            persistentKeepalive = value
-                proxyPeers =
+        )
-                _uiState.value.proxyPeers.update(
-                    index,
-                    _uiState.value.proxyPeers[index].copy(persistentKeepalive = value),
-                ),
-            )
     }
 
     fun onDeletePeer(index: Int) {
-        _uiState.value =
+        proxyPeers.value.removeAt(index)
-            _uiState.value.copy(
-                proxyPeers = _uiState.value.proxyPeers.removeAt(index),
-            )
     }
 
     fun addEmptyPeer() {
-        _uiState.value = _uiState.value.copy(proxyPeers = _uiState.value.proxyPeers + PeerProxy())
+        _proxyPeers.value.add(PeerProxy())
     }
 
     fun generateKeyPair() {
         val keyPair = KeyPair()
-        _uiState.value =
+        _interface.value = _interface.value.copy(
-            _uiState.value.copy(
+            privateKey = keyPair.privateKey.toBase64(),
-                interfaceProxy =
+            publicKey = keyPair.publicKey.toBase64()
-                _uiState.value.interfaceProxy.copy(
+        )
-                    privateKey = keyPair.privateKey.toBase64(),
-                    publicKey = keyPair.publicKey.toBase64(),
-                ),
-            )
     }
 
     fun onAddressesChanged(value: String) {
-        _uiState.value =
+        _interface.value = _interface.value.copy(
-            _uiState.value.copy(
+            addresses = value
-                interfaceProxy = _uiState.value.interfaceProxy.copy(addresses = value),
+        )
-            )
     }
 
     fun onListenPortChanged(value: String) {
-        _uiState.value =
+        _interface.value = _interface.value.copy(
-            _uiState.value.copy(
+            listenPort = value
-                interfaceProxy = _uiState.value.interfaceProxy.copy(listenPort = value),
+        )
-            )
     }
 
     fun onDnsServersChanged(value: String) {
-        _uiState.value =
+        _interface.value = _interface.value.copy(
-            _uiState.value.copy(
+            dnsServers = value
-                interfaceProxy = _uiState.value.interfaceProxy.copy(dnsServers = value),
+        )
-            )
     }
 
     fun onMtuChanged(value: String) {
-        _uiState.value =
+        _interface.value = _interface.value.copy(
-            _uiState.value.copy(interfaceProxy = _uiState.value.interfaceProxy.copy(mtu = value))
+            mtu = value
+        )
     }
 
-    private fun onInterfacePublicKeyChange(value: String) {
+    private fun onInterfacePublicKeyChange(value : String) {
-        _uiState.value =
+        _interface.value = _interface.value.copy(
-            _uiState.value.copy(
+            publicKey = value
-                interfaceProxy = _uiState.value.interfaceProxy.copy(publicKey = value),
+        )
-            )
     }
 
     fun onPrivateKeyChange(value: String) {
-        _uiState.value =
+        _interface.value = _interface.value.copy(
-            _uiState.value.copy(
+            privateKey = value
-                interfaceProxy = _uiState.value.interfaceProxy.copy(privateKey = value),
+        )
-            )
+        if(NumberUtils.isValidKey(value)) {
-        if (NumberUtils.isValidKey(value)) {
             val pair = KeyPair(Key.fromBase64(value))
             onInterfacePublicKeyChange(pair.publicKey.toBase64())
         } else {
             onInterfacePublicKeyChange("")
         }
     }
-
-    fun emitQueriedPackages(query: String) {
-        val packages =
-            getAllInternetCapablePackages().filter {
-                getPackageLabel(it).lowercase().contains(query.lowercase())
-            }
-        _uiState.value = _uiState.value.copy(packages = packages)
-    }
 }

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

@@ -8,17 +8,14 @@ import android.os.Build
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
 import androidx.compose.animation.slideInVertically
 import androidx.compose.animation.slideOutVertically
-import androidx.compose.foundation.ExperimentalFoundationApi
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.focusable
-import androidx.compose.foundation.gestures.ScrollableDefaults
 import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -26,27 +23,22 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.lazy.LazyColumn
 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.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
 import androidx.compose.material.icons.rounded.Delete
+import androidx.compose.material.icons.rounded.Edit
 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.Divider
 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
 import androidx.compose.material3.MaterialTheme
@@ -58,8 +50,6 @@ import androidx.compose.material3.TextButton
 import androidx.compose.material3.rememberModalBottomSheetState
 import androidx.compose.material3.surfaceColorAtElevation
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -71,13 +61,16 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.geometry.Offset
 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.buildAnnotatedString
 import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
@@ -86,36 +79,30 @@ import androidx.navigation.NavController
 import com.journeyapps.barcodescanner.ScanContract
 import com.journeyapps.barcodescanner.ScanOptions
 import com.wireguard.android.backend.Tunnel
+import com.zaneschepke.wireguardautotunnel.Constants
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
-import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
 import com.zaneschepke.wireguardautotunnel.ui.CaptureActivityPortrait
-import com.zaneschepke.wireguardautotunnel.ui.Screen
+import com.zaneschepke.wireguardautotunnel.ui.Routes
 import com.zaneschepke.wireguardautotunnel.ui.common.RowListItem
-import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
+import com.zaneschepke.wireguardautotunnel.ui.theme.brickRed
-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.WgTunnelException
-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
 
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
+@OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun MainScreen(
     viewModel: MainViewModel = hiltViewModel(),
-    appViewModel: AppViewModel,
+    padding: PaddingValues,
-    focusRequester: FocusRequester,
+    showSnackbarMessage: (String) -> Unit,
     navController: NavController
 ) {
+
     val haptic = LocalHapticFeedback.current
     val context = LocalContext.current
     val isVisible = rememberSaveable { mutableStateOf(true) }
@@ -123,122 +110,120 @@ fun MainScreen(
 
     val sheetState = rememberModalBottomSheetState()
     var showBottomSheet by remember { mutableStateOf(false) }
-
+    var showPrimaryChangeAlertDialog by remember { mutableStateOf(false) }
-    var showDeleteTunnelAlertDialog by remember { mutableStateOf(false) }
+    val tunnels by viewModel.tunnels.collectAsStateWithLifecycle(mutableListOf())
+    val handshakeStatus by viewModel.handshakeStatus.collectAsStateWithLifecycle(HandshakeStatus.NOT_STARTED)
     var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val state by viewModel.state.collectAsStateWithLifecycle(Tunnel.State.DOWN)
+    val tunnelName by viewModel.tunnelName.collectAsStateWithLifecycle("")
+    val settings by viewModel.settings.collectAsStateWithLifecycle()
+    val statistics by viewModel.statistics.collectAsStateWithLifecycle(null)
 
-    LaunchedEffect(Unit) {
+    // Nested scroll for control FAB
-        if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+    val nestedScrollConnection = remember {
-            delay(Constants.FOCUS_REQUEST_DELAY)
+        object : NestedScrollConnection {
-            focusRequester.requestFocus()
+            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
+            }
         }
     }
 
-    val tunnelFileImportResultLauncher =
+    val tunnelFileImportResultLauncher = rememberLauncherForActivityResult(object : ActivityResultContracts.GetContent() {
-        rememberLauncherForActivityResult(
+        override fun createIntent(context: Context, input: String): Intent {
-            object : ActivityResultContracts.GetContent() {
+            val intent = super.createIntent(context, input)
-                override fun createIntent(context: Context, input: String): Intent {
-                    val intent = super.createIntent(context, input)
 
-                    /* AndroidTV now comes with stubs that do nothing but display a Toast less helpful than
+            /* AndroidTV now comes with stubs that do nothing but display a Toast less helpful than
-                     * what we can do, so detect this and throw an exception that we can catch later. */
+             * what we can do, so detect this and throw an exception that we can catch later. */
-                    val activitiesToResolveIntent =
+            val activitiesToResolveIntent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                context.packageManager.queryIntentActivities(intent, PackageManager.ResolveInfoFlags.of(PackageManager.MATCH_DEFAULT_ONLY.toLong()))
-                            context.packageManager.queryIntentActivities(
+            } else {
-                                intent,
+                context.packageManager.queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY)
-                                PackageManager.ResolveInfoFlags.of(
+            }
-                                    PackageManager.MATCH_DEFAULT_ONLY.toLong(),
+            if (activitiesToResolveIntent.all {
-                                ),
+                    val name = it.activityInfo.packageName
-                            )
+                    name.startsWith(Constants.GOOGLE_TV_EXPLORER_STUB) || name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
-                        } else {
+                }) {
-                            context.packageManager.queryIntentActivities(
+                throw WgTunnelException(context.getString(R.string.no_file_explorer))
-                                intent,
+            }
-                                PackageManager.MATCH_DEFAULT_ONLY,
+            return intent
-                            )
+        }
-                        }
+    }) { data ->
-                    if (
+        if (data == null) return@rememberLauncherForActivityResult
-                        activitiesToResolveIntent.all {
+        scope.launch(Dispatchers.IO) {
-                            val name = it.activityInfo.packageName
+            try {
-                            name.startsWith(Constants.GOOGLE_TV_EXPLORER_STUB) ||
+                viewModel.onTunnelFileSelected(data)
-                                name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
+            } catch (e : WgTunnelException) {
-                        }
+                showSnackbarMessage(e.message)
-                    ) {
+            }
-                        appViewModel.showSnackbarMessage(Event.Error.FileExplorerRequired.message)
+        }
-                    }
+    }
-                    return intent
+
-                }
+    val scanLauncher = rememberLauncherForActivityResult(
-            },
+        contract = ScanContract(),
-        ) { data ->
+        onResult = {
-            if (data == null) return@rememberLauncherForActivityResult
             scope.launch {
-                viewModel.onTunnelFileSelected(data).let {
+                try {
-                    when (it) {
+                    viewModel.onTunnelQrResult(it.contents)
-                        is Result.Error -> appViewModel.showSnackbarMessage(it.error.message)
+                } catch (e: Exception) {
-                        is Result.Success -> {}
+                    when(e) {
+                        is WgTunnelException -> {
+                            showSnackbarMessage(e.message)
+                        } else -> {
+                            showSnackbarMessage("No QR code scanned")
+                        }
                     }
                 }
             }
         }
-    val scanLauncher =
+    )
-        rememberLauncherForActivityResult(
-            contract = ScanContract(),
-            onResult = {
-                if (it.contents != null) {
-                    scope.launch {
-                        viewModel.onTunnelQrResult(it.contents).let { result ->
-                            when (result) {
-                                is Result.Success -> {}
-                                is Result.Error -> appViewModel.showSnackbarMessage(result.error.message)
-                            }
-                        }
-                    }
-                }
-            },
-        )
 
-    AnimatedVisibility(showDeleteTunnelAlertDialog) {
+    if(showPrimaryChangeAlertDialog) {
         AlertDialog(
-            onDismissRequest = { showDeleteTunnelAlertDialog = false },
+            onDismissRequest = {
+               showPrimaryChangeAlertDialog = false
+            },
             confirmButton = {
-                TextButton(
+                TextButton(onClick = {
-                    onClick = {
+                    scope.launch {
-                        selectedTunnel?.let { viewModel.onDelete(it) }
+                        viewModel.onDefaultTunnelChange(selectedTunnel)
-                        showDeleteTunnelAlertDialog = false
+                        showPrimaryChangeAlertDialog = false
                         selectedTunnel = null
-                    },
+                    }
-                ) {
+                })
-                    Text(text = stringResource(R.string.yes))
+                { Text(text = stringResource(R.string.okay)) }
-                }
             },
             dismissButton = {
-                TextButton(onClick = { showDeleteTunnelAlertDialog = false }) {
+                TextButton(onClick = {
-                    Text(text = stringResource(R.string.cancel))
+                    showPrimaryChangeAlertDialog = false
-                }
+                })
+                { Text(text = stringResource(R.string.cancel)) }
             },
-            title = { Text(text = stringResource(R.string.delete_tunnel)) },
+            title = { Text(text = stringResource(R.string.primary_tunnel_change)) },
-            text = { Text(text = stringResource(R.string.delete_tunnel_message)) },
+            text = { Text(text = stringResource(R.string.primary_tunnel_change_question)) }
         )
     }
 
-    fun onTunnelToggle(checked: Boolean, tunnel: TunnelConfig) {
+    fun onTunnelToggle(checked : Boolean , tunnel : TunnelConfig) {
-        if (appViewModel.isRequiredPermissionGranted()) {
+        try {
             if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
+        } catch (e : Exception) {
+            showSnackbarMessage(e.message!!)
         }
     }
 
-    if (uiState.loading) {
-        return LoadingScreen()
-    }
-
     Scaffold(
-        modifier =
+        modifier = Modifier.pointerInput(Unit) {
-        Modifier.pointerInput(Unit) {
+            detectTapGestures(onTap = {
-            detectTapGestures(
+                selectedTunnel = null
-                onTap = {
+            })
-                    selectedTunnel = null
-                },
-            )
         },
         floatingActionButtonPosition = FabPosition.End,
         floatingActionButton = {
@@ -251,19 +236,17 @@ fun MainScreen(
                 val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
                 var fobColor by remember { mutableStateOf(secondaryColor) }
                 FloatingActionButton(
-                    modifier =
+                    modifier = Modifier
-                    (if (
+                        .padding(bottom = 90.dp)
-                        WireGuardAutoTunnel.isRunningOnAndroidTv() &&
-                        uiState.tunnels.isEmpty()
-                    )
-                        Modifier.focusRequester(focusRequester)
-                    else Modifier)
                         .onFocusChanged {
-                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                            if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
                                 fobColor = if (it.isFocused) hoverColor else secondaryColor
                             }
-                        },
+                        }
-                    onClick = { showBottomSheet = true },
+                    ,
+                    onClick = {
+                        showBottomSheet = true
+                    },
                     containerColor = fobColor,
                     shape = RoundedCornerShape(16.dp),
                 ) {
@@ -274,378 +257,260 @@ fun MainScreen(
                     )
                 }
             }
-        },
+        }
     ) {
-        AnimatedVisibility(uiState.tunnels.isEmpty(), exit = fadeOut(), enter = fadeIn()) {
+        if (tunnels.isEmpty()) {
             Column(
                 horizontalAlignment = Alignment.CenterHorizontally,
                 verticalArrangement = Arrangement.Center,
                 modifier = Modifier
-                    .fillMaxSize(),
+                    .fillMaxSize()
+                    .padding(padding)
             ) {
                 Text(text = stringResource(R.string.no_tunnels), fontStyle = FontStyle.Italic)
             }
         }
         if (showBottomSheet) {
             ModalBottomSheet(
-                onDismissRequest = { showBottomSheet = false },
+                onDismissRequest = {
-                sheetState = sheetState,
+                    showBottomSheet = false
+                },
+                sheetState = sheetState
             ) {
                 // Sheet content
                 Row(
-                    modifier =
+                    modifier = Modifier
-                    Modifier
                         .fillMaxWidth()
                         .clickable {
                             showBottomSheet = false
-                            tunnelFileImportResultLauncher.launch(Constants.ALLOWED_FILE_TYPES)
+                            try {
+                                tunnelFileImportResultLauncher.launch(Constants.ALLOWED_FILE_TYPES)
+                            } catch (e: Exception) {
+                                showSnackbarMessage(e.message!!)
+                            }
                         }
-                        .padding(10.dp),
+                        .padding(10.dp)
                 ) {
                     Icon(
                         Icons.Filled.FileOpen,
                         contentDescription = stringResource(id = R.string.open_file),
-                        modifier = Modifier.padding(10.dp),
+                        modifier = Modifier.padding(10.dp)
                     )
                     Text(
                         stringResource(id = R.string.add_tunnels_text),
-                        modifier = Modifier.padding(10.dp),
+                        modifier = Modifier.padding(10.dp)
                     )
                 }
-                if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                if(!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                    HorizontalDivider()
+                    Divider()
-                    Row(
+                    Row(modifier = Modifier
-                        modifier =
+                        .fillMaxWidth()
-                        Modifier
+                        .clickable {
-                            .fillMaxWidth()
+                            scope.launch {
-                            .clickable {
+                                showBottomSheet = false
-                                scope.launch {
+                                val scanOptions = ScanOptions()
-                                    showBottomSheet = false
+                                scanOptions.setDesiredBarcodeFormats(ScanOptions.QR_CODE)
-                                    val scanOptions = ScanOptions()
+                                scanOptions.setOrientationLocked(true)
-                                    scanOptions.setDesiredBarcodeFormats(ScanOptions.QR_CODE)
+                                scanOptions.setPrompt(context.getString(R.string.scanning_qr))
-                                    scanOptions.setOrientationLocked(true)
+                                scanOptions.setBeepEnabled(false)
-                                    scanOptions.setPrompt(
+                                scanOptions.captureActivity = CaptureActivityPortrait::class.java
-                                        context.getString(R.string.scanning_qr),
+                                scanLauncher.launch(scanOptions)
-                                    )
-                                    scanOptions.setBeepEnabled(false)
-                                    scanOptions.captureActivity =
-                                        CaptureActivityPortrait::class.java
-                                    scanLauncher.launch(scanOptions)
-                                }
                             }
-                            .padding(10.dp),
+                        }
+                        .padding(10.dp)
                     ) {
                         Icon(
                             Icons.Filled.QrCode,
                             contentDescription = stringResource(id = R.string.qr_scan),
-                            modifier = Modifier.padding(10.dp),
+                            modifier = Modifier.padding(10.dp)
                         )
                         Text(
                             stringResource(id = R.string.add_from_qr),
-                            modifier = Modifier.padding(10.dp),
+                            modifier = Modifier.padding(10.dp)
                         )
                     }
                 }
-                HorizontalDivider()
+                Divider()
                 Row(
-                    modifier =
+                    modifier = Modifier
-                    Modifier
                         .fillMaxWidth()
                         .clickable {
                             showBottomSheet = false
-                            navController.navigate(
+                            navController.navigate("${Routes.Config.name}/${Constants.MANUAL_TUNNEL_CONFIG_ID}")
-                                "${Screen.Config.route}/${Constants.MANUAL_TUNNEL_CONFIG_ID}",
-                            )
                         }
-                        .padding(10.dp),
+                        .padding(10.dp)
                 ) {
                     Icon(
                         Icons.Filled.Create,
                         contentDescription = stringResource(id = R.string.create_import),
-                        modifier = Modifier.padding(10.dp),
+                        modifier = Modifier.padding(10.dp)
                     )
                     Text(
                         stringResource(id = R.string.create_import),
-                        modifier = Modifier.padding(10.dp),
+                        modifier = Modifier.padding(10.dp)
                     )
                 }
             }
         }
-
+        Column(
-        LazyColumn(
             horizontalAlignment = Alignment.Start,
             verticalArrangement = Arrangement.Top,
-            modifier =
+            modifier = Modifier
-            Modifier
+                .fillMaxSize()
-                .fillMaxWidth()
+                .padding(padding)
-                .overscroll(ScrollableDefaults.overscrollEffect()),
-            state = rememberLazyListState(0, uiState.tunnels.count()),
-            userScrollEnabled = true,
-            reverseLayout = false,
-            flingBehavior = ScrollableDefaults.flingBehavior(),
         ) {
-            item {
+            LazyColumn(
-                if (uiState.settings.isAutoTunnelEnabled) {
+                modifier = Modifier
-                    val autoTunnelingLabel = buildAnnotatedString {
+                    .fillMaxSize()
-                        append(stringResource(id = R.string.auto_tunneling))
+                    .nestedScroll(nestedScrollConnection),
-                        append(": ")
+            ) {
-                        if (uiState.settings.isAutoTunnelPaused) append(
+                items(tunnels, key = { tunnel -> tunnel.id }) { tunnel ->
-                            stringResource(id = R.string.paused),
+                   val leadingIconColor = (if (tunnelName == tunnel.name) when (handshakeStatus) {
-                        ) else append(
+                        HandshakeStatus.HEALTHY -> mint
-                            stringResource(id = R.string.active),
+                        HandshakeStatus.UNHEALTHY -> brickRed
-                        )
+                        HandshakeStatus.NOT_STARTED -> Color.Gray
+                        HandshakeStatus.NEVER_CONNECTED -> brickRed
+                    } else {Color.Gray})
+                    val focusRequester = remember { FocusRequester() }
+                    val expanded = remember {
+                        mutableStateOf(false)
                     }
-                    RowListItem(
+                    RowListItem(icon = {
-                        icon = {
+                        if (settings.isTunnelConfigDefault(tunnel))
-                            val icon = Icons.Rounded.Bolt
                             Icon(
-                                icon,
+                                Icons.Rounded.Star, stringResource(R.string.status),
-                                icon.name,
+                                tint = leadingIconColor,
                                 modifier = Modifier
-                                    .padding(end = 8.5.dp)
+                                    .padding(end = 10.dp)
-                                    .size(25.dp),
+                                    .size(20.dp)
-                                tint =
-                                if (uiState.settings.isAutoTunnelPaused) Color.Gray
-                                else mint,
                             )
-                        },
+                        else Icon(
-                        text = autoTunnelingLabel.text,
+                            Icons.Rounded.Circle, stringResource(R.string.status),
-                        rowButton = {
-                            if (uiState.settings.isAutoTunnelPaused) {
-                                TextButton(
-                                    onClick = { viewModel.resumeAutoTunneling() },
-                                ) {
-                                    Text(stringResource(id = R.string.resume))
-                                }
-                            } else {
-                                TextButton(
-                                    onClick = { viewModel.pauseAutoTunneling() },
-                                ) {
-                                    Text(stringResource(id = R.string.pause))
-                                }
-                            }
-                        },
-                        onClick = {},
-                        onHold = {},
-                        expanded = false,
-                        statistics = null,
-                    )
-                }
-            }
-            items(
-                uiState.tunnels,
-                key = { tunnel -> tunnel.id },
-            ) { tunnel ->
-                val leadingIconColor =
-                    (if (
-                        uiState.vpnState.tunnelConfig?.name == tunnel.name &&
-                        uiState.vpnState.status == Tunnel.State.UP
-                    ) {
-                        uiState.vpnState.statistics
-                            ?.mapPeerStats()
-                            ?.map { it.value?.handshakeStatus() }
-                            .let { statuses ->
-                                when {
-                                    statuses?.all { it == HandshakeStatus.HEALTHY } == true -> mint
-                                    statuses?.any { it == HandshakeStatus.STALE } == true -> corn
-                                    statuses?.all { it == HandshakeStatus.NOT_STARTED } == true ->
-                                        Color.Gray
-
-                                    else -> {
-                                        Color.Gray
-                                    }
-                                }
-                            }
-                    } else {
-                        Color.Gray
-                    })
-                val expanded = remember { mutableStateOf(false) }
-                RowListItem(
-                    icon = {
-                        val circleIcon = Icons.Rounded.Circle
-                        val icon = if (tunnel.isPrimaryTunnel) {
-                            Icons.Rounded.Star
-                        } else if (tunnel.isMobileDataTunnel) {
-                            Icons.Rounded.Smartphone
-                        } else {
-                            circleIcon
-                        }
-                        Icon(
-                            icon,
-                            icon.name,
                             tint = leadingIconColor,
                             modifier = Modifier
-                                .padding(
+                                .padding(end = 15.dp)
-                                    end = if (icon == circleIcon) 12.5.dp else 10.dp,
+                                .size(15.dp)
-                                    start = if (icon == circleIcon) 2.5.dp else 0.dp,
-                                )
-                                .size(if (icon == circleIcon) 15.dp else 20.dp),
                         )
                     },
-                    text = tunnel.name.truncateWithEllipsis(Constants.ALLOWED_DISPLAY_NAME_LENGTH),
+                        text = tunnel.name,
-                    onHold = {
+                        onHold = {
-                        if (
+                            if (state == Tunnel.State.UP && tunnel.name == tunnelName) {
-                            (uiState.vpnState.status == Tunnel.State.UP) &&
+                                showSnackbarMessage(context.resources.getString(R.string.turn_off_tunnel))
-                            (tunnel.name == uiState.vpnState.tunnelConfig?.name)
+                                return@RowListItem
-                        ) {
-                            appViewModel.showSnackbarMessage(Event.Message.TunnelOffAction.message)
-                            return@RowListItem
-                        }
-                        haptic.performHapticFeedback(HapticFeedbackType.LongPress)
-                        selectedTunnel = tunnel
-                    },
-                    onClick = {
-                        if (!WireGuardAutoTunnel.isRunningOnAndroidTv()) {
-                            if (
-                                uiState.vpnState.status == Tunnel.State.UP &&
-                                (uiState.vpnState.tunnelConfig?.name == tunnel.name)
-                            ) {
-                                expanded.value = !expanded.value
                             }
-                        } else {
+                            haptic.performHapticFeedback(HapticFeedbackType.LongPress)
                             selectedTunnel = tunnel
-                            focusRequester.requestFocus()
+                        },
-                        }
+                        onClick = {
-                    },
+                            if (!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                    statistics = uiState.vpnState.statistics,
+                                if(state == Tunnel.State.UP && (tunnelName == tunnel.name) ) {
-                    expanded = expanded.value,
+                                    expanded.value = !expanded.value
-                    rowButton = {
+                                }
-                        if (
+                            } else {
-                            tunnel.id == selectedTunnel?.id &&
+                                selectedTunnel = tunnel
-                            !WireGuardAutoTunnel.isRunningOnAndroidTv()
+                                focusRequester.requestFocus()
-                        ) {
+                            }
-                            Row {
+                        },
-                                IconButton(
+                        statistics = statistics,
-                                    onClick = {
+                        expanded = expanded.value,
-                                        if (
+                        rowButton = {
-                                            uiState.settings.isAutoTunnelEnabled &&
+                            if (tunnel.id == selectedTunnel?.id && !WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                                            !uiState.settings.isAutoTunnelPaused
+                                Row {
-                                        ) {
+                                    if(!settings.isTunnelConfigDefault(tunnel)) {
-                                            appViewModel.showSnackbarMessage(
+                                        IconButton(onClick = {
-                                                Event.Message.AutoTunnelOffAction.message,
+                                            if(settings.isAutoTunnelEnabled) {
-                                            )
+                                                showSnackbarMessage(context.resources.getString(R.string.turn_off_auto))
-                                        } else {
+                                            } else showPrimaryChangeAlertDialog = true
-                                            navController.navigate(
+                                        }) {
-                                                "${Screen.Option.route}/${selectedTunnel?.id}",
+                                            Icon(Icons.Rounded.Star, stringResource(id = R.string.set_primary))
-                                            )
                                         }
-                                    },
+                                    }
-                                ) {
+                                    IconButton(onClick = {
-                                    val icon = Icons.Rounded.Settings
+                                        navController.navigate("${Routes.Config.name}/${selectedTunnel?.id}")
-                                    Icon(
+                                    }) {
-                                        icon,
+                                        Icon(Icons.Rounded.Edit, stringResource(id = R.string.edit))
-                                        icon.name,
+                                    }
-                                    )
+                                    IconButton(
+                                        modifier = Modifier.focusable(),
+                                        onClick = { viewModel.onDelete(tunnel) }) {
+                                        Icon(
+                                            Icons.Rounded.Delete,
+                                            stringResource(id = R.string.delete)
+                                        )
+                                    }
                                 }
-                                IconButton(
+                            } else {
-                                    modifier = Modifier.focusable(),
+                                val checked = state == Tunnel.State.UP && tunnel.name == tunnelName
-                                    onClick = { viewModel.onCopyTunnel(selectedTunnel) },
+                                if(!checked) expanded.value = false
-                                ) {
+                                @Composable
-                                    val icon = Icons.Rounded.CopyAll
+                                fun TunnelSwitch() = Switch(
-                                    Icon(icon, icon.name)
-                                }
-                                IconButton(
-                                    modifier = Modifier.focusable(),
-                                    onClick = { showDeleteTunnelAlertDialog = true },
-                                ) {
-                                    val icon = Icons.Rounded.Delete
-                                    Icon(icon, icon.name)
-                                }
-                            }
-                        } else {
-                            val checked by remember {
-                                derivedStateOf {
-                                    (uiState.vpnState.status == Tunnel.State.UP &&
-                                        tunnel.name == uiState.vpnState.tunnelConfig?.name)
-                                }
-                            }
-                            if (!checked) expanded.value = false
-
-                            @Composable
-                            fun TunnelSwitch() =
-                                Switch(
                                     modifier = Modifier.focusRequester(focusRequester),
                                     checked = checked,
                                     onCheckedChange = { checked ->
-                                        if (!checked) expanded.value = false
+                                        if(!checked) expanded.value = false
                                         onTunnelToggle(checked, tunnel)
-                                    },
+                                    }
                                 )
-                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                                if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                                Row {
+                                    Row {
-                                    IconButton(
+                                        if(!settings.isTunnelConfigDefault(tunnel)) {
-                                        onClick = {
+                                            IconButton(onClick = {
-                                            if (uiState.settings.isAutoTunnelEnabled) {
+                                                if(settings.isAutoTunnelEnabled) {
-                                                appViewModel.showSnackbarMessage(
+                                                    showSnackbarMessage(context.resources.getString(R.string.turn_off_auto))
-                                                    Event.Message.AutoTunnelOffAction.message,
+                                                } else showPrimaryChangeAlertDialog = true
-                                                )
+                                            }) {
-                                            } else {
+                                                Icon(Icons.Rounded.Star, stringResource(id = R.string.set_primary))
-                                                selectedTunnel = tunnel
-                                                navController.navigate(
-                                                    "${Screen.Option.route}/${selectedTunnel?.id}",
-                                                )
                                             }
-                                        },
+                                        }
-                                    ) {
+                                        IconButton(
-                                        val icon = Icons.Rounded.Settings
+                                            modifier = Modifier.focusRequester(focusRequester),
-                                        Icon(
+                                            onClick = {
-                                            icon,
+                                                if(state == Tunnel.State.UP && (tunnelName == tunnel.name) ) {
-                                            icon.name,
+                                                    expanded.value = !expanded.value
-                                        )
+                                                }
-                                    }
+                                            }) {
-                                    IconButton(
+                                            Icon(Icons.Rounded.Info, stringResource(R.string.info))
-                                        modifier = Modifier.focusRequester(focusRequester),
+                                        }
-                                        onClick = {
+                                        IconButton(onClick = {
-                                            if (
+                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName)
-                                                uiState.vpnState.status == Tunnel.State.UP &&
+                                                showSnackbarMessage(
-                                                (uiState.vpnState.tunnelConfig?.name == tunnel.name)
+                                                    context.resources.getString(
-                                            ) {
+                                                        R.string.turn_off_tunnel
-                                                expanded.value = !expanded.value
+                                                    )
-                                            } else {
-                                                appViewModel.showSnackbarMessage(
-                                                    Event.Message.TunnelOnAction.message,
                                                 )
+                                            else {
+                                                navController.navigate("${Routes.Config.name}/${tunnel.id}")
                                             }
-                                        },
+                                        }) {
-                                    ) {
+                                            Icon(
-                                        val icon = Icons.Rounded.Info
+                                                Icons.Rounded.Edit,
-                                        Icon(icon, icon.name)
+                                                stringResource(id = R.string.edit)
-                                    }
+                                            )
-                                    IconButton(
+                                        }
-                                        onClick = { viewModel.onCopyTunnel(tunnel) },
+                                        IconButton(onClick = {
-                                    ) {
+                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName)
-                                        val icon = Icons.Rounded.CopyAll
+                                                showSnackbarMessage(
-                                        Icon(icon, icon.name)
+                                                    context.resources.getString(
-                                    }
+                                                        R.string.turn_off_tunnel
-                                    IconButton(
+                                                    )
-                                        onClick = {
-                                            if (
-                                                uiState.vpnState.status == Tunnel.State.UP &&
-                                                tunnel.name == uiState.vpnState.tunnelConfig?.name
-                                            ) {
-                                                appViewModel.showSnackbarMessage(
-                                                    Event.Message.TunnelOffAction.message,
                                                 )
-                                            } else {
+                                            else {
-                                                selectedTunnel = tunnel
+                                                viewModel.onDelete(tunnel)
-                                                showDeleteTunnelAlertDialog = true
                                             }
-                                        },
+                                        }) {
-                                    ) {
+                                            Icon(
-                                        val icon = Icons.Rounded.Delete
+                                                Icons.Rounded.Delete,
-                                        Icon(
+                                                stringResource(id = R.string.delete)
-                                            icon,
+                                            )
-                                            icon.name,
+                                        }
-                                        )
+                                        TunnelSwitch()
                                     }
+                                } else {
                                     TunnelSwitch()
                                 }
-                            } else {
-                                TunnelSwitch()
                             }
-                        }
+                        })
-                    },
+                }
-                )
             }
         }
     }

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

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

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

@@ -8,110 +8,128 @@ import android.provider.OpenableColumns
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.wireguard.config.Config
-import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
+import com.zaneschepke.wireguardautotunnel.Constants
-import com.zaneschepke.wireguardautotunnel.data.model.Settings
+import com.zaneschepke.wireguardautotunnel.R
-import com.zaneschepke.wireguardautotunnel.data.model.TunnelConfig
+import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
-import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.repository.TunnelConfigDao
+import com.zaneschepke.wireguardautotunnel.repository.model.Settings
+import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
+import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceState
+import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardConnectivityWatcherService
+import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
 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.Result
+import com.zaneschepke.wireguardautotunnel.util.WgTunnelException
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import timber.log.Timber
 import java.io.InputStream
 import java.util.zip.ZipInputStream
 import javax.inject.Inject
 
+
 @HiltViewModel
-class MainViewModel
+class MainViewModel @Inject constructor(
-@Inject
-constructor(
     private val application: Application,
-    private val appDataRepository: AppDataRepository,
+    private val tunnelRepo: TunnelConfigDao,
-    private val serviceManager: ServiceManager,
+    private val settingsRepo: SettingsDoa,
-    val vpnService: VpnService
+    private val vpnService: VpnService
 ) : ViewModel() {
 
-    val uiState =
+    val tunnels get() = tunnelRepo.getAllFlow()
-        combine(
+    val state get() = vpnService.state
-            appDataRepository.settings.getSettingsFlow(),
-            appDataRepository.tunnels.getTunnelConfigsFlow(),
-            vpnService.vpnState,
-        ) { settings, tunnels, vpnState ->
-            MainUiState(settings, tunnels, vpnState, false)
-        }
-            .stateIn(
-                viewModelScope,
-                SharingStarted.WhileSubscribed(Constants.SUBSCRIPTION_TIMEOUT),
-                MainUiState(),
-            )
 
-    private fun stopWatcherService() =
+    val handshakeStatus get() = vpnService.handshakeStatus
+    val tunnelName get() = vpnService.tunnelName
+    private val _settings = MutableStateFlow(Settings())
+    val settings get() = _settings.asStateFlow()
+    val statistics get() = vpnService.statistics
+
+    init {
         viewModelScope.launch(Dispatchers.IO) {
-            serviceManager.stopWatcherService(application.applicationContext)
+            settingsRepo.getAllFlow().filter { it.isNotEmpty() }.collect {
+                val settings = it.first()
+                validateWatcherServiceState(settings)
+                _settings.emit(settings)
+            }
         }
+    }
+
+    private fun validateWatcherServiceState(settings: Settings) {
+        val watcherState = ServiceManager.getServiceState(
+            application.applicationContext,
+            WireGuardConnectivityWatcherService::class.java
+        )
+        if (settings.isAutoTunnelEnabled && watcherState == ServiceState.STOPPED && settings.defaultTunnel != null) {
+            ServiceManager.startWatcherService(
+                application.applicationContext,
+                settings.defaultTunnel!!
+            )
+        }
+    }
+
 
     fun onDelete(tunnel: TunnelConfig) {
-        viewModelScope.launch(Dispatchers.IO) {
+        viewModelScope.launch {
-            val settings = appDataRepository.settings.getSettings()
+            if (tunnelRepo.count() == 1L) {
-            val isPrimary = tunnel.isPrimaryTunnel
+                ServiceManager.stopWatcherService(application.applicationContext)
-            if (appDataRepository.tunnels.count() == 1 || isPrimary) {
+                val settings = settingsRepo.getAll()
-                stopWatcherService()
+                if (settings.isNotEmpty()) {
-                resetTunnelSetting(settings)
+                    val setting = settings[0]
+                    setting.defaultTunnel = null
+                    setting.isAutoTunnelEnabled = false
+                    setting.isAlwaysOnVpnEnabled = false
+                    settingsRepo.save(setting)
+                }
             }
-            appDataRepository.tunnels.delete(tunnel)
+            tunnelRepo.delete(tunnel)
-            WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
         }
     }
 
-    private fun resetTunnelSetting(settings: Settings) {
+    fun onTunnelStart(tunnelConfig: TunnelConfig) {
-        saveSettings(
+        viewModelScope.launch {
-            settings.copy(
+            stopActiveTunnel()
-                isAutoTunnelEnabled = false,
+            startTunnel(tunnelConfig)
-                isAlwaysOnVpnEnabled = false,
+        }
-            ),
-        )
     }
 
-    fun onTunnelStart(tunnelConfig: TunnelConfig) =
+    private fun startTunnel(tunnelConfig: TunnelConfig) {
-        viewModelScope.launch(Dispatchers.IO) {
+        ServiceManager.startVpnService(application.applicationContext, tunnelConfig.toString())
-            Timber.d("On start called!")
+    }
-            serviceManager.startVpnService(
+
+    private suspend fun stopActiveTunnel() {
+        if (ServiceManager.getServiceState(
                 application.applicationContext,
-                tunnelConfig.id,
+                WireGuardTunnelService::class.java,
-                isManualStart = true,
+            ) == ServiceState.STARTED
-            )
+        ) {
+            onTunnelStop()
+            delay(Constants.TOGGLE_TUNNEL_DELAY)
         }
+    }
 
-
+    fun onTunnelStop() {
-    fun onTunnelStop() =
+        ServiceManager.stopVpnService(application.applicationContext)
-        viewModelScope.launch(Dispatchers.IO) {
+    }
-            Timber.i("Stopping active tunnel")
-            serviceManager.stopVpnService(application.applicationContext, isManualStop = true)
-        }
 
     private fun validateConfigString(config: String) {
         TunnelConfig.configFromQuick(config)
     }
 
-    suspend fun onTunnelQrResult(result: String): Result<Unit> {
+    suspend fun onTunnelQrResult(result: String) {
-        return try {
+        try {
             validateConfigString(result)
             val tunnelConfig =
                 TunnelConfig(name = NumberUtils.generateRandomTunnelName(), wgQuick = result)
             addTunnel(tunnelConfig)
-            Result.Success(Unit)
+        } catch (e : Exception) {
-        } catch (e: Exception) {
+            throw WgTunnelException(e)
-            Timber.e(e)
-            Result.Error(Event.Error.InvalidQrCode)
         }
     }
 
@@ -120,119 +138,100 @@ constructor(
         val config = Config.parse(bufferReader)
         val tunnelName = getNameFromFileName(fileName)
         addTunnel(TunnelConfig(name = tunnelName, wgQuick = config.toWgQuickString()))
-        withContext(Dispatchers.IO) { stream.close() }
+        withContext(Dispatchers.IO) {
+            stream.close()
+        }
     }
 
-    private fun getInputStreamFromUri(uri: Uri): InputStream? {
+    private fun getInputStreamFromUri(uri: Uri): InputStream {
         return application.applicationContext.contentResolver.openInputStream(uri)
+            ?: throw WgTunnelException(application.getString(R.string.stream_failed))
     }
 
-    suspend fun onTunnelFileSelected(uri: Uri): Result<Unit> {
+    suspend fun onTunnelFileSelected(uri: Uri) {
         try {
-            if (isValidUriContentScheme(uri)) {
+            val fileName = getFileName(application.applicationContext, uri)
-                val fileName = getFileName(application.applicationContext, uri)
+            val fileExtension = getFileExtensionFromFileName(fileName)
-                when (getFileExtensionFromFileName(fileName)) {
+            when(fileExtension){
-                    Constants.CONF_FILE_EXTENSION ->
+                Constants.CONF_FILE_EXTENSION -> saveTunnelFromConfUri(fileName, uri)
-                        saveTunnelFromConfUri(fileName, uri).let {
+                Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(uri)
-                            when (it) {
+                else -> throw WgTunnelException(application.getString(R.string.file_extension_message))
-                                is Result.Error -> return Result.Error(Event.Error.FileReadFailed)
-                                is Result.Success -> return it
-                            }
-                        }
-
-                    Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(uri)
-                    else -> return Result.Error(Event.Error.InvalidFileExtension)
-                }
-                return Result.Success(Unit)
-            } else {
-                return Result.Error(Event.Error.InvalidFileExtension)
             }
         } catch (e: Exception) {
-            Timber.e(e)
+            throw WgTunnelException(e)
-            return Result.Error(Event.Error.FileReadFailed)
         }
     }
 
     private suspend fun saveTunnelsFromZipUri(uri: Uri) {
         ZipInputStream(getInputStreamFromUri(uri)).use { zip ->
             generateSequence { zip.nextEntry }
-                .filterNot {
+                .filterNot { it.isDirectory ||
-                    it.isDirectory ||
+                        getFileExtensionFromFileName(it.name) != Constants.CONF_FILE_EXTENSION }
-                        getFileExtensionFromFileName(it.name) != Constants.CONF_FILE_EXTENSION
-                }
                 .forEach {
                     val name = getNameFromFileName(it.name)
                     val config = Config.parse(zip)
                     viewModelScope.launch(Dispatchers.IO) {
                         addTunnel(TunnelConfig(name = name, wgQuick = config.toWgQuickString()))
-                    }
                 }
+            }
         }
     }
 
-    private suspend fun saveTunnelFromConfUri(name: String, uri: Uri): Result<Unit> {
+    private suspend fun saveTunnelFromConfUri(name : String, uri: Uri) {
         val stream = getInputStreamFromUri(uri)
-        return if (stream != null) {
+        saveTunnelConfigFromStream(stream, name)
-            saveTunnelConfigFromStream(stream, name)
-            Result.Success(Unit)
-        } else {
-            Result.Error(Event.Error.FileReadFailed)
-        }
     }
 
     private suspend fun addTunnel(tunnelConfig: TunnelConfig) {
-        val firstTunnel = appDataRepository.tunnels.count() == 0
         saveTunnel(tunnelConfig)
-        if (firstTunnel) WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate(application)
     }
 
-    fun pauseAutoTunneling() =
-        viewModelScope.launch {
-            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = true))
-            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate(application)
-        }
-
-    fun resumeAutoTunneling() =
-        viewModelScope.launch {
-            appDataRepository.settings.save(uiState.value.settings.copy(isAutoTunnelPaused = false))
-            WireGuardAutoTunnel.requestAutoTunnelTileServiceUpdate(application)
-        }
-
     private suspend fun saveTunnel(tunnelConfig: TunnelConfig) {
-        appDataRepository.tunnels.save(tunnelConfig)
+        tunnelRepo.save(tunnelConfig)
     }
 
-    private fun getFileNameByCursor(context: Context, uri: Uri): String? {
+    private fun getFileNameByCursor(context: Context, uri: Uri): String {
-        context.contentResolver.query(uri, null, null, null, null)?.use {
+        val cursor = context.contentResolver.query(uri, null, null, null, null)
-            return getDisplayNameByCursor(it)
+        if (cursor != null) {
-        }
+            cursor.use {
-        return null
+                return getDisplayNameByCursor(it)
-    }
+            }
-
-    private fun getDisplayNameColumnIndex(cursor: Cursor): Int? {
-        val columnIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
-        return if (columnIndex != -1) {
-            return columnIndex
         } else {
-            null
+            throw WgTunnelException("Failed to initialize cursor")
         }
     }
 
-    private fun getDisplayNameByCursor(cursor: Cursor): String? {
+    private fun getDisplayNameColumnIndex(cursor: Cursor): Int {
-        return if (cursor.moveToFirst()) {
+        val columnIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
-            val index = getDisplayNameColumnIndex(cursor)
+        if (columnIndex == -1) {
-            if (index != null) {
+            throw WgTunnelException("Cursor out of bounds")
-                cursor.getString(index)
+        }
-            } else null
+        return columnIndex
-        } else null
     }
 
-    private fun isValidUriContentScheme(uri: Uri): Boolean {
+    private fun getDisplayNameByCursor(cursor: Cursor): String {
-        return uri.scheme == Constants.URI_CONTENT_SCHEME
+        if (cursor.moveToFirst()) {
+            val index = getDisplayNameColumnIndex(cursor)
+            return cursor.getString(index)
+        } else {
+            throw WgTunnelException("Cursor failed to move to first")
+        }
     }
 
+    private fun validateUriContentScheme(uri: Uri) {
+        if (uri.scheme != Constants.URI_CONTENT_SCHEME) {
+            throw WgTunnelException(application.getString(R.string.file_extension_message))
+        }
+    }
+
+
     private fun getFileName(context: Context, uri: Uri): String {
-        return getFileNameByCursor(context, uri) ?: NumberUtils.generateRandomTunnelName()
+        validateUriContentScheme(uri)
+        return try {
+            getFileNameByCursor(context, uri)
+        } catch (_: Exception) {
+            NumberUtils.generateRandomTunnelName()
+        }
     }
 
     private fun getNameFromFileName(fileName: String): String {
@@ -243,23 +242,18 @@ constructor(
         return try {
             fileName.substring(fileName.lastIndexOf('.'))
         } catch (e: Exception) {
-            Timber.e(e)
             ""
         }
     }
 
-    private fun saveSettings(settings: Settings) =
+    suspend fun onDefaultTunnelChange(selectedTunnel: TunnelConfig?) {
-        viewModelScope.launch(Dispatchers.IO) { appDataRepository.settings.save(settings) }
+        if (selectedTunnel != null) {
-
+            _settings.emit(
-
+                _settings.value.copy(
-    fun onCopyTunnel(tunnel: TunnelConfig?) = viewModelScope.launch {
+                    defaultTunnel = selectedTunnel.toString()
-        tunnel?.let {
+                )
-            saveTunnel(
-                TunnelConfig(
-                    name = it.name.plus(NumberUtils.randomThree()),
-                    wgQuick = it.wgQuick,
-                ),
             )
+            settingsRepo.save(_settings.value)
         }
     }
 }