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.

.github/workflows/android.yml

@@ -70,7 +70,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           # fix hardcode changelog file name
-          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/32400.txt
+          body_path: ${{ github.workspace }}/fastlane/metadata/android/en-US/changelogs/32300.txt
           tag_name: ${{ github.ref_name }}
           name: Release ${{ github.ref_name }}
           draft: false

app/build.gradle.kts

@@ -23,10 +23,6 @@ android {
             arg("room.schemaLocation", "$projectDir/schemas")
         }
 
-        sourceSets {
-            getByName("debug").assets.srcDirs(files("$projectDir/schemas")) // Room
-        }
-
         resourceConfigurations.addAll(listOf("en"))
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
@@ -37,51 +33,33 @@ android {
 
     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 build
+            //try to get secrets from env first for pipeline build, then properties file for local build
-            storeFile = file(
+            storeFile = file(System.getenv().getOrDefault(Constants.KEY_STORE_PATH_VAR, properties.getProperty(Constants.KEY_STORE_PATH_VAR)))
-                System.getenv().getOrDefault(
+            storePassword = System.getenv().getOrDefault(Constants.STORE_PASS_VAR, properties.getProperty(Constants.STORE_PASS_VAR))
-                    Constants.KEY_STORE_PATH_VAR,
+            keyAlias = System.getenv().getOrDefault(Constants.KEY_ALIAS_VAR, properties.getProperty(Constants.KEY_ALIAS_VAR))
-                    properties.getProperty(Constants.KEY_STORE_PATH_VAR)
+            keyPassword = System.getenv().getOrDefault(Constants.KEY_PASS_VAR, properties.getProperty(Constants.KEY_PASS_VAR))
-                )
-            )
-            storePassword = System.getenv().getOrDefault(
-                Constants.STORE_PASS_VAR,
-                properties.getProperty(Constants.STORE_PASS_VAR)
-            )
-            keyAlias = System.getenv().getOrDefault(
-                Constants.KEY_ALIAS_VAR,
-                properties.getProperty(Constants.KEY_ALIAS_VAR)
-            )
-            keyPassword = System.getenv().getOrDefault(
-                Constants.KEY_PASS_VAR,
-                properties.getProperty(Constants.KEY_PASS_VAR)
-            )
         }
     }
 
     buildTypes {
-        // don't strip
+        //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
                 }
         }
@@ -107,7 +85,8 @@ android {
         }
         create("general") {
             dimension = Constants.TYPE
-            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
+            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle))
+            {
                 apply(plugin = "com.google.gms.google-services")
                 apply(plugin = "com.google.firebase.crashlytics")
             }
@@ -124,6 +103,7 @@ android {
     buildFeatures {
         compose = true
         buildConfig = true
+
     }
     composeOptions {
         kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
@@ -149,22 +129,20 @@ 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)
 
-    // wg
+    //wg
     implementation(libs.tunnel)
     coreLibraryDesugaring(libs.desugar.jdk.libs)
 
-    // logging
+    //logging
     implementation(libs.timber)
 
     // compose navigation
@@ -175,41 +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)
 
-    // firebase crashlytics
+    //firebase crashlytics
     generalImplementation(platform(libs.firebase.bom))
     generalImplementation(libs.google.firebase.crashlytics.ktx)
     generalImplementation(libs.google.firebase.analytics.ktx)
 
-    // barcode scanning
+    //barcode scanning
     implementation(libs.zxing.android.embedded)
     implementation(libs.zxing.core)
 
-    // bio
+    //bio
     implementation(libs.androidx.biometric.ktx)
 
-    // 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/proguard-rules.pro

@@ -19,6 +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.repository.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/src/androidTest/java/com/zaneschepke/wireguardautotunnel/MigrationTest.kt

@@ -1,63 +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.repository.AppDatabase
-import java.io.IOException
-import org.junit.Rule
-import org.junit.Test
-import org.junit.runner.RunWith
-
-@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 migrate2To3() {
-        helper.createDatabase(dbName, 3).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(
-                "INSERT INTO Settings (is_tunnel_enabled, " +
-                        "is_tunnel_on_mobile_data_enabled," +
-                        "trusted_network_ssids," +
-                        "default_tunnel, " +
-                        "is_always_on_vpn_enabled," +
-                        "is_tunnel_on_ethernet_enabled," +
-                        "is_shortcuts_enabled," +
-                        "is_battery_saver_enabled," +
-                        "is_tunnel_on_wifi_enabled)" +
-                        " VALUES (" +
-                        "false," +
-                        "false," +
-                        "'[trustedSSID1,trustedSSID2]'," +
-                        "'defaultTunnel'," +
-                        "false," +
-                        "false," +
-                        "false," +
-                        "false," +
-                        "false)"
-            )
-            execSQL(
-                "INSERT INTO TunnelConfig (name, wg_quick)" +
-                        " VALUES ('hello', 'hello')"
-            )
-            // 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, 4, true)
-        // MigrationTestHelper automatically verifies the schema changes,
-        // but you need to validate that the data was migrated properly.
-    }
-}

app/src/main/AndroidManifest.xml

@@ -17,10 +17,6 @@
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
     <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
     <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
-    <!--foreground service exempt android 14-->
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SYSTEM_EXEMPTED"/>
-    <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"/>
-
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_REMOTE_MESSAGING"/>
     <!--foreground service permissions-->
@@ -106,7 +102,7 @@
             android:permission="android.permission.BIND_VPN_SERVICE"
             android:enabled="true"
             android:persistent="true"
-            android:foregroundServiceType="systemExempted"
+            android:foregroundServiceType="remoteMessaging"
             android:exported="false">
             <intent-filter>
                 <action android:name="android.net.VpnService"/>
@@ -119,7 +115,8 @@
             android:enabled="true"
             android:stopWithTask="false"
             android:persistent="true"
-            android:foregroundServiceType="systemExempted"
+            android:foregroundServiceType="location"
+            android:permission=""
             android:exported="false">
         </service>
         <receiver android:enabled="true" android:name=".receiver.BootReceiver"

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

@@ -2,7 +2,7 @@ package com.zaneschepke.wireguardautotunnel
 
 object Constants {
     const val MANUAL_TUNNEL_CONFIG_ID = "0"
-    const val WATCHER_SERVICE_WAKE_LOCK_TIMEOUT = 10 * 60 * 1000L // 10 minutes
+    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
@@ -17,5 +17,4 @@ object Constants {
     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"
-    const val SYSTEM_EXEMPT_SERVICE_TYPE_ID = 1024
 }

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

@@ -1,14 +1,14 @@
 package com.zaneschepke.wireguardautotunnel
 
 import android.content.BroadcastReceiver
-import java.math.BigDecimal
-import java.text.DecimalFormat
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
 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,
@@ -25,7 +25,7 @@ fun BroadcastReceiver.goAsync(
     }
 }
 
-fun BigDecimal.toThreeDecimalPlaceString(): String {
+fun BigDecimal.toThreeDecimalPlaceString() : String {
     val df = DecimalFormat("#.###")
     return df.format(this)
 }

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

@@ -6,50 +6,40 @@ import android.content.pm.PackageManager
 import androidx.lifecycle.ProcessLifecycleOwner
 import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
-import com.zaneschepke.wireguardautotunnel.repository.datastore.DataStoreManager
 import com.zaneschepke.wireguardautotunnel.repository.model.Settings
 import dagger.hilt.android.HiltAndroidApp
-import java.io.IOException
-import javax.inject.Inject
 import kotlinx.coroutines.launch
 import timber.log.Timber
+import javax.inject.Inject
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
-    @Inject
-    lateinit var settingsRepo: SettingsDoa
 
     @Inject
-    lateinit var dataStoreManager: DataStoreManager
+    lateinit var settingsRepo : SettingsDoa
 
     override fun onCreate() {
         super.onCreate()
-        if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree())
+        if(BuildConfig.DEBUG) {
-        initSettings()
+            Timber.plant(Timber.DebugTree())
-        with(ProcessLifecycleOwner.get()) {
-            lifecycleScope.launch {
-                try {
-                    // load preferences into memory
-                    dataStoreManager.init()
-                } catch (e: IOException) {
-                    Timber.e("Failed to load preferences")
-                }
-            }
         }
+        initSettings()
     }
 
     private fun initSettings() {
         with(ProcessLifecycleOwner.get()) {
             lifecycleScope.launch {
-                if (settingsRepo.getAll().isEmpty()) {
+                if(settingsRepo.getAll().isEmpty()) {
                     settingsRepo.save(Settings())
                 }
             }
         }
     }
 
+
+
     companion object {
-        fun isRunningOnAndroidTv(context: Context): Boolean {
+        fun isRunningOnAndroidTv(context : Context) : Boolean {
             return context.packageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)
         }
     }

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

@@ -16,14 +16,10 @@ import javax.inject.Singleton
 class DatabaseModule {
     @Provides
     @Singleton
-    fun provideDatabase(
+    fun provideDatabase(@ApplicationContext context : Context) : AppDatabase {
-        @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()
             .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,35 +1,27 @@
 package com.zaneschepke.wireguardautotunnel.module
 
-import android.content.Context
 import com.zaneschepke.wireguardautotunnel.repository.AppDatabase
 import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
 import com.zaneschepke.wireguardautotunnel.repository.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.repository.datastore.DataStoreManager
 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 provideSettingsRepository(appDatabase: AppDatabase): SettingsDoa {
+    fun provideSettingsRepository(appDatabase: AppDatabase) : SettingsDoa {
         return appDatabase.settingDao()
     }
 
     @Singleton
     @Provides
-    fun provideTunnelConfigRepository(appDatabase: AppDatabase): TunnelConfigDao {
+    fun provideTunnelConfigRepository(appDatabase: AppDatabase) : TunnelConfigDao {
         return appDatabase.tunnelConfigDoa()
     }
-
-    @Singleton
-    @Provides
-    fun providePreferencesDataStore(@ApplicationContext context: Context): DataStoreManager {
-        return DataStoreManager(context)
-    }
 }

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

@@ -15,19 +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(mobileDataService: MobileDataService): NetworkService<MobileDataService>
+    abstract fun provideWifiService(wifiService: WifiService) : NetworkService<WifiService>
 
     @Binds
     @ServiceScoped
-    abstract fun provideEthernetService(ethernetService: EthernetService): NetworkService<EthernetService>
+    abstract fun provideMobileDataService(mobileDataService : MobileDataService) : NetworkService<MobileDataService>
+
+    @Binds
+    @ServiceScoped
+    abstract fun provideEthernetService(ethernetService: EthernetService) : NetworkService<EthernetService>
 }

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

@@ -3,10 +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.repository.SettingsDoa
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.WireGuardTunnel
 import dagger.Module
@@ -19,40 +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(
+        return WireGuardTunnel(backend)
-        @ApplicationContext context: Context,
-        rootShell: RootShell
-    ): Backend {
-        return WgQuickBackend(context, rootShell, ToolsInstaller(context, rootShell))
-    }
-
-    @Provides
-    @Singleton
-    fun provideVpnService(
-        @Userspace userspaceBackend: Backend,
-        @Kernel kernelBackend: Backend,
-        settingsDoa: SettingsDoa
-    ): VpnService {
-        return WireGuardTunnel(userspaceBackend, kernelBackend, settingsDoa)
     }
 }

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

@@ -7,18 +7,16 @@ import com.zaneschepke.wireguardautotunnel.goAsync
 import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.cancel
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class BootReceiver : BroadcastReceiver() {
-    @Inject
-    lateinit var settingsRepo: SettingsDoa
 
-    override fun onReceive(
+    @Inject
-        context: Context,
+    lateinit var settingsRepo : SettingsDoa
-        intent: Intent
+
-    ) = goAsync {
+    override fun onReceive(context: Context, intent: Intent) = goAsync {
         if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
             try {
                 val settings = settingsRepo.getAll()

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

@@ -8,19 +8,16 @@ import com.zaneschepke.wireguardautotunnel.goAsync
 import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.delay
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class NotificationActionReceiver : BroadcastReceiver() {
-    @Inject
-    lateinit var settingsRepo: SettingsDoa
 
-    override fun onReceive(
+    @Inject
-        context: Context,
+    lateinit var settingsRepo : SettingsDoa
-        intent: Intent?
+    override fun onReceive(context: Context, intent: Intent?) = goAsync {
-    ) = goAsync {
         try {
             val settings = settingsRepo.getAll()
             if (settings.isNotEmpty()) {

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

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

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

@@ -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.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

@@ -10,6 +10,7 @@ import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface SettingsDoa {
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun save(t: Settings)
 

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

@@ -9,7 +9,8 @@ import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import kotlinx.coroutines.flow.Flow
 
 @Dao
-interface TunnelConfigDao {
+interface TunnelConfigDao{
+
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun save(t: TunnelConfig)
 

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

@@ -1,39 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.repository.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.preferencesDataStore
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.map
-
-class DataStoreManager(private val context: Context) {
-    companion object {
-        val LOCATION_DISCLOSURE_SHOWN = booleanPreferencesKey("LOCATION_DISCLOSURE_SHOWN")
-    }
-
-    // preferences
-    private val preferencesKey = "preferences"
-    private val Context.dataStore by preferencesDataStore(
-        name = preferencesKey
-    )
-
-    suspend fun init() {
-        context.dataStore.data.first()
-    }
-
-    suspend fun <T> saveToDataStore(key: Preferences.Key<T>, value: T) =
-        context.dataStore.edit {
-        it[key] = value
-    }
-
-    fun <T> getFromStore(key: Preferences.Key<T>) =
-        context.dataStore.data.map {
-        it[key]
-    }
-
-    val locationDisclosureFlow: Flow<Boolean?> = context.dataStore.data.map {
-        it[LOCATION_DISCLOSURE_SHOWN]
-    }
-}

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

@@ -6,39 +6,18 @@ import androidx.room.PrimaryKey
 
 @Entity
 data class Settings(
-    @PrimaryKey(autoGenerate = true) val id: Int = 0,
+    @PrimaryKey(autoGenerate = true) val id : Int = 0,
-    @ColumnInfo(name = "is_tunnel_enabled") var isAutoTunnelEnabled: Boolean = false,
+    @ColumnInfo(name = "is_tunnel_enabled") var isAutoTunnelEnabled : Boolean = false,
-    @ColumnInfo(name = "is_tunnel_on_mobile_data_enabled") var isTunnelOnMobileDataEnabled: 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 = "trusted_network_ssids") var trustedNetworkSSIDs : MutableList<String> = mutableListOf(),
-    @ColumnInfo(name = "default_tunnel") var defaultTunnel: String? = null,
+    @ColumnInfo(name = "default_tunnel") var defaultTunnel : String? = null,
-    @ColumnInfo(name = "is_always_on_vpn_enabled") var isAlwaysOnVpnEnabled: Boolean = false,
+    @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_tunnel_on_ethernet_enabled") var isTunnelOnEthernetEnabled : Boolean = false,
-    @ColumnInfo(
+    @ColumnInfo(name = "is_shortcuts_enabled", defaultValue = "false") var isShortcutsEnabled : Boolean = false,
-        name = "is_shortcuts_enabled",
+    @ColumnInfo(name = "is_battery_saver_enabled", defaultValue = "false") var isBatterySaverEnabled : Boolean = false,
-        defaultValue = "false"
+    @ColumnInfo(name = "is_tunnel_on_wifi_enabled", defaultValue = "false") var isTunnelOnWifiEnabled : Boolean = false,
-    ) var isShortcutsEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_battery_saver_enabled",
-        defaultValue = "false"
-    ) var isBatterySaverEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_tunnel_on_wifi_enabled",
-        defaultValue = "false"
-    ) var isTunnelOnWifiEnabled: Boolean = false,
-    @ColumnInfo(
-        name = "is_kernel_enabled",
-        defaultValue = "false"
-    ) var isKernelEnabled: Boolean = false,
-    @ColumnInfo(
-    name = "is_restore_on_boot_enabled",
-    defaultValue = "false"
-    ) var isRestoreOnBootEnabled: Boolean = false,
-    @ColumnInfo(
-    name = "is_multi_tunnel_enabled",
-    defaultValue = "false"
-    ) var isMultiTunnelEnabled: Boolean = false
 ) {
-    fun isTunnelConfigDefault(tunnelConfig: TunnelConfig): Boolean {
+    fun isTunnelConfigDefault(tunnelConfig: TunnelConfig) : Boolean {
         return if (defaultTunnel != null) {
             val defaultConfig = TunnelConfig.from(defaultTunnel!!)
             (tunnelConfig.id == defaultConfig.id)

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

@@ -5,26 +5,27 @@ import androidx.room.Entity
 import androidx.room.Index
 import androidx.room.PrimaryKey
 import com.wireguard.config.Config
-import java.io.InputStream
 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,
+    @PrimaryKey(autoGenerate = true) val id : Int = 0,
-    @ColumnInfo(name = "name") var name: String,
+    @ColumnInfo(name = "name") var name : String,
-    @ColumnInfo(name = "wg_quick") var wgQuick: String
+    @ColumnInfo(name = "wg_quick") var wgQuick : String,
-) {
+){
+
     override fun toString(): String {
         return Json.encodeToString(serializer(), this)
     }
 
     companion object {
-        fun from(string: String): TunnelConfig {
+
+        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)

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

@@ -6,7 +6,9 @@ import android.os.IBinder
 import androidx.lifecycle.LifecycleService
 import timber.log.Timber
 
+
 open class ForegroundService : LifecycleService() {
+
     private var isServiceStarted = false
 
     override fun onBind(intent: Intent): IBinder? {
@@ -15,11 +17,7 @@ open class ForegroundService : LifecycleService() {
         return null
     }
 
-    override fun onStartCommand(
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        intent: Intent?,
-        flags: Int,
-        startId: Int
-    ): Int {
         super.onStartCommand(intent, flags, startId)
         Timber.d("onStartCommand executed with startId: $startId")
         if (intent != null) {
@@ -43,18 +41,19 @@ open class ForegroundService : LifecycleService() {
         return START_STICKY
     }
 
+
     override fun onDestroy() {
         super.onDestroy()
         Timber.d("The service has been destroyed")
     }
 
-    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(extras: Bundle?) {
+    protected open fun stopService(extras : Bundle?) {
         Timber.d("Stopping ${this.javaClass.simpleName}")
         try {
             stopForeground(STOP_FOREGROUND_REMOVE)

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

@@ -16,60 +16,44 @@ object ServiceManager {
             .getRunningServices(Integer.MAX_VALUE)
             .any { it.service.className == service.name }
 
-    fun <T : Service> getServiceState(
+    fun <T : Service> getServiceState(context: Context, cls : Class<T>): ServiceState {
-        context: Context,
-        cls: Class<T>
-    ): ServiceState {
         val isServiceRunning = context.isServiceRunning(cls)
-        return if (isServiceRunning) ServiceState.STARTED else ServiceState.STOPPED
+        return if(isServiceRunning) ServiceState.STARTED else ServiceState.STOPPED
     }
 
-    private fun <T : Service> actionOnService(
+    private fun <T : Service> actionOnService(action: Action, context: Context, cls : Class<T>, extras : Map<String,String>? = null) {
-        action: Action,
-        context: Context,
-        cls: Class<T>,
-        extras: Map<String, String>? = null
-    ) {
         if (getServiceState(context, cls) == ServiceState.STOPPED && action == Action.STOP) return
         if (getServiceState(context, cls) == ServiceState.STARTED && action == Action.START) return
-        val intent =
+        val intent = Intent(context, cls).also {
-            Intent(context, cls).also {
+            it.action = action.name
-                it.action = action.name
+            extras?.forEach {(k, v) ->
-                extras?.forEach { (k, v) ->
+                it.putExtra(k, v)
-                    it.putExtra(k, v)
-                }
             }
+        }
         intent.component?.javaClass
         try {
-            when (action) {
+            when(action) {
                 Action.START_FOREGROUND -> {
                     context.startForegroundService(intent)
                 }
-
                 Action.START -> {
                     context.startService(intent)
                 }
-
                 Action.STOP -> context.startService(intent)
             }
-        } catch (e: Exception) {
+        } catch (e : Exception) {
             Timber.e(e.message)
         }
     }
 
-    fun startVpnService(
+    fun startVpnService(context : Context, tunnelConfig : String) {
-        context: Context,
-        tunnelConfig: String
-    ) {
         actionOnService(
             Action.START,
             context,
             WireGuardTunnelService::class.java,
-            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig)
+            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig))
-        )
     }
-
+    fun stopVpnService(context : Context) {
-    fun stopVpnService(context: Context) {
         actionOnService(
             Action.STOP,
             context,
@@ -77,68 +61,39 @@ object ServiceManager {
         )
     }
 
-    fun startVpnServiceForeground(
+    fun startVpnServiceForeground(context : Context, tunnelConfig : String) {
-        context: Context,
-        tunnelConfig: String
-    ) {
         actionOnService(
             Action.START_FOREGROUND,
             context,
             WireGuardTunnelService::class.java,
-            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig)
+            mapOf(context.getString(R.string.tunnel_extras_key) to tunnelConfig))
-        )
     }
 
-    private fun startWatcherServiceForeground(
+    private fun startWatcherServiceForeground(context : Context, tunnelConfig : String) {
-        context: Context,
-        tunnelConfig: String
-    ) {
         actionOnService(
-            Action.START,
+            Action.START, context,
-            context,
+            WireGuardConnectivityWatcherService::class.java, mapOf(context.
-            WireGuardConnectivityWatcherService::class.java,
+            getString(R.string.tunnel_extras_key) to
-            mapOf(
+                    tunnelConfig))
-                context
-                    .getString(R.string.tunnel_extras_key) to
-                        tunnelConfig
-            )
-        )
     }
 
-    fun startWatcherService(
+    fun startWatcherService(context : Context, tunnelConfig : String) {
-        context: Context,
-        tunnelConfig: String
-    ) {
         actionOnService(
-            Action.START,
+            Action.START, context,
-            context,
+            WireGuardConnectivityWatcherService::class.java, mapOf(context.
-            WireGuardConnectivityWatcherService::class.java,
+            getString(R.string.tunnel_extras_key) to
-            mapOf(
+                    tunnelConfig))
-                context
-                    .getString(R.string.tunnel_extras_key) to
-                        tunnelConfig
-            )
-        )
     }
 
-    fun stopWatcherService(context: Context) {
+    fun stopWatcherService(context : Context) {
         actionOnService(
-            Action.STOP,
+            Action.STOP, context,
-            context,
+            WireGuardConnectivityWatcherService::class.java)
-            WireGuardConnectivityWatcherService::class.java
-        )
     }
 
-    fun toggleWatcherServiceForeground(
+    fun toggleWatcherServiceForeground(context: Context, tunnelConfig : String) {
-        context: Context,
+        when(getServiceState( context,
-        tunnelConfig: String
+            WireGuardConnectivityWatcherService::class.java,)) {
-    ) {
-        when (
-            getServiceState(
-                context,
-                WireGuardConnectivityWatcherService::class.java
-            )
-        ) {
             ServiceState.STARTED -> stopWatcherService(context)
             ServiceState.STOPPED -> startWatcherServiceForeground(context, tunnelConfig)
         }

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

@@ -7,7 +7,6 @@ import android.content.Intent
 import android.os.Bundle
 import android.os.PowerManager
 import android.os.SystemClock
-import androidx.core.app.ServiceCompat
 import androidx.lifecycle.lifecycleScope
 import com.wireguard.android.backend.Tunnel
 import com.zaneschepke.wireguardautotunnel.Constants
@@ -22,16 +21,17 @@ import com.zaneschepke.wireguardautotunnel.service.network.WifiService
 import com.zaneschepke.wireguardautotunnel.service.notification.NotificationService
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import timber.log.Timber
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class WireGuardConnectivityWatcherService : ForegroundService() {
+
     private val foregroundId = 122
 
     @Inject
@@ -64,37 +64,30 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     private var wakeLock: PowerManager.WakeLock? = null
     private val tag = this.javaClass.name
 
+
     override fun onCreate() {
         super.onCreate()
         lifecycleScope.launch(Dispatchers.Main) {
-            try {
+            launchWatcherNotification()
-                launchWatcherNotification()
-            } catch (e: Exception) {
-                Timber.e("Failed to start watcher service, not enough permissions")
-            }
         }
     }
 
     override fun startService(extras: Bundle?) {
         super.startService(extras)
-        try {
+        launchWatcherNotification()
-            launchWatcherNotification()
+        val tunnelId = extras?.getString(getString(R.string.tunnel_extras_key))
-            val tunnelId = extras?.getString(getString(R.string.tunnel_extras_key))
+        if (tunnelId != null) {
-            if (tunnelId != null) {
+            this.tunnelConfig = tunnelId
-                this.tunnelConfig = tunnelId
+        }
-            }
+        // we need this lock so our service gets not affected by Doze Mode
-            // we need this lock so our service gets not affected by Doze Mode
+        lifecycleScope.launch {
-            lifecycleScope.launch {
+            initWakeLock()
-                initWakeLock()
+        }
-            }
+        cancelWatcherJob()
-            cancelWatcherJob()
+        if (this::tunnelConfig.isInitialized) {
-            if (this::tunnelConfig.isInitialized) {
+            startWatcherJob()
-                startWatcherJob()
+        } else {
-            } else {
+            stopService(extras)
-                stopService(extras)
-            }
-        } catch (e: Exception) {
-            Timber.e("Failed to launch watcher service, no permissions")
         }
     }
 
@@ -110,32 +103,23 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     }
 
     private fun launchWatcherNotification() {
-        val notification =
+        val notification = notificationService.createNotification(
-            notificationService.createNotification(
+            channelId = getString(R.string.watcher_channel_id),
-                channelId = getString(R.string.watcher_channel_id),
+            channelName = getString(R.string.watcher_channel_name),
-                channelName = getString(R.string.watcher_channel_name),
+            description = getString(R.string.watcher_notification_text),
-                description = getString(R.string.watcher_notification_text),
+            vibration = false
-                vibration = false
-            )
-        ServiceCompat.startForeground(
-            this,
-            foregroundId,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID
         )
+        super.startForeground(foregroundId, notification)
     }
 
-    // try to start task again if killed
+    //try to start task again if killed
     override fun onTaskRemoved(rootIntent: Intent) {
         Timber.d("Task Removed called")
         val restartServiceIntent = Intent(rootIntent)
-        val restartServicePendingIntent: PendingIntent =
+        val restartServicePendingIntent: PendingIntent = PendingIntent.getService(
-            PendingIntent.getService(
+            this, 1, restartServiceIntent,
-                this,
+            PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE
-                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
@@ -147,10 +131,9 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     }
 
     private suspend fun initWakeLock() {
-        val isBatterySaverOn =
+        val isBatterySaverOn = withContext(lifecycleScope.coroutineContext) {
-            withContext(lifecycleScope.coroutineContext) {
+            settingsRepo.getAll().firstOrNull()?.isBatterySaverEnabled ?: false
-                settingsRepo.getAll().firstOrNull()?.isBatterySaverEnabled ?: false
+        }
-            }
         wakeLock =
             (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
                 newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "$tag::lock").apply {
@@ -172,29 +155,28 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
     }
 
     private fun startWatcherJob() {
-        watcherJob =
+        watcherJob = lifecycleScope.launch(Dispatchers.IO) {
-            lifecycleScope.launch(Dispatchers.IO) {
+            val settings = settingsRepo.getAll()
-                val settings = settingsRepo.getAll()
+            if (settings.isNotEmpty()) {
-                if (settings.isNotEmpty()) {
+                setting = settings[0]
-                    setting = settings[0]
+            }
-                }
+            launch {
+                watchForWifiConnectivityChanges()
+            }
+            if (setting.isTunnelOnMobileDataEnabled) {
                 launch {
-                    watchForWifiConnectivityChanges()
+                    watchForMobileDataConnectivityChanges()
-                }
-                if (setting.isTunnelOnMobileDataEnabled) {
-                    launch {
-                        watchForMobileDataConnectivityChanges()
-                    }
-                }
-                if (setting.isTunnelOnEthernetEnabled) {
-                    launch {
-                        watchForEthernetConnectivityChanges()
-                    }
-                }
-                launch {
-                    manageVpn()
                 }
             }
+            if (setting.isTunnelOnEthernetEnabled) {
+                launch {
+                    watchForEthernetConnectivityChanges()
+                }
+            }
+            launch {
+                manageVpn()
+            }
+        }
     }
 
     private suspend fun watchForMobileDataConnectivityChanges() {
@@ -250,9 +232,7 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
                 is NetworkStatus.CapabilitiesChanged -> {
                     Timber.d("Wifi capabilities changed")
                     isWifiConnected = true
-                    val ssid = wifiService.getNetworkName(it.networkCapabilities) ?: ""
+                    currentNetworkSSID = wifiService.getNetworkName(it.networkCapabilities) ?: ""
-                    Timber.d("Detected SSID: $ssid")
-                    currentNetworkSSID = ssid
                 }
 
                 is NetworkStatus.Unavailable -> {
@@ -265,69 +245,36 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
 
     private suspend fun manageVpn() {
         while (true) {
-            when {
+            if (isEthernetConnected && setting.isTunnelOnEthernetEnabled && vpnService.getState() == Tunnel.State.DOWN) {
-                (
+                ServiceManager.startVpnService(this, tunnelConfig)
-                        (
+            }
-                                isEthernetConnected &&
+            if (!isEthernetConnected && setting.isTunnelOnMobileDataEnabled &&
-                                        setting.isTunnelOnEthernetEnabled &&
+                !isWifiConnected &&
-                                        vpnService.getState() == Tunnel.State.DOWN
+                isMobileDataConnected
-                                )
+                && vpnService.getState() == Tunnel.State.DOWN
-                        ) ->
+            ) {
-                    ServiceManager.startVpnService(this, tunnelConfig)
+                ServiceManager.startVpnService(this, tunnelConfig)
-
+            } else if (!isEthernetConnected && !setting.isTunnelOnMobileDataEnabled &&
-                (
+                !isWifiConnected &&
-                        !isEthernetConnected &&
+                vpnService.getState() == Tunnel.State.UP
-                                setting.isTunnelOnMobileDataEnabled &&
+            ) {
-                                !isWifiConnected &&
+                ServiceManager.stopVpnService(this)
-                                isMobileDataConnected &&
+            } else if (!isEthernetConnected && isWifiConnected &&
-                                vpnService.getState() == Tunnel.State.DOWN
+                !setting.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
-                        ) ->
+                setting.isTunnelOnWifiEnabled &&
-                    ServiceManager.startVpnService(this, tunnelConfig)
+                (vpnService.getState() != Tunnel.State.UP)
-
+            ) {
-                (
+                ServiceManager.startVpnService(this, tunnelConfig)
-                        !isEthernetConnected &&
+            } else if (!isEthernetConnected && (isWifiConnected &&
-                                !setting.isTunnelOnMobileDataEnabled &&
+                        setting.trustedNetworkSSIDs.contains(currentNetworkSSID)) &&
-                                !isWifiConnected &&
+                (vpnService.getState() == Tunnel.State.UP)
-                                vpnService.getState() == Tunnel.State.UP
+            ) {
-                        ) ->
+                ServiceManager.stopVpnService(this)
-                    ServiceManager.stopVpnService(this)
+            } else if (!isEthernetConnected && (isWifiConnected &&
-
+                        !setting.isTunnelOnWifiEnabled &&
-                (
+                (vpnService.getState() == Tunnel.State.UP)
-                        !isEthernetConnected && isWifiConnected &&
+            )) {
-                                !setting.trustedNetworkSSIDs.contains(currentNetworkSSID) &&
+                ServiceManager.stopVpnService(this)
-                                setting.isTunnelOnWifiEnabled &&
-                                (vpnService.getState() != Tunnel.State.UP)
-                        ) ->
-                    ServiceManager.startVpnService(this, tunnelConfig)
-
-                (
-                        !isEthernetConnected && (
-                                isWifiConnected &&
-                                        setting.trustedNetworkSSIDs.contains(currentNetworkSSID)
-                                ) &&
-                                (vpnService.getState() == Tunnel.State.UP)
-                        ) ->
-                    ServiceManager.stopVpnService(this)
-
-                (
-                        !isEthernetConnected && (
-                                isWifiConnected &&
-                                        !setting.isTunnelOnWifiEnabled &&
-                                        (vpnService.getState() == Tunnel.State.UP)
-                                )
-                        ) ->
-                    ServiceManager.stopVpnService(this)
-
-                (
-                        !isEthernetConnected && !isWifiConnected &&
-                                !isMobileDataConnected &&
-                                (vpnService.getState() == Tunnel.State.UP)
-                        ) ->
-                    ServiceManager.stopVpnService(this)
-
-                else -> {
-                    // Do nothing
-                }
             }
             delay(Constants.VPN_CONNECTIVITY_CHECK_INTERVAL)
         }

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

@@ -3,9 +3,7 @@ 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.zaneschepke.wireguardautotunnel.Constants
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.receiver.NotificationActionReceiver
 import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
@@ -14,28 +12,29 @@ import com.zaneschepke.wireguardautotunnel.service.notification.NotificationServ
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 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 settingsRepo: SettingsDoa
 
     @Inject
-    lateinit var notificationService: NotificationService
+    lateinit var notificationService : NotificationService
 
-    private lateinit var job: Job
+    private lateinit var job : Job
 
-    private var tunnelName: String = ""
+    private var tunnelName : String = ""
 
     override fun onCreate() {
         super.onCreate()
@@ -44,76 +43,69 @@ class WireGuardTunnelService : ForegroundService() {
         }
     }
 
-    override fun startService(extras: Bundle?) {
+    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) {
-                    if (tunnelConfigString != null) {
+                    try {
-                        try {
+                        val tunnelConfig = TunnelConfig.from(tunnelConfigString)
-                            val tunnelConfig = TunnelConfig.from(tunnelConfigString)
+                        tunnelName = tunnelConfig.name
+                        vpnService.startTunnel(tunnelConfig)
+                    } catch (e : Exception) {
+                        Timber.e("Problem starting tunnel: ${e.message}")
+                        stopService(extras)
+                    }
+                } else {
+                    Timber.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)
-                        } 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)
-                            }
                         }
                     }
                 }
-                launch {
+            }
-                    var didShowConnected = false
+            launch {
-                    var didShowFailedHandshakeNotification = false
+                var didShowConnected = false
-                    vpnService.handshakeStatus.collect {
+                var didShowFailedHandshakeNotification = false
-                        when (it) {
+                vpnService.handshakeStatus.collect {
-                            HandshakeStatus.NOT_STARTED -> {
+                    when(it) {
+                        HandshakeStatus.NOT_STARTED -> {
+                        }
+                        HandshakeStatus.NEVER_CONNECTED -> {
+                            if(!didShowFailedHandshakeNotification) {
+                                launchVpnConnectionFailedNotification(getString(R.string.initial_connection_failure_message))
+                                didShowFailedHandshakeNotification = true
+                                didShowConnected = false
                             }
-                            HandshakeStatus.NEVER_CONNECTED -> {
+                        }
-                                if (!didShowFailedHandshakeNotification) {
+                        HandshakeStatus.HEALTHY -> {
-                                    launchVpnConnectionFailedNotification(
+                            if(!didShowConnected) {
-                                        getString(R.string.initial_connection_failure_message)
+                                launchVpnConnectedNotification()
-                                    )
+                                didShowConnected = true
-                                    didShowFailedHandshakeNotification = true
-                                    didShowConnected = false
-                                }
                             }
-
+                        }
-                            HandshakeStatus.HEALTHY -> {
+                        HandshakeStatus.UNHEALTHY -> {
-                                if (!didShowConnected) {
+                            if(!didShowFailedHandshakeNotification) {
-                                    launchVpnConnectedNotification()
+                                launchVpnConnectionFailedNotification(getString(R.string.lost_connection_failure_message))
-                                    didShowConnected = true
+                                didShowFailedHandshakeNotification = true
-                                }
+                                didShowConnected = false
-                            }
-                            HandshakeStatus.STALE -> {}
-                            HandshakeStatus.UNHEALTHY -> {
-                                if (!didShowFailedHandshakeNotification) {
-                                    launchVpnConnectionFailedNotification(
-                                        getString(R.string.lost_connection_failure_message)
-                                    )
-                                    didShowFailedHandshakeNotification = true
-                                    didShowConnected = false
-                                }
                             }
                         }
                     }
                 }
             }
+        }
     }
 
-    override fun stopService(extras: Bundle?) {
+    override fun stopService(extras : Bundle?) {
         super.stopService(extras)
         lifecycleScope.launch(Dispatchers.IO) {
             vpnService.stopTunnel()
@@ -123,67 +115,50 @@ class WireGuardTunnelService : ForegroundService() {
     }
 
     private fun launchVpnConnectedNotification() {
-        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.tunnel_start_title),
-                title = getString(R.string.tunnel_start_title),
+            onGoing = false,
-                onGoing = false,
+            vibration = false,
-                vibration = false,
+            showTimestamp = true,
-                showTimestamp = true,
+            description = "${getString(R.string.tunnel_start_text)} $tunnelName"
-                description = "${getString(R.string.tunnel_start_text)} $tunnelName"
-            )
-        ServiceCompat.startForeground(
-            this,
-            foregroundId,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID
         )
-    }
-
-    private fun launchVpnStartingNotification() {
-        val notification =
-            notificationService.createNotification(
-                channelId = getString(R.string.vpn_channel_id),
-                channelName = getString(R.string.vpn_channel_name),
-                title = getString(R.string.vpn_starting),
-                onGoing = false,
-                vibration = false,
-                showTimestamp = true,
-                description = getString(R.string.attempt_connection)
-            )
-        ServiceCompat.startForeground(
-            this,
-            foregroundId,
-            notification,
-            Constants.SYSTEM_EXEMPT_SERVICE_TYPE_ID
-        )
-    }
-
-    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 launchVpnStartingNotification() {
+        val notification = notificationService.createNotification(
+            channelId = getString(R.string.vpn_channel_id),
+            channelName = getString(R.string.vpn_channel_name),
+            title = getString(R.string.vpn_starting),
+            onGoing = false,
+            vibration = false,
+            showTimestamp = true,
+            description = getString(R.string.attempt_connection)
+        )
+        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,82 +14,69 @@ 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
 
     private val wifiManager =
         context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
 
-    override val networkStatus =
+    override val networkStatus = callbackFlow {
-        callbackFlow {
+        val networkStatusCallback = when (Build.VERSION.SDK_INT) {
-            val networkStatusCallback =
+            in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
-                when (Build.VERSION.SDK_INT) {
+                object : ConnectivityManager.NetworkCallback(
-                    in Build.VERSION_CODES.S..Int.MAX_VALUE -> {
+                    FLAG_INCLUDE_LOCATION_INFO
-                        object : 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()
-                    .addTransportType(networkCapability)
-                    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
-                    .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
-                    .build()
-            connectivityManager.registerNetworkCallback(request, networkStatusCallback)
 
-            awaitClose {
+            else -> {
-                connectivityManager.unregisterNetworkCallback(networkStatusCallback)
+                object : ConnectivityManager.NetworkCallback() {
+
+                    override fun onAvailable(network: Network) {
+                        trySend(NetworkStatus.Available(network))
+                    }
+
+                    override fun onLost(network: Network) {
+                        trySend(NetworkStatus.Unavailable(network))
+                    }
+
+                    override fun onCapabilitiesChanged(
+                        network: Network,
+                        networkCapabilities: NetworkCapabilities
+                    ) {
+                        trySend(NetworkStatus.CapabilitiesChanged(network, networkCapabilities))
+                    }
+                }
             }
         }
+        val request = NetworkRequest.Builder()
+            .addTransportType(networkCapability)
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+            .build()
+        connectivityManager.registerNetworkCallback(request, networkStatusCallback)
+
+        awaitClose {
+            connectivityManager.unregisterNetworkCallback(networkStatusCallback)
+        }
+    }
+
 
     override fun getNetworkName(networkCapabilities: NetworkCapabilities): String? {
         var ssid: String? = getWifiNameFromCapabilities(networkCapabilities)
@@ -102,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) {
@@ -117,20 +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: suspend (
+    crossinline onCapabilitiesChanged: suspend (network : Network, networkCapabilities : NetworkCapabilities) -> Result,
-        network: Network,
+): Flow<Result> = map { status ->
-        networkCapabilities: NetworkCapabilities
+    when (status) {
-    ) -> Result
+        is NetworkStatus.Unavailable -> onUnavailable(status.network)
-): Flow<Result> =
+        is NetworkStatus.Available -> onAvailable(status.network)
-    map { status ->
+        is NetworkStatus.CapabilitiesChanged -> onCapabilitiesChanged(status.network, status.networkCapabilities)
-        when (status) {
-            is NetworkStatus.Unavailable -> onUnavailable(status.network)
-            is NetworkStatus.Available -> onAvailable(status.network)
-            is NetworkStatus.CapabilitiesChanged -> onCapabilitiesChanged(
-                status.network,
-                status.networkCapabilities
-            )
-        }
     }
+}

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

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

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

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

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

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

@@ -12,7 +12,7 @@ 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,

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

@@ -12,13 +12,9 @@ import com.zaneschepke.wireguardautotunnel.ui.MainActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
-class WireGuardNotification
+class WireGuardNotification @Inject constructor(@ApplicationContext private val context: Context) : NotificationService {
-@Inject
+
-constructor(
+    private val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-    @ApplicationContext private val context: Context
-) : NotificationService {
-    private val notificationManager =
-        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
     override fun createNotification(
         channelId: String,
@@ -33,19 +29,18 @@ constructor(
         onGoing: Boolean,
         lights: Boolean
     ): Notification {
-        val channel =
+        val channel = NotificationChannel(
-            NotificationChannel(
+            channelId,
-                channelId,
+            channelName,
-                channelName,
+            importance
-                importance
+        ).let {
-            ).let {
+            it.description = title
-                it.description = title
+            it.enableLights(lights)
-                it.enableLights(lights)
+            it.lightColor = Color.RED
-                it.lightColor = Color.RED
+            it.enableVibration(vibration)
-                it.enableVibration(vibration)
+            it.vibrationPattern = longArrayOf(100, 200, 300, 400, 500, 400, 300, 200, 400)
-                it.vibrationPattern = longArrayOf(100, 200, 300, 400, 500, 400, 300, 200, 400)
+            it
-                it
+        }
-            }
         notificationManager.createNotificationChannel(channel)
         val pendingIntent: PendingIntent =
             Intent(context, MainActivity::class.java).let { notificationIntent ->
@@ -63,15 +58,14 @@ constructor(
                 channelId
             )
         return builder.let {
-            if (action != null && actionText != null) {
+            if(action != null && actionText != null) {
-                // TODO find a not deprecated way to do this
+                //TODO find a not deprecated way to do this
                 it.addAction(
                     Notification.Action.Builder(0, actionText, action)
-                        .build()
+                        .build())
-                )
+                    it.setAutoCancel(true)
-                it.setAutoCancel(true)
             }
-            it.setContentTitle(title)
+                it.setContentTitle(title)
                 .setContentText(description)
                 .setContentIntent(pendingIntent)
                 .setOngoing(onGoing)

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

@@ -12,23 +12,24 @@ import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.foreground.WireGuardTunnelService
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelException
 import dagger.hilt.android.AndroidEntryPoint
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import timber.log.Timber
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class ShortcutsActivity : ComponentActivity() {
-    @Inject
-    lateinit var settingsRepo: SettingsDoa
 
     @Inject
-    lateinit var tunnelConfigRepo: TunnelConfigDao
+    lateinit var settingsRepo : SettingsDoa
 
-    private fun attemptWatcherServiceToggle(tunnelConfig: String) {
+    @Inject
+    lateinit var tunnelConfigRepo : TunnelConfigDao
+
+    private fun attemptWatcherServiceToggle(tunnelConfig : String) {
         lifecycleScope.launch(Dispatchers.Main) {
             val settings = getSettings()
-            if (settings.isAutoTunnelEnabled) {
+            if(settings.isAutoTunnelEnabled) {
                 ServiceManager.toggleWatcherServiceForeground(this@ShortcutsActivity, tunnelConfig)
             }
         }
@@ -36,36 +37,29 @@ class ShortcutsActivity : ComponentActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        if (intent.getStringExtra(CLASS_NAME_EXTRA_KEY)
+        if(intent.getStringExtra(CLASS_NAME_EXTRA_KEY)
-                .equals(WireGuardTunnelService::class.java.simpleName)
+            .equals(WireGuardTunnelService::class.java.simpleName)) {
-        ) {
             lifecycleScope.launch(Dispatchers.Main) {
                 val settings = getSettings()
-                if (settings.isShortcutsEnabled) {
+                if(settings.isShortcutsEnabled) {
                     try {
                         val tunnelName = intent.getStringExtra(TUNNEL_NAME_EXTRA_KEY)
-                        val tunnelConfig =
+                        val tunnelConfig = if(tunnelName != null) {
-                            if (tunnelName != null) {
+                            tunnelConfigRepo.getAll().firstOrNull { it.name == tunnelName }
-                                tunnelConfigRepo.getAll().firstOrNull { it.name == tunnelName }
+                        } else {
+                            if(settings.defaultTunnel == null) {
+                                tunnelConfigRepo.getAll().first()
                             } else {
-                                if (settings.defaultTunnel == null) {
+                                TunnelConfig.from(settings.defaultTunnel!!)
-                                    tunnelConfigRepo.getAll().first()
-                                } else {
-                                    TunnelConfig.from(settings.defaultTunnel!!)
-                                }
                             }
+                        }
                         tunnelConfig ?: return@launch
                         attemptWatcherServiceToggle(tunnelConfig.toString())
-                        when (intent.action) {
+                        when(intent.action){
-                            Action.STOP.name -> ServiceManager.stopVpnService(
+                            Action.STOP.name -> ServiceManager.stopVpnService(this@ShortcutsActivity)
-                                this@ShortcutsActivity
+                            Action.START.name -> ServiceManager.startVpnService(this@ShortcutsActivity, tunnelConfig.toString())
-                            )
-                            Action.START.name -> ServiceManager.startVpnService(
-                                this@ShortcutsActivity,
-                                tunnelConfig.toString()
-                            )
                         }
-                    } catch (e: Exception) {
+                    } catch (e : Exception) {
                         Timber.e(e.message)
                     }
                 }
@@ -74,7 +68,7 @@ class ShortcutsActivity : ComponentActivity() {
         finish()
     }
 
-    private suspend fun getSettings(): Settings {
+    private suspend fun getSettings() : Settings {
         val settings = settingsRepo.getAll()
         return if (settings.isNotEmpty()) {
             settings.first()
@@ -82,7 +76,6 @@ class ShortcutsActivity : ComponentActivity() {
             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/TunnelControlTile.kt

@@ -11,34 +11,34 @@ 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 javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
+import javax.inject.Inject
 
 @AndroidEntryPoint
 class TunnelControlTile : TileService() {
-    @Inject
-    lateinit var settingsRepo: SettingsDoa
 
     @Inject
-    lateinit var configRepo: TunnelConfigDao
+    lateinit var settingsRepo : SettingsDoa
 
     @Inject
-    lateinit var vpnService: VpnService
+    lateinit var configRepo : TunnelConfigDao
+
+    @Inject
+    lateinit var vpnService : VpnService
 
     private val scope = CoroutineScope(Dispatchers.Main)
 
-    private lateinit var job: Job
+    private lateinit var job : Job
 
     override fun onStartListening() {
-        job =
+        job = scope.launch {
-            scope.launch {
+            updateTileState()
-                updateTileState()
+        }
-            }
         super.onStartListening()
     }
 
@@ -58,18 +58,15 @@ class TunnelControlTile : TileService() {
             scope.launch {
                 try {
                     val tunnel = determineTileTunnel()
-                    if (tunnel != null) {
+                    if(tunnel != null) {
                         attemptWatcherServiceToggle(tunnel.toString())
-                        if (vpnService.getState() == Tunnel.State.UP) {
+                        if(vpnService.getState() == Tunnel.State.UP) {
                             ServiceManager.stopVpnService(this@TunnelControlTile)
                         } else {
-                            ServiceManager.startVpnServiceForeground(
+                            ServiceManager.startVpnServiceForeground(this@TunnelControlTile, tunnel.toString())
-                                this@TunnelControlTile,
-                                tunnel.toString()
-                            )
                         }
                     }
-                } catch (e: Exception) {
+                } catch (e : Exception) {
                     Timber.e(e.message)
                 } finally {
                     cancel()
@@ -78,38 +75,34 @@ class TunnelControlTile : TileService() {
         }
     }
 
-    private suspend fun determineTileTunnel(): TunnelConfig? {
+    private suspend fun determineTileTunnel() : TunnelConfig? {
-        var tunnelConfig: TunnelConfig? = null
+        var tunnelConfig : TunnelConfig? = null
         val settings = settingsRepo.getAll()
         if (settings.isNotEmpty()) {
             val setting = settings.first()
-            tunnelConfig =
+            tunnelConfig = if (setting.defaultTunnel != null) {
-                if (setting.defaultTunnel != null) {
+                TunnelConfig.from(setting.defaultTunnel!!)
-                    TunnelConfig.from(setting.defaultTunnel!!)
+            } else {
+                val configs = configRepo.getAll()
+                val config  = if(configs.isNotEmpty()) {
+                    configs.first()
                 } else {
-                    val configs = configRepo.getAll()
+                    null
-                    val config =
-                        if (configs.isNotEmpty()) {
-                            configs.first()
-                        } else {
-                            null
-                        }
-                    config
                 }
+                config
+            }
         }
         return tunnelConfig
     }
 
-    private fun attemptWatcherServiceToggle(tunnelConfig: String) {
+
+    private fun attemptWatcherServiceToggle(tunnelConfig : String) {
         scope.launch {
             val settings = settingsRepo.getAll()
             if (settings.isNotEmpty()) {
                 val setting = settings.first()
-                if (setting.isAutoTunnelEnabled) {
+                if(setting.isAutoTunnelEnabled) {
-                    ServiceManager.toggleWatcherServiceForeground(
+                    ServiceManager.toggleWatcherServiceForeground(this@TunnelControlTile, tunnelConfig)
-                        this@TunnelControlTile,
-                        tunnelConfig
-                    )
                 }
             }
         }
@@ -118,31 +111,27 @@ class TunnelControlTile : TileService() {
     private suspend fun updateTileState() {
         vpnService.state.collect {
             try {
-                when (it) {
+                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(
+                setTileDescription(config?.name ?: this.resources.getString(R.string.no_tunnel_available))
-                    config?.name ?: this.resources.getString(R.string.no_tunnel_available)
-                )
                 qsTile.updateTile()
-            } catch (e: Exception) {
+            } 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
         }
@@ -152,7 +141,7 @@ class TunnelControlTile : TileService() {
     }
 
     private fun cancelJob() {
-        if (this::job.isInitialized) {
+        if(this::job.isInitialized) {
             job.cancel()
         }
     }

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

@@ -2,16 +2,13 @@ package com.zaneschepke.wireguardautotunnel.service.tunnel
 
 enum class HandshakeStatus {
     HEALTHY,
-    STALE,
     UNHEALTHY,
     NEVER_CONNECTED,
-    NOT_STARTED
+    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

@@ -7,15 +7,12 @@ import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import kotlinx.coroutines.flow.SharedFlow
 
 interface VpnService : Tunnel {
-    suspend fun startTunnel(tunnelConfig: TunnelConfig): Tunnel.State
+    suspend fun startTunnel(tunnelConfig : TunnelConfig) : Tunnel.State
-
     suspend fun stopTunnel()
-
+    val state : SharedFlow<Tunnel.State>
-    val state: SharedFlow<Tunnel.State>
+    val tunnelName : SharedFlow<String>
-    val tunnelName: SharedFlow<String>
+    val statistics : SharedFlow<Statistics>
-    val statistics: SharedFlow<Statistics>
+    val lastHandshake : SharedFlow<Map<Key,Long>>
-    val lastHandshake: SharedFlow<Map<Key, Long>>
+    val handshakeStatus : SharedFlow<HandshakeStatus>
-    val handshakeStatus: SharedFlow<HandshakeStatus>
+    fun getState() : Tunnel.State
-
-    fun getState(): Tunnel.State
 }

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

@@ -4,15 +4,10 @@ import com.wireguard.android.backend.Backend
 import com.wireguard.android.backend.BackendException
 import com.wireguard.android.backend.Statistics
 import com.wireguard.android.backend.Tunnel
-import com.wireguard.config.Config
 import com.wireguard.crypto.Key
 import com.zaneschepke.wireguardautotunnel.Constants
-import com.zaneschepke.wireguardautotunnel.module.Kernel
-import com.zaneschepke.wireguardautotunnel.module.Userspace
-import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
 import com.zaneschepke.wireguardautotunnel.repository.model.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
-import javax.inject.Inject
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -25,28 +20,20 @@ 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 constructor(private val backend : Backend) : VpnService {
 
-class WireGuardTunnel
-@Inject
-constructor(
-    @Userspace private val userspaceBackend: Backend,
-    @Kernel private val kernelBackend: Backend,
-    private val settingsRepo: SettingsDoa
-) : VpnService {
     private val _tunnelName = MutableStateFlow("")
     override val tunnelName get() = _tunnelName.asStateFlow()
 
-    private val _state =
+    private val _state = MutableSharedFlow<Tunnel.State>(
-        MutableSharedFlow<Tunnel.State>(
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
-            onBufferOverflow = BufferOverflow.DROP_OLDEST,
+        replay = 1)
-            replay = 1
-        )
 
-    private val _handshakeStatus =
+    private val _handshakeStatus = MutableSharedFlow<HandshakeStatus>(replay = 1,
-        MutableSharedFlow<HandshakeStatus>(
+        onBufferOverflow = BufferOverflow.DROP_OLDEST)
-            replay = 1,
-            onBufferOverflow = BufferOverflow.DROP_OLDEST
-        )
     override val state get() = _state.asSharedFlow()
 
     private val _statistics = MutableSharedFlow<Statistics>(replay = 1)
@@ -60,56 +47,30 @@ constructor(
 
     private val scope = CoroutineScope(Dispatchers.IO)
 
-    private lateinit var statsJob: Job
+    private lateinit var statsJob : Job
 
-    private var config: Config? = null
 
-    private var backend: Backend = userspaceBackend
+    override suspend fun startTunnel(tunnelConfig: TunnelConfig) : Tunnel.State{
-
-    private var backendIsUserspace = true
-
-    init {
-        scope.launch {
-            settingsRepo.getAllFlow().collect {
-                val settings = it.first()
-                if (settings.isKernelEnabled && backendIsUserspace) {
-                    Timber.d("Setting kernel backend")
-                    backend = kernelBackend
-                    backendIsUserspace = false
-                } else if (!settings.isKernelEnabled && !backendIsUserspace) {
-                    Timber.d("Setting userspace backend")
-                    backend = userspaceBackend
-                    backendIsUserspace = true
-                }
-            }
-        }
-    }
-
-    override suspend fun startTunnel(tunnelConfig: TunnelConfig): Tunnel.State {
         return try {
             stopTunnelOnConfigChange(tunnelConfig)
             emitTunnelName(tunnelConfig.name)
-            config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
+            val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-            val state =
+            val state = backend.setState(
-                backend.setState(
+                this, Tunnel.State.UP, config)
-                    this,
-                    Tunnel.State.UP,
-                    config
-                )
             _state.emit(state)
             state
-        } catch (e: Exception) {
+        } catch (e : Exception) {
             Timber.e("Failed to start tunnel with error: ${e.message}")
             Tunnel.State.DOWN
         }
     }
 
-    private suspend fun emitTunnelName(name: String) {
+    private suspend fun emitTunnelName(name : String) {
         _tunnelName.emit(name)
     }
 
     private suspend fun stopTunnelOnConfigChange(tunnelConfig: TunnelConfig) {
-        if (getState() == Tunnel.State.UP && _tunnelName.value != tunnelConfig.name) {
+        if(getState() == Tunnel.State.UP && _tunnelName.value != tunnelConfig.name) {
             stopTunnel()
         }
     }
@@ -120,11 +81,11 @@ constructor(
 
     override suspend fun stopTunnel() {
         try {
-            if (getState() == Tunnel.State.UP) {
+            if(getState() == Tunnel.State.UP) {
                 val state = backend.setState(this, Tunnel.State.DOWN, null)
                 _state.emit(state)
             }
-        } catch (e: BackendException) {
+        } catch (e : BackendException) {
             Timber.e("Failed to stop tunnel with error: ${e.message}")
         }
     }
@@ -133,55 +94,49 @@ constructor(
         return backend.getState(this)
     }
 
-    override fun onStateChange(state: Tunnel.State) {
+    override fun onStateChange(state : Tunnel.State) {
         val tunnel = this
         _state.tryEmit(state)
-        if (state == Tunnel.State.UP) {
+        if(state == Tunnel.State.UP) {
-            statsJob =
+            statsJob = scope.launch {
-                scope.launch {
+                val handshakeMap = HashMap<Key, Long>()
-                    val handshakeMap = HashMap<Key, Long>()
+                var neverHadHandshakeCounter = 0
-                    var neverHadHandshakeCounter = 0
+                while (true) {
-                    while (true) {
+                    val statistics = backend.getStatistics(tunnel)
-                        val statistics = backend.getStatistics(tunnel)
+                    _statistics.emit(statistics)
-                        _statistics.emit(statistics)
+                    statistics.peers().forEach {
-                        statistics.peers().forEach { key ->
+                        val handshakeEpoch = statistics.peer(it)?.latestHandshakeEpochMillis ?: 0L
-                            val handshakeEpoch =
+                        handshakeMap[it] = handshakeEpoch
-                                statistics.peer(key)?.latestHandshakeEpochMillis ?: 0L
+                        if(handshakeEpoch == 0L) {
-                            handshakeMap[key] = handshakeEpoch
+                            if(neverHadHandshakeCounter >= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
-                            if (handshakeEpoch == 0L) {
+                                _handshakeStatus.emit(HandshakeStatus.NEVER_CONNECTED)
-                                if (neverHadHandshakeCounter >= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
+                            } else {
-                                    _handshakeStatus.emit(HandshakeStatus.NEVER_CONNECTED)
+                                _handshakeStatus.emit(HandshakeStatus.NOT_STARTED)
-                                } 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
                             }
-                            // TODO one day make each peer have their own dedicated status
+                            if(neverHadHandshakeCounter <= HandshakeStatus.NEVER_CONNECTED_TO_UNHEALTHY_TIME_LIMIT_SEC) {
-                            val lastHandshake = NumberUtils.getSecondsBetweenTimestampAndNow(
+                                neverHadHandshakeCounter += (1 * Constants.VPN_STATISTIC_CHECK_INTERVAL/1000).toInt()
-                                handshakeEpoch
-                            )
-                            if (lastHandshake != null) {
-                                if (lastHandshake >= HandshakeStatus.STALE_TIME_LIMIT_SEC) {
-                                    _handshakeStatus.emit(HandshakeStatus.STALE)
-                                } else {
-                                    _handshakeStatus.emit(HandshakeStatus.HEALTHY)
-                                }
                             }
+                            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)
                     }
+                    _lastHandshake.emit(handshakeMap)
+                    delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
                 }
+            }
         }
-        if (state == Tunnel.State.DOWN) {
+        if(state == Tunnel.State.DOWN) {
-            if (this::statsJob.isInitialized) {
+            if(this::statsJob.isInitialized) {
                 statsJob.cancel()
             }
             _handshakeStatus.tryEmit(HandshakeStatus.NOT_STARTED)
             _lastHandshake.tryEmit(emptyMap())
         }
     }
+
+
 }

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

@@ -1,8 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui
-
-import androidx.lifecycle.ViewModel
-import javax.inject.Inject
-
-class ActivityViewModel @Inject constructor() : ViewModel() {
-    // TODO move shared logic to shared viewmodel
-}

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

@@ -12,6 +12,7 @@ import androidx.activity.compose.setContent
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.animation.ExitTransition
+import androidx.compose.animation.ExperimentalAnimationApi
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.slideInHorizontally
@@ -58,14 +59,13 @@ import timber.log.Timber
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
-    @OptIn(
+
+    @OptIn(ExperimentalAnimationApi::class,
         ExperimentalPermissionsApi::class
     )
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContent {
-            // TODO move shared logic to shared viewmodel
-            // val sharedViewModel = hiltViewModel<ActivityViewModel>()
             val navController = rememberNavController()
             val focusRequester = remember { FocusRequester() }
 
@@ -84,86 +84,68 @@ class MainActivity : AppCompatActivity() {
                 }
 
                 var vpnIntent by remember { mutableStateOf(GoBackend.VpnService.prepare(this)) }
-                val vpnActivityResultState =
+                val vpnActivityResultState = rememberLauncherForActivityResult(
-                    rememberLauncherForActivityResult(
+                    ActivityResultContracts.StartActivityForResult(),
-                        ActivityResultContracts.StartActivityForResult(),
+                    onResult = {
-                        onResult = {
+                        val accepted = (it.resultCode == RESULT_OK)
-                            val accepted = (it.resultCode == RESULT_OK)
+                        if (accepted) {
-                            if (accepted) {
+                            vpnIntent = null
-                                vpnIntent = null
-                            }
                         }
-                    )
+                    })
                 LaunchedEffect(vpnIntent) {
                     if (vpnIntent != null) {
                         vpnActivityResultState.launch(vpnIntent)
-                    } else {
+                    } else requestNotificationPermission()
-                        requestNotificationPermission()
-                    }
                 }
 
-                fun showSnackBarMessage(message: String) {
+                fun showSnackBarMessage(message : String) {
                     lifecycleScope.launch(Dispatchers.Main) {
-                        val result =
+                        val result = snackbarHostState.showSnackbar(
-                            snackbarHostState.showSnackbar(
+                            message = message,
-                                message = message,
+                            actionLabel = applicationContext.getString(R.string.okay),
-                                actionLabel = applicationContext.getString(R.string.okay),
+                            duration = SnackbarDuration.Short,
-                                duration = SnackbarDuration.Short
+                        )
-                            )
                         when (result) {
-                            SnackbarResult.ActionPerformed -> {
+                            SnackbarResult.ActionPerformed -> { snackbarHostState.currentSnackbarData?.dismiss() }
-                                snackbarHostState.currentSnackbarData?.dismiss()
+                            SnackbarResult.Dismissed -> { snackbarHostState.currentSnackbarData?.dismiss() }
-                            }
-
-                            SnackbarResult.Dismissed -> {
-                                snackbarHostState.currentSnackbarData?.dismiss()
-                            }
                         }
                     }
                 }
 
-                Scaffold(
+                Scaffold(snackbarHost = {
-                    snackbarHost = {
                         SnackbarHost(snackbarHostState) { snackbarData: SnackbarData ->
                             CustomSnackBar(
                                 snackbarData.visuals.message,
                                 isRtl = false,
-                                containerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(
+                                containerColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
-                                    2.dp
-                                )
                             )
                         }
                     },
-                    modifier =
+                    modifier = Modifier.onKeyEvent {
-                    Modifier.onKeyEvent {
                         if (it.nativeKeyEvent.action == KeyEvent.ACTION_UP) {
                             when (it.nativeKeyEvent.keyCode) {
                                 KeyEvent.KEYCODE_DPAD_UP -> {
                                     try {
                                         focusRequester.requestFocus()
-                                    } catch (e: IllegalStateException) {
+                                    } catch(e : IllegalStateException) {
-                                        Timber.e(
+                                        Timber.e("No D-Pad focus request modifier added to element on screen")
-                                            "No D-Pad focus request modifier added to element on screen"
-                                        )
                                     }
                                     false
-                                }
+                                } else -> {
-
+                                   false
-                                else -> {
-                                    false
                                 }
                             }
                         } else {
                             false
                         }
                     },
-                    bottomBar =
+                    bottomBar = if (vpnIntent == null && notificationPermissionState.status.isGranted) {
-                    if (vpnIntent == null && notificationPermissionState.status.isGranted) {
                         { BottomNavBar(navController, Routes.navItems) }
                     } else {
                         {}
-                    }
+                    },
-                ) { padding ->
+                )
+                { padding ->
                     if (vpnIntent != null) {
                         PermissionRequestFailedScreen(
                             padding = padding,
@@ -180,11 +162,7 @@ class MainActivity : AppCompatActivity() {
                                 val intentSettings =
                                     Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                                 intentSettings.data =
-                                    Uri.fromParts(
+                                    Uri.fromParts(Constants.URI_PACKAGE_SCHEME, this.packageName, null)
-                                        Constants.URI_PACKAGE_SCHEME,
-                                        this.packageName,
-                                        null
-                                    )
                                 startActivity(intentSettings)
                             },
                             message = getString(R.string.notification_permission_required),
@@ -194,36 +172,23 @@ class MainActivity : AppCompatActivity() {
                     }
 
                     NavHost(navController, startDestination = Routes.Main.name) {
-                        composable(
+                        composable(Routes.Main.name, enterTransition = {
-                            Routes.Main.name,
+                            when (initialState.destination.route) {
-                            enterTransition = {
+                                Routes.Settings.name, Routes.Support.name ->
-                                when (initialState.destination.route) {
+                                    slideInHorizontally(
-                                    Routes.Settings.name, Routes.Support.name ->
+                                        initialOffsetX = { -Constants.SLIDE_IN_TRANSITION_OFFSET },
-                                        slideInHorizontally(
+                                        animationSpec = tween(Constants.SLIDE_IN_ANIMATION_DURATION)
-                                            initialOffsetX = {
+                                    )
-                                                -Constants.SLIDE_IN_TRANSITION_OFFSET
-                                            },
-                                            animationSpec = tween(
-                                                Constants.SLIDE_IN_ANIMATION_DURATION
-                                            )
-                                        )
 
-                                    else -> {
+                                else -> {
-                                        fadeIn(
+                                    fadeIn(animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION))
-                                            animationSpec = tween(
-                                                Constants.FADE_IN_ANIMATION_DURATION
-                                            )
-                                        )
-                                    }
                                 }
-                            },
-                            exitTransition = {
-                                ExitTransition.None
                             }
-                        ) {
+                        }, exitTransition = {
-                            MainScreen(padding = padding, showSnackbarMessage = { message ->
+                            ExitTransition.None
-                                showSnackBarMessage(message)
+                        }
-                            }, navController = navController)
+                            ) {
+                            MainScreen(padding = padding, showSnackbarMessage = { message -> showSnackBarMessage(message) }, navController = navController)
                         }
                         composable(Routes.Settings.name, enterTransition = {
                             when (initialState.destination.route) {
@@ -241,16 +206,10 @@ class MainActivity : AppCompatActivity() {
                                 }
 
                                 else -> {
-                                    fadeIn(
+                                    fadeIn(animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION))
-                                        animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION)
-                                    )
                                 }
                             }
-                        }) {
+                        }) { SettingsScreen(padding = padding, showSnackbarMessage = { message -> showSnackBarMessage(message) }, focusRequester = focusRequester) }
-                            SettingsScreen(padding = padding, showSnackbarMessage = { message ->
-                                showSnackBarMessage(message)
-                            }, focusRequester = focusRequester)
-                        }
                         composable(Routes.Support.name, enterTransition = {
                             when (initialState.destination.route) {
                                 Routes.Settings.name, Routes.Main.name ->
@@ -260,26 +219,16 @@ class MainActivity : AppCompatActivity() {
                                     )
 
                                 else -> {
-                                    fadeIn(
+                                    fadeIn(animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION))
-                                        animationSpec = tween(Constants.FADE_IN_ANIMATION_DURATION)
-                                    )
                                 }
                             }
-                        }) { SupportScreen(padding = padding, focusRequester = focusRequester) }
+                        }) { 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()) {
+                            if(!id.isNullOrBlank()) {
-                                ConfigScreen(
+                                ConfigScreen(navController = navController, id = id, showSnackbarMessage = { message -> showSnackBarMessage(message) }, focusRequester = focusRequester)}
-                                    navController = navController,
-                                    id = id,
-                                    showSnackbarMessage = { message ->
-                                        showSnackBarMessage(message)
-                                    },
-                                    focusRequester = focusRequester
-                                )
-                            }
                         }
                     }
                 }

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

@@ -10,27 +10,26 @@ enum class Routes {
     Main,
     Settings,
     Support,
-    Config
+    Config;
-    ;
+
 
     companion object {
-        val navItems =
+        val navItems = listOf(
-            listOf(
+            BottomNavItem(
-                BottomNavItem(
+                name = "Tunnels",
-                    name = "Tunnels",
+                route = Main.name,
-                    route = Main.name,
+                icon = Icons.Rounded.Home,
-                    icon = Icons.Rounded.Home
+            ),
-                ),
+            BottomNavItem(
-                BottomNavItem(
+                name = "Settings",
-                    name = "Settings",
+                route = Settings.name,
-                    route = Settings.name,
+                icon = Icons.Rounded.Settings,
-                    icon = Icons.Rounded.Settings
+            ),
-                ),
+            BottomNavItem(
-                BottomNavItem(
+                name = "Support",
-                    name = "Support",
+                route = Support.name,
-                    route = Support.name,
+                icon = Icons.Rounded.QuestionMark,
-                    icon = Icons.Rounded.QuestionMark
-                )
             )
+        )
     }
 }

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

@@ -1,10 +1,8 @@
 package com.zaneschepke.wireguardautotunnel.ui.common
 
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.IntrinsicSize
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
 import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.Icon
 import androidx.compose.material3.Text
@@ -13,28 +11,20 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextOverflow
 import com.zaneschepke.wireguardautotunnel.R
 
 @Composable
-fun ClickableIconButton(
+fun ClickableIconButton(onIconClick : () -> Unit, text : String, icon : ImageVector, enabled : Boolean) {
-    onIconClick: () -> Unit,
+    TextButton(onClick = {},
-    text: String,
-    icon: ImageVector,
-    enabled: Boolean
-) {
-    TextButton(
-        onClick = {},
         enabled = enabled
     ) {
-        Text(text, Modifier.weight(1f, false))
+        Text(text)
         Spacer(modifier = Modifier.size(ButtonDefaults.IconSpacing))
         Icon(
             imageVector = icon,
             contentDescription = stringResource(R.string.delete),
-            modifier =
+            modifier = Modifier.size(ButtonDefaults.IconSize).clickable {
-            Modifier.size(ButtonDefaults.IconSize).weight(1f, false).clickable {
+                if(enabled) {
-                if (enabled) {
                     onIconClick()
                 }
             }

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

@@ -16,21 +16,13 @@ import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.launch
 
 @Composable
-fun PermissionRequestFailedScreen(
+fun PermissionRequestFailedScreen(padding : PaddingValues, onRequestAgain : () -> Unit, message : String, buttonText : String ) {
-    padding: PaddingValues,
-    onRequestAgain: () -> Unit,
-    message: String,
-    buttonText: String
-) {
     val scope = rememberCoroutineScope()
-    Column(
+    Column(horizontalAlignment = Alignment.CenterHorizontally,
-        horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.Center,
-        modifier =
+        modifier = Modifier
-        Modifier
             .fillMaxSize()
-            .padding(padding)
+            .padding(padding)) {
-    ) {
         Text(message, textAlign = TextAlign.Center, modifier = Modifier.padding(15.dp))
         Button(onClick = {
             scope.launch {

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

@@ -23,18 +23,12 @@ import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 
 @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(
@@ -48,27 +42,22 @@ fun RowListItem(
     ) {
         Column {
             Row(
-                modifier =
+                modifier = Modifier
-                Modifier
                     .fillMaxWidth()
                     .padding(horizontal = 14.dp, vertical = 5.dp),
                 verticalAlignment = Alignment.CenterVertically,
                 horizontalArrangement = Arrangement.SpaceBetween
             ) {
-                Row(
+                Row(verticalAlignment = Alignment.CenterVertically,) {
-                    verticalAlignment = Alignment.CenterVertically,
-                    modifier = Modifier.fillMaxWidth(.60f)
-                ) {
                     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,
@@ -77,11 +66,9 @@ fun RowListItem(
                         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) }
@@ -62,18 +64,16 @@ fun SearchBar(onQuery: (queryString: String) -> Unit) {
             }
         },
         maxLines = 1,
-        colors =
+        colors = TextFieldDefaults.colors(
-        TextFieldDefaults.colors(
             focusedContainerColor = Color.Transparent,
             unfocusedContainerColor = Color.Transparent,
-            disabledContainerColor = Color.Transparent
+            disabledContainerColor = Color.Transparent,
         ),
         placeholder = { Text(text = stringResource(R.string.hint_search_packages)) },
         textStyle = MaterialTheme.typography.bodySmall,
         singleLine = true,
         keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Text),
-        modifier =
+        modifier = Modifier
-        Modifier
             .fillMaxWidth()
             .background(color = MaterialTheme.colorScheme.background, shape = RectangleShape)
     )

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

@@ -10,15 +10,9 @@ 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,
@@ -30,11 +24,10 @@ fun ConfigurationTextBox(
         placeholder = {
             Text(hint)
         },
-        keyboardOptions =
+        keyboardOptions = KeyboardOptions(
-        KeyboardOptions(
             capitalization = KeyboardCapitalization.None,
             imeAction = ImeAction.Done
         ),
-        keyboardActions = keyboardActions
+        keyboardActions = keyboardActions,
     )
 }

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

@@ -12,17 +12,10 @@ import androidx.compose.ui.Modifier
 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 = Modifier
-        Modifier
             .fillMaxWidth()
             .padding(padding),
         verticalAlignment = Alignment.CenterVertically,

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

@@ -11,14 +11,12 @@ import androidx.navigation.NavController
 import androidx.navigation.compose.currentBackStackEntryAsState
 
 @Composable
-fun BottomNavBar(
+fun BottomNavBar(navController : NavController, bottomNavItems : List<BottomNavItem>) {
-    navController: NavController,
+
-    bottomNavItems: List<BottomNavItem>
-) {
     val backStackEntry = navController.currentBackStackEntryAsState()
 
     NavigationBar(
-        containerColor = MaterialTheme.colorScheme.background
+        containerColor = MaterialTheme.colorScheme.background,
     ) {
         bottomNavItems.forEach { item ->
             val selected = item.route == backStackEntry.value?.destination?.route
@@ -29,13 +27,13 @@ fun BottomNavBar(
                 label = {
                     Text(
                         text = item.name,
-                        fontWeight = FontWeight.SemiBold
+                        fontWeight = FontWeight.SemiBold,
                     )
                 },
                 icon = {
                     Icon(
                         imageVector = item.icon,
-                        contentDescription = "${item.name} Icon"
+                        contentDescription = "${item.name} Icon",
                     )
                 }
             )

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

@@ -11,87 +11,69 @@ import androidx.core.content.ContextCompat
 import androidx.fragment.app.FragmentActivity
 
 @Composable
-fun AuthorizationPrompt(
+fun AuthorizationPrompt(onSuccess : () -> Unit, onFailure : () -> Unit, onError : (String) -> Unit) {
-    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 =
+    val isBiometricAvailable = remember {
-        remember {
+        when(bio){
-            when (bio) {
+            BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
-                BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> {
+                onError("Biometrics not available")
-                    onError("Biometrics not available")
+                false
-                    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
             }
+            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(
+                    super.onAuthenticationError(errorCode, errString)
-                        errorCode: Int,
+                    onFailure()
-                        errString: CharSequence
-                    ) {
-                        super.onAuthenticationError(errorCode, errString)
-                        onFailure()
-                    }
-
-                    override fun onAuthenticationSucceeded(
-                        result: BiometricPrompt.AuthenticationResult
-                    ) {
-                        super.onAuthenticationSucceeded(result)
-                        onSuccess()
-                    }
-
-                    override fun onAuthenticationFailed() {
-                        super.onAuthenticationFailed()
-                        onFailure()
-                    }
                 }
-            )
+
+                override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) {
+                    super.onAuthenticationSucceeded(result)
+                    onSuccess()
+                }
+
+                override fun onAuthenticationFailed() {
+                    super.onAuthenticationFailed()
+                    onFailure()
+                }
+            }
+        )
         biometricPrompt.authenticate(promptInfo)
     }
 }

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

@@ -34,14 +34,11 @@ fun CustomSnackBar(
     containerColor: Color = MaterialTheme.colorScheme.surface
 ) {
     val context = LocalContext.current
-    Snackbar(
+    Snackbar(containerColor = containerColor,
-        containerColor = containerColor,
+        modifier = Modifier.fillMaxWidth(
-        modifier =
+            if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) 1/3f else 2/3f).padding(bottom = 100.dp),
-        Modifier.fillMaxWidth(
-            if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) 1 / 3f else 2 / 3f
-        ).padding(bottom = 100.dp),
         shape = RoundedCornerShape(16.dp)
-    ) {
+        ) {
         CompositionLocalProvider(
             LocalLayoutDirection provides
                     if (isRtl) LayoutDirection.Rtl else LayoutDirection.Ltr

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

@@ -12,10 +12,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 
 @Composable
-fun SectionTitle(
+fun SectionTitle(title : String, padding : Dp) {
-    title: String,
-    padding: Dp
-) {
     Text(
         title,
         textAlign = TextAlign.Center,

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 = if (i.listenPort.isPresent) {
+                listenPort = if(i.listenPort.isPresent) i.listenPort.get().toString().trim() else "",
-                    i.listenPort.get().toString()
+                mtu = if(i.mtu.isPresent) i.mtu.get().toString().trim() else ""
-                    .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,47 +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 = if (peer.preSharedKey.isPresent) {
+                preSharedKey = if(peer.preSharedKey.isPresent) peer.preSharedKey.get().toBase64().trim() else "",
-                    peer.preSharedKey.get().toBase64()
+                persistentKeepalive = if(peer.persistentKeepalive.isPresent) peer.persistentKeepalive.get().toString().trim() else "",
-                    .trim()
+                endpoint = if(peer.endpoint.isPresent) peer.endpoint.get().toString().trim() else "",
-                } else {
-                    ""
-                },
-                persistentKeepalive = if (peer.persistentKeepalive.isPresent) {
-                    peer.persistentKeepalive.get()
-                    .toString().trim()
-                } else {
-                    ""
-                },
-                endpoint = if (peer.endpoint.isPresent) {
-                    peer.endpoint.get().toString()
-                    .trim()
-                } else {
-                    ""
-                },
                 allowedIps = peer.allowedIps.joinToString(", ").trim()
             )
         }
-
+        val IPV4_PUBLIC_NETWORKS = setOf(
-        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", "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",
+            "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",
-                "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",
+            "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",
-                "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",
+            "192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10",
-                "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",
+            "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"
-                "192.170.0.0/15", "192.172.0.0/14", "192.176.0.0/12", "192.192.0.0/10",
+        )
-                "193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6", "200.0.0.0/5", "208.0.0.0/4"
-            )
         val IPV4_WILDCARD = setOf("0.0.0.0/0")
     }
 }

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

@@ -86,9 +86,7 @@ import kotlinx.coroutines.launch
 import timber.log.Timber
 
 @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
-@OptIn(
+@OptIn(ExperimentalComposeUiApi::class, ExperimentalMaterial3Api::class,
-    ExperimentalComposeUiApi::class,
-    ExperimentalMaterial3Api::class,
     ExperimentalFoundationApi::class
 )
 @Composable
@@ -99,11 +97,13 @@ fun ConfigScreen(
     showSnackbarMessage: (String) -> Unit,
     id: String
 ) {
+
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
     val clipboardManager: ClipboardManager = LocalClipboardManager.current
     val keyboardController = LocalSoftwareKeyboardController.current
 
+
     val tunnel by viewModel.tunnel.collectAsStateWithLifecycle(null)
     val tunnelName = viewModel.tunnelName.collectAsStateWithLifecycle()
     val packages by viewModel.packages.collectAsStateWithLifecycle()
@@ -115,25 +115,22 @@ fun ConfigScreen(
     var showApplicationsDialog by remember { mutableStateOf(false) }
     var showAuthPrompt by remember { mutableStateOf(false) }
     var isAuthenticated by remember { mutableStateOf(false) }
-    val baseTextBoxModifier =
+    val baseTextBoxModifier = Modifier.onFocusChanged {
-        Modifier.onFocusChanged {
+        if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-            if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+            keyboardController?.hide()
-                keyboardController?.hide()
-            }
         }
+    }
 
-    val keyboardActions =
+    val keyboardActions = KeyboardActions(
-        KeyboardActions(
+        onDone = {
-            onDone = {
+            keyboardController?.hide()
-                keyboardController?.hide()
+        }
-            }
+    )
-        )
 
-    val keyboardOptions =
+    val keyboardOptions = KeyboardOptions(
-        KeyboardOptions(
+        capitalization = KeyboardCapitalization.None,
-            capitalization = KeyboardCapitalization.None,
+        imeAction = ImeAction.Done
-            imeAction = ImeAction.Done
+    )
-        )
 
     val fillMaxHeight = .85f
     val fillMaxWidth = .85f
@@ -143,7 +140,7 @@ fun ConfigScreen(
         scope.launch(Dispatchers.IO) {
             try {
                 viewModel.onScreenLoad(id)
-            } catch (e: Exception) {
+            } catch (e : Exception) {
                 showSnackbarMessage(e.message!!)
                 navController.navigate(Routes.Main.name)
             }
@@ -152,35 +149,29 @@ fun ConfigScreen(
 
     val applicationButtonText = {
         "Tunneling apps: " +
-                if (isAllApplicationsEnabled) {
+                if (isAllApplicationsEnabled) "all"
-                    "all"
+                else "${checkedPackages.size} " + (if (include) "included" else "excluded")
-                } else {
+
-                    "${checkedPackages.size} " + (if (include) "included" else "excluded")
-                }
     }
 
-    if (showAuthPrompt) {
+    if(showAuthPrompt) {
-        AuthorizationPrompt(
+        AuthorizationPrompt(onSuccess = {
-            onSuccess = {
+            showAuthPrompt = false
-                showAuthPrompt = false
+            isAuthenticated = true },
-                isAuthenticated = true
-            },
             onError = { error ->
                 showSnackbarMessage(error)
                 showAuthPrompt = false
-            },
+                      },
             onFailure = {
                 showAuthPrompt = false
                 showSnackbarMessage(context.getString(R.string.authentication_failed))
-            }
+            })
-        )
     }
 
     if (showApplicationsDialog) {
-        val sortedPackages =
+        val sortedPackages = remember(packages) {
-            remember(packages) {
+            packages.sortedBy { viewModel.getPackageLabel(it) }
-                packages.sortedBy { viewModel.getPackageLabel(it) }
+        }
-            }
         AlertDialog(onDismissRequest = {
             showApplicationsDialog = false
         }) {
@@ -189,8 +180,7 @@ fun ConfigScreen(
                 shadowElevation = 2.dp,
                 shape = RoundedCornerShape(12.dp),
                 color = MaterialTheme.colorScheme.surface,
-                modifier =
+                modifier = Modifier
-                Modifier
                     .fillMaxWidth()
                     .fillMaxHeight(if (isAllApplicationsEnabled) 1 / 5f else 4 / 5f)
             ) {
@@ -198,8 +188,7 @@ fun ConfigScreen(
                     modifier = Modifier.fillMaxWidth()
                 ) {
                     Row(
-                        modifier =
+                        modifier = Modifier
-                        Modifier
                             .fillMaxWidth()
                             .padding(horizontal = 20.dp, vertical = 7.dp),
                         verticalAlignment = Alignment.CenterVertically,
@@ -215,8 +204,7 @@ fun ConfigScreen(
                     }
                     if (!isAllApplicationsEnabled) {
                         Row(
-                            modifier =
+                            modifier = Modifier
-                            Modifier
                                 .fillMaxWidth()
                                 .padding(
                                     horizontal = 20.dp,
@@ -251,8 +239,7 @@ fun ConfigScreen(
                             }
                         }
                         Row(
-                            modifier =
+                            modifier = Modifier
-                            Modifier
                                 .fillMaxWidth()
                                 .padding(
                                     horizontal = 20.dp,
@@ -267,25 +254,21 @@ fun ConfigScreen(
                         LazyColumn(
                             horizontalAlignment = Alignment.Start,
                             verticalArrangement = Arrangement.Top,
-                            modifier =
+                            modifier = Modifier
-                            Modifier
                                 .fillMaxHeight(4 / 5f)
                         ) {
                             items(
                                 sortedPackages,
-                                key = { it.packageName }
+                                key = { it.packageName }) { pack ->
-                            ) { pack ->
                                 Row(
                                     verticalAlignment = Alignment.CenterVertically,
                                     horizontalArrangement = Arrangement.SpaceBetween,
-                                    modifier =
+                                    modifier = Modifier
-                                    Modifier
                                         .fillMaxSize()
                                         .padding(5.dp)
                                 ) {
                                     Row(
-                                        modifier =
+                                        modifier = Modifier.fillMaxWidth(
-                                        Modifier.fillMaxWidth(
                                             fillMaxWidth
                                         )
                                     ) {
@@ -295,13 +278,11 @@ fun ConfigScreen(
                                             )
                                         if (drawable != null) {
                                             Image(
-                                                painter =
+                                                painter = DrawablePainter(
-                                                DrawablePainter(
                                                     drawable
                                                 ),
                                                 stringResource(id = R.string.icon),
-                                                modifier =
+                                                modifier = Modifier.size(
-                                                Modifier.size(
                                                     50.dp,
                                                     50.dp
                                                 )
@@ -310,8 +291,7 @@ fun ConfigScreen(
                                             Icon(
                                                 Icons.Rounded.Android,
                                                 stringResource(id = R.string.edit),
-                                                modifier =
+                                                modifier = Modifier.size(
-                                                Modifier.size(
                                                     50.dp,
                                                     50.dp
                                                 )
@@ -326,15 +306,11 @@ fun ConfigScreen(
                                         modifier = Modifier.fillMaxSize(),
                                         checked = (checkedPackages.contains(pack.packageName)),
                                         onCheckedChange = {
-                                            if (it) {
+                                            if (it) viewModel.onAddCheckedPackage(
-                                                viewModel.onAddCheckedPackage(
+                                                pack.packageName
-                                                    pack.packageName
+                                            ) else viewModel.onRemoveCheckedPackage(
-                                                )
+                                                pack.packageName
-                                            } else {
+                                            )
-                                                viewModel.onRemoveCheckedPackage(
-                                                    pack.packageName
-                                                )
-                                            }
                                         }
                                     )
                                 }
@@ -343,8 +319,7 @@ fun ConfigScreen(
                     }
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
-                        modifier =
+                        modifier = Modifier
-                        Modifier
                             .fillMaxSize()
                             .padding(top = 5.dp),
                         horizontalArrangement = Arrangement.Center
@@ -352,8 +327,7 @@ fun ConfigScreen(
                         TextButton(
                             onClick = {
                                 showApplicationsDialog = false
-                            }
+                            }) {
-                        ) {
                             Text(stringResource(R.string.done))
                         }
                     }
@@ -362,6 +336,7 @@ fun ConfigScreen(
         }
     }
 
+
     if (tunnel != null) {
         Scaffold(
             floatingActionButtonPosition = FabPosition.End,
@@ -370,43 +345,37 @@ fun ConfigScreen(
                 val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
                 var fobColor by remember { mutableStateOf(secondaryColor) }
                 FloatingActionButton(
-                    modifier =
+                    modifier = Modifier.padding(bottom = 90.dp).onFocusChanged {
-                    Modifier.padding(bottom = 90.dp).onFocusChanged {
+                        if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                        if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                            fobColor = if (it.isFocused) hoverColor else secondaryColor }
-                            fobColor = if (it.isFocused) hoverColor else secondaryColor
-                        }
                     },
                     onClick = {
                         scope.launch {
                             try {
                                 viewModel.onSaveAllChanges()
                                 navController.navigate(Routes.Main.name)
-                                showSnackbarMessage(
+                                showSnackbarMessage(context.resources.getString(R.string.config_changes_saved))
-                                    context.resources.getString(R.string.config_changes_saved)
+                            } catch (e : Exception) {
-                                )
-                            } catch (e: Exception) {
                                 Timber.e(e.message)
                                 showSnackbarMessage(e.message!!)
                             }
                         }
                     },
                     containerColor = fobColor,
-                    shape = RoundedCornerShape(16.dp)
+                    shape = RoundedCornerShape(16.dp),
                 ) {
                     Icon(
                         imageVector = Icons.Rounded.Save,
                         contentDescription = stringResource(id = R.string.save_changes),
-                        tint = Color.DarkGray
+                        tint = Color.DarkGray,
                     )
                 }
-            }
+            }) {
-        ) {
             Column {
                 Column(
                     horizontalAlignment = Alignment.CenterHorizontally,
                     verticalArrangement = Arrangement.Top,
-                    modifier =
+                    modifier = Modifier
-                    Modifier
                         .verticalScroll(rememberScrollState())
                         .weight(1f, true)
                         .fillMaxSize()
@@ -416,29 +385,21 @@ fun ConfigScreen(
                         shadowElevation = 2.dp,
                         shape = RoundedCornerShape(12.dp),
                         color = MaterialTheme.colorScheme.surface,
-                        modifier =
+                        modifier = (if (WireGuardAutoTunnel.isRunningOnAndroidTv(context))
-                        (
+                            Modifier
-                                if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                                .fillMaxHeight(fillMaxHeight)
-                                    Modifier
+                                .fillMaxWidth(fillMaxWidth)
-                                        .fillMaxHeight(fillMaxHeight)
+                        else Modifier.fillMaxWidth(fillMaxWidth)).padding(
-                                        .fillMaxWidth(fillMaxWidth)
+                            top = 50.dp,
-                                } else {
+                            bottom = 10.dp
-                                    Modifier.fillMaxWidth(fillMaxWidth)
+                        )
-                                }
-                                ).padding(
-                                top = 50.dp,
-                                bottom = 10.dp
-                            )
                     ) {
                         Column(
                             horizontalAlignment = Alignment.Start,
                             verticalArrangement = Arrangement.Top,
                             modifier = Modifier.padding(15.dp).focusGroup()
                         ) {
-                            SectionTitle(
+                            SectionTitle(stringResource(R.string.interface_), padding = screenPadding)
-                                stringResource(R.string.interface_),
-                                padding = screenPadding
-                            )
                             ConfigurationTextBox(
                                 value = tunnelName.value,
                                 onValueChange = { value ->
@@ -447,17 +408,14 @@ fun ConfigScreen(
                                 keyboardActions = keyboardActions,
                                 label = stringResource(R.string.name),
                                 hint = stringResource(R.string.tunnel_name).lowercase(),
-                                modifier = baseTextBoxModifier.fillMaxWidth().focusRequester(
+                                modifier = baseTextBoxModifier.fillMaxWidth().focusRequester(focusRequester)
-                                    focusRequester
-                                )
                             )
                             OutlinedTextField(
-                                modifier =
+                                modifier = baseTextBoxModifier.fillMaxWidth().clickable {
-                                baseTextBoxModifier.fillMaxWidth().clickable {
                                     showAuthPrompt = true
                                 },
                                 value = proxyInterface.privateKey,
-                                visualTransformation = if ((id == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated) VisualTransformation.None else PasswordVisualTransformation(),
+                                visualTransformation = if((id == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated) VisualTransformation.None else PasswordVisualTransformation(),
                                 enabled = (id == Constants.MANUAL_TUNNEL_CONFIG_ID) || isAuthenticated,
                                 onValueChange = { value ->
                                     viewModel.onPrivateKeyChange(value)
@@ -467,8 +425,7 @@ fun ConfigScreen(
                                         modifier = Modifier.focusRequester(FocusRequester.Default),
                                         onClick = {
                                             viewModel.generateKeyPair()
-                                        }
+                                        }) {
-                                    ) {
                                         Icon(
                                             Icons.Rounded.Refresh,
                                             stringResource(R.string.rotate_keys),
@@ -483,9 +440,7 @@ fun ConfigScreen(
                                 keyboardActions = keyboardActions
                             )
                             OutlinedTextField(
-                                modifier = baseTextBoxModifier.fillMaxWidth().focusRequester(
+                                modifier = baseTextBoxModifier.fillMaxWidth().focusRequester(FocusRequester.Default),
-                                    FocusRequester.Default
-                                ),
                                 value = proxyInterface.publicKey,
                                 enabled = false,
                                 onValueChange = {},
@@ -493,11 +448,8 @@ fun ConfigScreen(
                                     IconButton(
                                         modifier = Modifier.focusRequester(FocusRequester.Default),
                                         onClick = {
-                                            clipboardManager.setText(
+                                            clipboardManager.setText(AnnotatedString(proxyInterface.publicKey))
-                                                AnnotatedString(proxyInterface.publicKey)
+                                        }) {
-                                            )
-                                        }
-                                    ) {
                                         Icon(
                                             Icons.Rounded.ContentCopy,
                                             stringResource(R.string.copy_public_key),
@@ -520,15 +472,14 @@ fun ConfigScreen(
                                     keyboardActions = keyboardActions,
                                     label = stringResource(R.string.addresses),
                                     hint = stringResource(R.string.comma_separated_list),
-                                    modifier =
+                                    modifier = baseTextBoxModifier
-                                    baseTextBoxModifier
                                         .fillMaxWidth(3 / 5f)
                                         .padding(end = 5.dp)
                                 )
                                 ConfigurationTextBox(
                                     value = proxyInterface.listenPort,
                                     onValueChange = { value -> viewModel.onListenPortChanged(value) },
-                                    keyboardActions = keyboardActions,
+                                    keyboardActions =  keyboardActions,
                                     label = stringResource(R.string.listen_port),
                                     hint = stringResource(R.string.random),
                                     modifier = baseTextBoxModifier.width(IntrinsicSize.Min)
@@ -541,8 +492,7 @@ fun ConfigScreen(
                                     keyboardActions = keyboardActions,
                                     label = stringResource(R.string.dns_servers),
                                     hint = stringResource(R.string.comma_separated_list),
-                                    modifier =
+                                    modifier = baseTextBoxModifier
-                                    baseTextBoxModifier
                                         .fillMaxWidth(3 / 5f)
                                         .padding(end = 5.dp)
                                 )
@@ -557,8 +507,7 @@ fun ConfigScreen(
                             }
                             Row(
                                 verticalAlignment = Alignment.CenterVertically,
-                                modifier =
+                                modifier = Modifier
-                                Modifier
                                     .fillMaxSize()
                                     .padding(top = 5.dp),
                                 horizontalArrangement = Arrangement.Center
@@ -566,8 +515,7 @@ fun ConfigScreen(
                                 TextButton(
                                     onClick = {
                                         showApplicationsDialog = true
-                                    }
+                                    }) {
-                                ) {
                                     Text(applicationButtonText())
                                 }
                             }
@@ -579,40 +527,30 @@ fun ConfigScreen(
                             shadowElevation = 2.dp,
                             shape = RoundedCornerShape(12.dp),
                             color = MaterialTheme.colorScheme.surface,
-                            modifier =
+                            modifier = (if (WireGuardAutoTunnel.isRunningOnAndroidTv(context))
-                            (
+                                Modifier
-                                    if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                                    .fillMaxHeight(fillMaxHeight)
-                                        Modifier
+                                    .fillMaxWidth(fillMaxWidth)
-                                            .fillMaxHeight(fillMaxHeight)
+                            else Modifier.fillMaxWidth(fillMaxWidth)).padding(
-                                            .fillMaxWidth(fillMaxWidth)
+                                top = 10.dp,
-                                    } else {
+                                bottom = 10.dp
-                                        Modifier.fillMaxWidth(fillMaxWidth)
+                            )
-                                    }
-                                    ).padding(
-                                    top = 10.dp,
-                                    bottom = 10.dp
-                                )
                         ) {
                             Column(
                                 horizontalAlignment = Alignment.Start,
                                 verticalArrangement = Arrangement.Top,
-                                modifier =
+                                modifier = Modifier
-                                Modifier
                                     .padding(horizontal = 15.dp)
                                     .padding(bottom = 10.dp)
                             ) {
                                 Row(
                                     horizontalArrangement = Arrangement.SpaceBetween,
                                     verticalAlignment = Alignment.CenterVertically,
-                                    modifier =
+                                    modifier = Modifier
-                                    Modifier
                                         .fillMaxWidth()
                                         .padding(horizontal = 5.dp)
                                 ) {
-                                    SectionTitle(
+                                    SectionTitle(stringResource(R.string.peer), padding = screenPadding)
-                                        stringResource(R.string.peer),
-                                        padding = screenPadding
-                                    )
                                     IconButton(
                                         onClick = {
                                             viewModel.onDeletePeer(index)
@@ -655,17 +593,10 @@ fun ConfigScreen(
                                     onValueChange = { value ->
                                         viewModel.onPersistentKeepaliveChanged(index, value)
                                     },
-                                    trailingIcon = {
+                                    trailingIcon = { Text(stringResource(R.string.seconds), modifier = Modifier.padding(end = 10.dp)) },
-                                        Text(
-                                            stringResource(R.string.seconds),
-                                            modifier = Modifier.padding(end = 10.dp)
-                                        )
-                                    },
                                     label = { Text(stringResource(R.string.persistent_keepalive)) },
                                     singleLine = true,
-                                    placeholder = {
+                                    placeholder = { Text(stringResource(R.string.optional_no_recommend)) },
-                                        Text(stringResource(R.string.optional_no_recommend))
-                                    },
                                     keyboardOptions = keyboardOptions,
                                     keyboardActions = keyboardActions
                                 )
@@ -694,9 +625,7 @@ fun ConfigScreen(
                                     },
                                     label = { Text(stringResource(R.string.allowed_ips)) },
                                     singleLine = true,
-                                    placeholder = {
+                                    placeholder = { Text(stringResource(R.string.comma_separated_list)) },
-                                        Text(stringResource(R.string.comma_separated_list))
-                                    },
                                     keyboardOptions = keyboardOptions,
                                     keyboardActions = keyboardActions
                                 )
@@ -706,11 +635,11 @@ fun ConfigScreen(
                     Row(
                         horizontalArrangement = Arrangement.SpaceEvenly,
                         verticalAlignment = Alignment.CenterVertically,
-                        modifier =
+                        modifier = Modifier
-                        Modifier
                             .fillMaxSize()
                             .padding(bottom = 140.dp)
                     ) {
+
                         Row(
                             verticalAlignment = Alignment.CenterVertically,
                             horizontalArrangement = Arrangement.Center
@@ -718,14 +647,13 @@ fun ConfigScreen(
                             TextButton(
                                 onClick = {
                                     viewModel.addEmptyPeer()
-                                }
+                                }) {
-                            ) {
                                 Text(stringResource(R.string.add_peer))
                             }
                         }
                     }
                 }
-                if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
                     Spacer(modifier = Modifier.weight(.17f))
                 }
             }

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

@@ -23,20 +23,18 @@ import com.zaneschepke.wireguardautotunnel.ui.models.PeerProxy
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelException
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
+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 tunnelRepo: TunnelConfigDao,
-    private val settingsRepo: SettingsDoa
 ) : ViewModel() {
+
     private val _tunnel = MutableStateFlow<TunnelConfig?>(null)
     private val _tunnelName = MutableStateFlow("")
     val tunnelName get() = _tunnelName.asStateFlow()
@@ -60,14 +58,13 @@ constructor(
     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) {
+    suspend fun onScreenLoad(id : String) {
-        if (id != Constants.MANUAL_TUNNEL_CONFIG_ID) {
+        if(id != Constants.MANUAL_TUNNEL_CONFIG_ID) {
-            tunnelConfig = getTunnelConfigById(id) ?: throw WgTunnelException(
+            tunnelConfig = getTunnelConfigById(id) ?: throw WgTunnelException("Config not found")
-                "Config not found"
-            )
             emitScreenData()
         } else {
             emitEmptyScreenData()
@@ -87,6 +84,7 @@ constructor(
         }
     }
 
+
     private suspend fun emitScreenData() {
         emitTunnelConfig()
         emitPeersFromConfig()
@@ -99,7 +97,7 @@ constructor(
 
     private suspend fun emitDefaultTunnelStatus() {
         val settings = settingsRepo.getAll()
-        if (settings.isNotEmpty()) {
+        if(settings.isNotEmpty()) {
             _isDefaultTunnel.value = settings.first().isTunnelConfigDefault(tunnelConfig)
         }
     }
@@ -111,7 +109,7 @@ constructor(
 
     private fun emitPeersFromConfig() {
         val config = TunnelConfig.configFromQuick(tunnelConfig.wgQuick)
-        config.peers.forEach {
+        config.peers.forEach{
             _proxyPeers.value.add(PeerProxy.from(it))
         }
     }
@@ -124,10 +122,10 @@ constructor(
         _interface.value = interfaceProxy
     }
 
-    private suspend fun getTunnelConfigById(id: String): TunnelConfig? {
+    private suspend fun getTunnelConfigById(id : String) : TunnelConfig? {
         return try {
             tunnelRepo.getById(id.toLong())
-        } catch (_: Exception) {
+        } catch (_ : Exception) {
             null
         }
     }
@@ -136,31 +134,30 @@ constructor(
         _tunnel.emit(tunnelConfig)
     }
 
-    private suspend fun emitTunnelConfigName() {
+    private  suspend fun emitTunnelConfigName() {
         _tunnelName.emit(tunnelConfig.name)
     }
 
-    fun onTunnelNameChange(name: String) {
+    fun onTunnelNameChange(name : String) {
         _tunnelName.value = name
     }
 
-    fun onIncludeChange(include: Boolean) {
+    fun onIncludeChange(include : Boolean) {
         _include.value = include
     }
-
+    fun onAddCheckedPackage(packageName : String) {
-    fun onAddCheckedPackage(packageName: String) {
         _checkedPackages.value.add(packageName)
     }
 
-    fun onAllApplicationsChange(isAllApplicationsEnabled: Boolean) {
+    fun onAllApplicationsChange(isAllApplicationsEnabled : Boolean) {
         _isAllApplicationsEnabled.value = isAllApplicationsEnabled
     }
 
-    fun onRemoveCheckedPackage(packageName: String) {
+    fun onRemoveCheckedPackage(packageName : String) {
         _checkedPackages.value.remove(packageName)
     }
 
-    private suspend fun emitSplitTunnelConfiguration(config: Config) {
+    private suspend fun emitSplitTunnelConfiguration(config : Config) {
         val excludedApps = config.`interface`.excludedApplications
         val includedApps = config.`interface`.includedApplications
         if (excludedApps.isNotEmpty() || includedApps.isNotEmpty()) {
@@ -171,10 +168,7 @@ constructor(
         }
     }
 
-    private suspend fun determineAppInclusionState(
+    private suspend fun determineAppInclusionState(excludedApps : Set<String>, includedApps : Set<String>) {
-        excludedApps: Set<String>,
-        includedApps: Set<String>
-    ) {
         if (excludedApps.isEmpty()) {
             emitIncludedAppsExist()
             emitCheckedApps(includedApps)
@@ -192,7 +186,7 @@ constructor(
         _include.emit(false)
     }
 
-    private suspend fun emitCheckedApps(apps: Set<String>) {
+    private suspend fun emitCheckedApps(apps : Set<String>) {
         _checkedPackages.emit(apps.toMutableStateList())
     }
 
@@ -211,45 +205,45 @@ constructor(
         }
     }
 
-    fun emitQueriedPackages(query: String) {
+    fun emitQueriedPackages(query : String) {
         viewModelScope.launch(Dispatchers.IO) {
-            val packages =
+            val packages = getAllInternetCapablePackages().filter {
-                getAllInternetCapablePackages().filter {
+                getPackageLabel(it).lowercase().contains(query.lowercase())
-                    getPackageLabel(it).lowercase().contains(query.lowercase())
+            }
-                }
             _packages.emit(packages)
         }
     }
 
-    fun getPackageLabel(packageInfo: PackageInfo): String {
+    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 _isAllApplicationsEnabled.value
     }
 
+    private fun isIncludeApplicationsEnabled() : Boolean {
+        return _include.value
+    }
+
     private suspend fun saveConfig(tunnelConfig: TunnelConfig) {
         tunnelRepo.save(tunnelConfig)
     }
-
     private suspend fun updateTunnelConfig(tunnelConfig: TunnelConfig?) {
-        if (tunnelConfig != null) {
+        if(tunnelConfig != null) {
             saveConfig(tunnelConfig)
             updateSettingsDefaultTunnel(tunnelConfig)
         }
@@ -257,119 +251,88 @@ constructor(
 
     private suspend fun updateSettingsDefaultTunnel(tunnelConfig: TunnelConfig) {
         val settings = settingsRepo.getAll()
-        if (settings.isNotEmpty()) {
+        if(settings.isNotEmpty()) {
             val setting = settings[0]
-            if (setting.defaultTunnel != null) {
+            if(setting.defaultTunnel != null) {
-                if (tunnelConfig.id == TunnelConfig.from(setting.defaultTunnel!!).id) {
+                if(tunnelConfig.id == TunnelConfig.from(setting.defaultTunnel!!).id) {
-                    settingsRepo.save(
+                    settingsRepo.save(setting.copy(
-                        setting.copy(
+                        defaultTunnel = tunnelConfig.toString()
-                            defaultTunnel = tunnelConfig.toString()
+                    ))
-                        )
-                    )
                 }
             }
         }
     }
 
-    private fun buildPeerListFromProxyPeers(): List<Peer> {
+    fun buildPeerListFromProxyPeers() : List<Peer> {
         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 buildInterfaceListFromProxyInterface(): Interface {
+    fun buildInterfaceListFromProxyInterface() : Interface {
         val builder = Interface.Builder()
         builder.parsePrivateKey(_interface.value.privateKey.trim())
         builder.parseAddresses(_interface.value.addresses.trim())
         builder.parseDnsServers(_interface.value.dnsServers.trim())
-        if (_interface.value.mtu.isNotEmpty()) builder.parseMtu(_interface.value.mtu.trim())
+        if(_interface.value.mtu.isNotEmpty()) builder.parseMtu(_interface.value.mtu.trim())
-        if (_interface.value.listenPort.isNotEmpty()) {
+        if(_interface.value.listenPort.isNotEmpty()) builder.parseListenPort(_interface.value.listenPort.trim())
-            builder.parseListenPort(
+        if(isAllApplicationsEnabled()) _checkedPackages.value.clear()
-                _interface.value.listenPort.trim()
+        if(_include.value) builder.includeApplications(_checkedPackages.value)
-            )
+        if(!_include.value) builder.excludeApplications(_checkedPackages.value)
-        }
-        if (isAllApplicationsEnabled()) _checkedPackages.value.clear()
-        if (_include.value) builder.includeApplications(_checkedPackages.value)
-        if (!_include.value) builder.excludeApplications(_checkedPackages.value)
         return builder.build()
     }
 
+
+
     suspend fun onSaveAllChanges() {
         try {
             val peerList = buildPeerListFromProxyPeers()
             val wgInterface = buildInterfaceListFromProxyInterface()
             val config = Config.Builder().addPeers(peerList).setInterface(wgInterface).build()
-            val tunnelConfig =
+            val tunnelConfig = _tunnel.value?.copy(
-                _tunnel.value?.copy(
+                name = _tunnelName.value,
-                    name = _tunnelName.value,
+                wgQuick = config.toWgQuickString()
-                    wgQuick = config.toWgQuickString()
-                )
-            updateTunnelConfig(tunnelConfig)
-        } catch (e: Exception) {
-            throw WgTunnelException(
-                "Error: ${e.cause?.message?.lowercase() ?: "unknown error occurred"}"
             )
+            updateTunnelConfig(tunnelConfig)
+        } catch (e : Exception) {
+            throw WgTunnelException("Error: ${e.cause?.message?.lowercase() ?: "unknown error occurred"}")
         }
     }
 
-    fun onPeerPublicKeyChange(
+    fun onPeerPublicKeyChange(index: Int, publicKey: String) {
-        index: Int,
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-        publicKey: String
+            publicKey = publicKey
-    ) {
+        )
-        _proxyPeers.value[index] =
-            _proxyPeers.value[index].copy(
-                publicKey = publicKey
-            )
     }
 
-    fun onPreSharedKeyChange(
+    fun onPreSharedKeyChange(index: Int, value: String) {
-        index: Int,
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-        value: String
+            preSharedKey = value
-    ) {
+        )
-        _proxyPeers.value[index] =
-            _proxyPeers.value[index].copy(
-                preSharedKey = value
-            )
     }
 
-    fun onEndpointChange(
+    fun onEndpointChange(index: Int, value: String) {
-        index: Int,
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-        value: String
+            endpoint = value
-    ) {
+        )
-        _proxyPeers.value[index] =
-            _proxyPeers.value[index].copy(
-                endpoint = value
-            )
     }
 
-    fun onAllowedIpsChange(
+    fun onAllowedIpsChange(index: Int, value: String) {
-        index: Int,
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-        value: String
+            allowedIps = value
-    ) {
+        )
-        _proxyPeers.value[index] =
-            _proxyPeers.value[index].copy(
-                allowedIps = value
-            )
     }
 
-    fun onPersistentKeepaliveChanged(
+    fun onPersistentKeepaliveChanged(index : Int, value : String) {
-        index: Int,
+        _proxyPeers.value[index] = _proxyPeers.value[index].copy(
-        value: String
+            persistentKeepalive = value
-    ) {
+        )
-        _proxyPeers.value[index] =
-            _proxyPeers.value[index].copy(
-                persistentKeepalive = value
-            )
     }
 
     fun onDeletePeer(index: Int) {
@@ -382,54 +345,47 @@ constructor(
 
     fun generateKeyPair() {
         val keyPair = KeyPair()
-        _interface.value =
+        _interface.value = _interface.value.copy(
-            _interface.value.copy(
+            privateKey = keyPair.privateKey.toBase64(),
-                privateKey = keyPair.privateKey.toBase64(),
+            publicKey = keyPair.publicKey.toBase64()
-                publicKey = keyPair.publicKey.toBase64()
+        )
-            )
     }
 
     fun onAddressesChanged(value: String) {
-        _interface.value =
+        _interface.value = _interface.value.copy(
-            _interface.value.copy(
+            addresses = value
-                addresses = value
+        )
-            )
     }
 
     fun onListenPortChanged(value: String) {
-        _interface.value =
+        _interface.value = _interface.value.copy(
-            _interface.value.copy(
+            listenPort = value
-                listenPort = value
+        )
-            )
     }
 
     fun onDnsServersChanged(value: String) {
-        _interface.value =
+        _interface.value = _interface.value.copy(
-            _interface.value.copy(
+            dnsServers = value
-                dnsServers = value
+        )
-            )
     }
 
     fun onMtuChanged(value: String) {
-        _interface.value =
+        _interface.value = _interface.value.copy(
-            _interface.value.copy(
+            mtu = value
-                mtu = value
+        )
-            )
     }
 
-    private fun onInterfacePublicKeyChange(value: String) {
+    private fun onInterfacePublicKeyChange(value : String) {
-        _interface.value =
+        _interface.value = _interface.value.copy(
-            _interface.value.copy(
+            publicKey = value
-                publicKey = value
+        )
-            )
     }
 
     fun onPrivateKeyChange(value: String) {
-        _interface.value =
+        _interface.value = _interface.value.copy(
-            _interface.value.copy(
+            privateKey = value
-                privateKey = value
+        )
-            )
+        if(NumberUtils.isValidKey(value)) {
-        if (NumberUtils.isValidKey(value)) {
             val pair = KeyPair(Key.fromBase64(value))
             onInterfacePublicKeyChange(pair.publicKey.toBase64())
         } else {

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

@@ -88,7 +88,6 @@ import com.zaneschepke.wireguardautotunnel.ui.CaptureActivityPortrait
 import com.zaneschepke.wireguardautotunnel.ui.Routes
 import com.zaneschepke.wireguardautotunnel.ui.common.RowListItem
 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.WgTunnelException
 import kotlinx.coroutines.Dispatchers
@@ -103,6 +102,7 @@ fun MainScreen(
     showSnackbarMessage: (String) -> Unit,
     navController: NavController
 ) {
+
     val haptic = LocalHapticFeedback.current
     val context = LocalContext.current
     val isVisible = rememberSaveable { mutableStateOf(true) }
@@ -112,9 +112,7 @@ fun MainScreen(
     var showBottomSheet by remember { mutableStateOf(false) }
     var showPrimaryChangeAlertDialog by remember { mutableStateOf(false) }
     val tunnels by viewModel.tunnels.collectAsStateWithLifecycle(mutableListOf())
-    val handshakeStatus by viewModel.handshakeStatus.collectAsStateWithLifecycle(
+    val handshakeStatus by viewModel.handshakeStatus.collectAsStateWithLifecycle(HandshakeStatus.NOT_STARTED)
-        HandshakeStatus.NOT_STARTED
-    )
     var selectedTunnel by remember { mutableStateOf<TunnelConfig?>(null) }
     val state by viewModel.state.collectAsStateWithLifecycle(Tunnel.State.DOWN)
     val tunnelName by viewModel.tunnelName.collectAsStateWithLifecycle("")
@@ -122,100 +120,75 @@ fun MainScreen(
     val statistics by viewModel.statistics.collectAsStateWithLifecycle(null)
 
     // Nested scroll for control FAB
-    val nestedScrollConnection =
+    val nestedScrollConnection = remember {
-        remember {
+        object : NestedScrollConnection {
-            object : NestedScrollConnection {
+            override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
-                override fun onPreScroll(
+                // Hide FAB
-                    available: Offset,
+                if (available.y < -1) {
-                    source: NestedScrollSource
+                    isVisible.value = false
-                ): Offset {
-                    // Hide FAB
-                    if (available.y < -1) {
-                        isVisible.value = false
-                    }
-                    // Show FAB
-                    if (available.y > 1) {
-                        isVisible.value = true
-                    }
-                    return Offset.Zero
                 }
+                // 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()
-                                )
-                            )
-                        } else {
-                            context.packageManager.queryIntentActivities(
-                                intent,
-                                PackageManager.MATCH_DEFAULT_ONLY
-                            )
-                        }
-                    if (activitiesToResolveIntent.all {
-                            val name = it.activityInfo.packageName
-                            name.startsWith(Constants.GOOGLE_TV_EXPLORER_STUB) || name.startsWith(
-                                Constants.ANDROID_TV_EXPLORER_STUB
-                            )
-                        }
-                    ) {
-                        throw WgTunnelException(context.getString(R.string.no_file_explorer))
-                    }
-                    return intent
-                }
             }
-        ) { data ->
+            if (activitiesToResolveIntent.all {
-            if (data == null) return@rememberLauncherForActivityResult
+                    val name = it.activityInfo.packageName
-            scope.launch(Dispatchers.IO) {
+                    name.startsWith(Constants.GOOGLE_TV_EXPLORER_STUB) || name.startsWith(Constants.ANDROID_TV_EXPLORER_STUB)
+                }) {
+                throw WgTunnelException(context.getString(R.string.no_file_explorer))
+            }
+            return intent
+        }
+    }) { data ->
+        if (data == null) return@rememberLauncherForActivityResult
+        scope.launch(Dispatchers.IO) {
+            try {
+                viewModel.onTunnelFileSelected(data)
+            } catch (e : WgTunnelException) {
+                showSnackbarMessage(e.message)
+            }
+        }
+    }
+
+    val scanLauncher = rememberLauncherForActivityResult(
+        contract = ScanContract(),
+        onResult = {
+            scope.launch {
                 try {
-                    viewModel.onTunnelFileSelected(data)
+                    viewModel.onTunnelQrResult(it.contents)
-                } catch (e: WgTunnelException) {
+                } catch (e: Exception) {
-                    showSnackbarMessage(e.message)
+                    when(e) {
-                }
+                        is WgTunnelException -> {
-            }
+                            showSnackbarMessage(e.message)
-        }
+                        } else -> {
-
+                            showSnackbarMessage("No QR code scanned")
-    val scanLauncher =
-        rememberLauncherForActivityResult(
-            contract = ScanContract(),
-            onResult = {
-                scope.launch {
-                    try {
-                        viewModel.onTunnelQrResult(it.contents)
-                    } catch (e: Exception) {
-                        when (e) {
-                            is WgTunnelException -> {
-                                showSnackbarMessage(e.message)
-                            }
-
-                            else -> {
-                                showSnackbarMessage("No QR code scanned")
-                            }
                         }
                     }
                 }
             }
-        )
+        }
+    )
 
-    if (showPrimaryChangeAlertDialog) {
+    if(showPrimaryChangeAlertDialog) {
         AlertDialog(
             onDismissRequest = {
-                showPrimaryChangeAlertDialog = false
+               showPrimaryChangeAlertDialog = false
             },
             confirmButton = {
                 TextButton(onClick = {
@@ -224,32 +197,30 @@ fun MainScreen(
                         showPrimaryChangeAlertDialog = false
                         selectedTunnel = null
                     }
-                }) { Text(text = stringResource(R.string.okay)) }
+                })
+                { Text(text = stringResource(R.string.okay)) }
             },
             dismissButton = {
                 TextButton(onClick = {
                     showPrimaryChangeAlertDialog = false
-                }) { Text(text = stringResource(R.string.cancel)) }
+                })
+                { Text(text = stringResource(R.string.cancel)) }
             },
             title = { Text(text = stringResource(R.string.primary_tunnel_change)) },
             text = { Text(text = stringResource(R.string.primary_tunnel_change_question)) }
         )
     }
 
-    fun onTunnelToggle(
+    fun onTunnelToggle(checked : Boolean , tunnel : TunnelConfig) {
-        checked: Boolean,
-        tunnel: TunnelConfig
-    ) {
         try {
             if (checked) viewModel.onTunnelStart(tunnel) else viewModel.onTunnelStop()
-        } catch (e: Exception) {
+        } catch (e : Exception) {
             showSnackbarMessage(e.message!!)
         }
     }
 
     Scaffold(
-        modifier =
+        modifier = Modifier.pointerInput(Unit) {
-        Modifier.pointerInput(Unit) {
             detectTapGestures(onTap = {
                 selectedTunnel = null
             })
@@ -259,30 +230,30 @@ fun MainScreen(
             AnimatedVisibility(
                 visible = isVisible.value,
                 enter = slideInVertically(initialOffsetY = { it * 2 }),
-                exit = slideOutVertically(targetOffsetY = { it * 2 })
+                exit = slideOutVertically(targetOffsetY = { it * 2 }),
             ) {
                 val secondaryColor = MaterialTheme.colorScheme.secondary
                 val hoverColor = MaterialTheme.colorScheme.surfaceColorAtElevation(2.dp)
                 var fobColor by remember { mutableStateOf(secondaryColor) }
                 FloatingActionButton(
-                    modifier =
+                    modifier = Modifier
-                    Modifier
                         .padding(bottom = 90.dp)
                         .onFocusChanged {
                             if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
                                 fobColor = if (it.isFocused) hoverColor else secondaryColor
                             }
-                        },
+                        }
+                    ,
                     onClick = {
                         showBottomSheet = true
                     },
                     containerColor = fobColor,
-                    shape = RoundedCornerShape(16.dp)
+                    shape = RoundedCornerShape(16.dp),
                 ) {
                     Icon(
                         imageVector = Icons.Rounded.Add,
                         contentDescription = stringResource(id = R.string.add_tunnel),
-                        tint = Color.DarkGray
+                        tint = Color.DarkGray,
                     )
                 }
             }
@@ -292,8 +263,7 @@ fun MainScreen(
             Column(
                 horizontalAlignment = Alignment.CenterHorizontally,
                 verticalArrangement = Arrangement.Center,
-                modifier =
+                modifier = Modifier
-                Modifier
                     .fillMaxSize()
                     .padding(padding)
             ) {
@@ -309,8 +279,7 @@ fun MainScreen(
             ) {
                 // Sheet content
                 Row(
-                    modifier =
+                    modifier = Modifier
-                    Modifier
                         .fillMaxWidth()
                         .clickable {
                             showBottomSheet = false
@@ -332,26 +301,23 @@ fun MainScreen(
                         modifier = Modifier.padding(10.dp)
                     )
                 }
-                if (!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                if(!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
                     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(context.getString(R.string.scanning_qr))
+                                scanOptions.captureActivity = CaptureActivityPortrait::class.java
-                                    scanOptions.setBeepEnabled(false)
+                                scanLauncher.launch(scanOptions)
-                                    scanOptions.captureActivity =
-                                        CaptureActivityPortrait::class.java
-                                    scanLauncher.launch(scanOptions)
-                                }
                             }
-                            .padding(10.dp)
+                        }
+                        .padding(10.dp)
                     ) {
                         Icon(
                             Icons.Filled.QrCode,
@@ -366,14 +332,11 @@ fun MainScreen(
                 }
                 Divider()
                 Row(
-                    modifier =
+                    modifier = Modifier
-                    Modifier
                         .fillMaxWidth()
                         .clickable {
                             showBottomSheet = false
-                            navController.navigate(
+                            navController.navigate("${Routes.Config.name}/${Constants.MANUAL_TUNNEL_CONFIG_ID}")
-                                "${Routes.Config.name}/${Constants.MANUAL_TUNNEL_CONFIG_ID}"
-                            )
                         }
                         .padding(10.dp)
                 ) {
@@ -392,67 +355,47 @@ fun MainScreen(
         Column(
             horizontalAlignment = Alignment.Start,
             verticalArrangement = Arrangement.Top,
-            modifier =
+            modifier = Modifier
-            Modifier
                 .fillMaxSize()
                 .padding(padding)
         ) {
             LazyColumn(
-                modifier =
+                modifier = Modifier
-                Modifier
                     .fillMaxSize()
-                    .padding(top = 10.dp)
+                    .nestedScroll(nestedScrollConnection),
-                    .nestedScroll(nestedScrollConnection)
             ) {
                 items(tunnels, key = { tunnel -> tunnel.id }) { tunnel ->
-                    val leadingIconColor = (
+                   val leadingIconColor = (if (tunnelName == tunnel.name) when (handshakeStatus) {
-                            if (tunnelName == tunnel.name) {
+                        HandshakeStatus.HEALTHY -> mint
-                                when (handshakeStatus) {
+                        HandshakeStatus.UNHEALTHY -> brickRed
-                                    HandshakeStatus.HEALTHY -> mint
+                        HandshakeStatus.NOT_STARTED -> Color.Gray
-                                    HandshakeStatus.UNHEALTHY -> brickRed
+                        HandshakeStatus.NEVER_CONNECTED -> brickRed
-                                    HandshakeStatus.STALE -> corn
+                    } else {Color.Gray})
-                                    HandshakeStatus.NOT_STARTED -> Color.Gray
-                                    HandshakeStatus.NEVER_CONNECTED -> brickRed
-                                }
-                            } else {
-                                Color.Gray
-                            }
-                            )
                     val focusRequester = remember { FocusRequester() }
-                    val expanded =
+                    val expanded = remember {
-                        remember {
+                        mutableStateOf(false)
-                            mutableStateOf(false)
+                    }
-                        }
+                    RowListItem(icon = {
-                    RowListItem(
+                        if (settings.isTunnelConfigDefault(tunnel))
-                        icon = {
+                            Icon(
-                            if (settings.isTunnelConfigDefault(tunnel)) {
+                                Icons.Rounded.Star, stringResource(R.string.status),
-                                Icon(
+                                tint = leadingIconColor,
-                                    Icons.Rounded.Star,
+                                modifier = Modifier
-                                    stringResource(R.string.status),
+                                    .padding(end = 10.dp)
-                                    tint = leadingIconColor,
+                                    .size(20.dp)
-                                    modifier =
+                            )
-                                    Modifier
+                        else Icon(
-                                        .padding(end = 10.dp)
+                            Icons.Rounded.Circle, stringResource(R.string.status),
-                                        .size(20.dp)
+                            tint = leadingIconColor,
-                                )
+                            modifier = Modifier
-                            } else {
+                                .padding(end = 15.dp)
-                                Icon(
+                                .size(15.dp)
-                                    Icons.Rounded.Circle,
+                        )
-                                    stringResource(R.string.status),
+                    },
-                                    tint = leadingIconColor,
-                                    modifier =
-                                    Modifier
-                                        .padding(end = 15.dp)
-                                        .size(15.dp)
-                                )
-                            }
-                        },
                         text = tunnel.name,
                         onHold = {
-                            if ((state == Tunnel.State.UP) && (tunnel.name == tunnelName)) {
+                            if (state == Tunnel.State.UP && tunnel.name == tunnelName) {
-                                showSnackbarMessage(
+                                showSnackbarMessage(context.resources.getString(R.string.turn_off_tunnel))
-                                    context.resources.getString(R.string.turn_off_tunnel)
-                                )
                                 return@RowListItem
                             }
                             haptic.performHapticFeedback(HapticFeedbackType.LongPress)
@@ -460,7 +403,7 @@ fun MainScreen(
                         },
                         onClick = {
                             if (!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                                if (state == Tunnel.State.UP && (tunnelName == tunnel.name)) {
+                                if(state == Tunnel.State.UP && (tunnelName == tunnel.name) ) {
                                     expanded.value = !expanded.value
                                 }
                             } else {
@@ -471,40 +414,25 @@ fun MainScreen(
                         statistics = statistics,
                         expanded = expanded.value,
                         rowButton = {
-                            if (tunnel.id == selectedTunnel?.id && !WireGuardAutoTunnel.isRunningOnAndroidTv(
+                            if (tunnel.id == selectedTunnel?.id && !WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                                    context
-                                )
-                            ) {
                                 Row {
-                                    if (!settings.isTunnelConfigDefault(tunnel)) {
+                                    if(!settings.isTunnelConfigDefault(tunnel)) {
                                         IconButton(onClick = {
-                                            if (settings.isAutoTunnelEnabled) {
+                                            if(settings.isAutoTunnelEnabled) {
-                                                showSnackbarMessage(
+                                                showSnackbarMessage(context.resources.getString(R.string.turn_off_auto))
-                                                    context.resources.getString(
+                                            } else showPrimaryChangeAlertDialog = true
-                                                        R.string.turn_off_auto
-                                                    )
-                                                )
-                                            } else {
-                                                showPrimaryChangeAlertDialog = true
-                                            }
                                         }) {
-                                            Icon(
+                                            Icon(Icons.Rounded.Star, stringResource(id = R.string.set_primary))
-                                                Icons.Rounded.Star,
-                                                stringResource(id = R.string.set_primary)
-                                            )
                                         }
                                     }
                                     IconButton(onClick = {
-                                        navController.navigate(
+                                        navController.navigate("${Routes.Config.name}/${selectedTunnel?.id}")
-                                            "${Routes.Config.name}/${selectedTunnel?.id}"
-                                        )
                                     }) {
                                         Icon(Icons.Rounded.Edit, stringResource(id = R.string.edit))
                                     }
                                     IconButton(
                                         modifier = Modifier.focusable(),
-                                        onClick = { viewModel.onDelete(tunnel) }
+                                        onClick = { viewModel.onDelete(tunnel) }) {
-                                    ) {
                                         Icon(
                                             Icons.Rounded.Delete,
                                             stringResource(id = R.string.delete)
@@ -513,59 +441,45 @@ fun MainScreen(
                                 }
                             } else {
                                 val checked = state == Tunnel.State.UP && tunnel.name == tunnelName
-                                if (!checked) expanded.value = false
+                                if(!checked) expanded.value = false
-
                                 @Composable
-                                fun TunnelSwitch() =
+                                fun TunnelSwitch() = Switch(
-                                    Switch(
+                                    modifier = Modifier.focusRequester(focusRequester),
-                                        modifier = Modifier.focusRequester(focusRequester),
+                                    checked = checked,
-                                        checked = checked,
+                                    onCheckedChange = { checked ->
-                                        onCheckedChange = { checked ->
+                                        if(!checked) expanded.value = false
-                                            if (!checked) expanded.value = false
+                                        onTunnelToggle(checked, tunnel)
-                                            onTunnelToggle(checked, tunnel)
+                                    }
-                                        }
+                                )
-                                    )
                                 if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
                                     Row {
-                                        if (!settings.isTunnelConfigDefault(tunnel)) {
+                                        if(!settings.isTunnelConfigDefault(tunnel)) {
                                             IconButton(onClick = {
-                                                if (settings.isAutoTunnelEnabled) {
+                                                if(settings.isAutoTunnelEnabled) {
-                                                    showSnackbarMessage(
+                                                    showSnackbarMessage(context.resources.getString(R.string.turn_off_auto))
-                                                        context.resources.getString(
+                                                } else showPrimaryChangeAlertDialog = true
-                                                            R.string.turn_off_auto
-                                                        )
-                                                    )
-                                                } else {
-                                                    showPrimaryChangeAlertDialog = true
-                                                }
                                             }) {
-                                                Icon(
+                                                Icon(Icons.Rounded.Star, stringResource(id = R.string.set_primary))
-                                                    Icons.Rounded.Star,
-                                                    stringResource(id = R.string.set_primary)
-                                                )
                                             }
                                         }
                                         IconButton(
                                             modifier = Modifier.focusRequester(focusRequester),
                                             onClick = {
-                                                if (state == Tunnel.State.UP && (tunnelName == tunnel.name)) {
+                                                if(state == Tunnel.State.UP && (tunnelName == tunnel.name) ) {
                                                     expanded.value = !expanded.value
                                                 }
-                                            }
+                                            }) {
-                                        ) {
                                             Icon(Icons.Rounded.Info, stringResource(R.string.info))
                                         }
                                         IconButton(onClick = {
-                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName) {
+                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName)
                                                 showSnackbarMessage(
                                                     context.resources.getString(
                                                         R.string.turn_off_tunnel
                                                     )
                                                 )
-                                            } else {
+                                            else {
-                                                navController.navigate(
+                                                navController.navigate("${Routes.Config.name}/${tunnel.id}")
-                                                    "${Routes.Config.name}/${tunnel.id}"
-                                                )
                                             }
                                         }) {
                                             Icon(
@@ -574,13 +488,13 @@ fun MainScreen(
                                             )
                                         }
                                         IconButton(onClick = {
-                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName) {
+                                            if (state == Tunnel.State.UP && tunnel.name == tunnelName)
                                                 showSnackbarMessage(
                                                     context.resources.getString(
                                                         R.string.turn_off_tunnel
                                                     )
                                                 )
-                                            } else {
+                                            else {
                                                 viewModel.onDelete(tunnel)
                                             }
                                         }) {
@@ -595,8 +509,7 @@ fun MainScreen(
                                     TunnelSwitch()
                                 }
                             }
-                        }
+                        })
-                    )
                 }
             }
         }

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

@@ -22,9 +22,6 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.NumberUtils
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelException
 import dagger.hilt.android.lifecycle.HiltViewModel
-import java.io.InputStream
-import java.util.zip.ZipInputStream
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -32,16 +29,19 @@ import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+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 tunnelRepo: TunnelConfigDao,
     private val settingsRepo: SettingsDoa,
     private val vpnService: VpnService
 ) : ViewModel() {
+
     val tunnels get() = tunnelRepo.getAllFlow()
     val state get() = vpnService.state
 
@@ -62,11 +62,10 @@ constructor(
     }
 
     private fun validateWatcherServiceState(settings: Settings) {
-        val watcherState =
+        val watcherState = ServiceManager.getServiceState(
-            ServiceManager.getServiceState(
+            application.applicationContext,
-                application.applicationContext,
+            WireGuardConnectivityWatcherService::class.java
-                WireGuardConnectivityWatcherService::class.java
+        )
-            )
         if (settings.isAutoTunnelEnabled && watcherState == ServiceState.STOPPED && settings.defaultTunnel != null) {
             ServiceManager.startWatcherService(
                 application.applicationContext,
@@ -75,6 +74,7 @@ constructor(
         }
     }
 
+
     fun onDelete(tunnel: TunnelConfig) {
         viewModelScope.launch {
             if (tunnelRepo.count() == 1L) {
@@ -106,7 +106,7 @@ constructor(
     private suspend fun stopActiveTunnel() {
         if (ServiceManager.getServiceState(
                 application.applicationContext,
-                WireGuardTunnelService::class.java
+                WireGuardTunnelService::class.java,
             ) == ServiceState.STARTED
         ) {
             onTunnelStop()
@@ -128,15 +128,12 @@ constructor(
             val tunnelConfig =
                 TunnelConfig(name = NumberUtils.generateRandomTunnelName(), wgQuick = result)
             addTunnel(tunnelConfig)
-        } catch (e: Exception) {
+        } catch (e : Exception) {
             throw WgTunnelException(e)
         }
     }
 
-    private suspend fun saveTunnelConfigFromStream(
+    private suspend fun saveTunnelConfigFromStream(stream: InputStream, fileName: String) {
-        stream: InputStream,
-        fileName: String
-    ) {
         val bufferReader = stream.bufferedReader(charset = Charsets.UTF_8)
         val config = Config.parse(bufferReader)
         val tunnelName = getNameFromFileName(fileName)
@@ -155,12 +152,10 @@ constructor(
         try {
             val fileName = getFileName(application.applicationContext, uri)
             val fileExtension = getFileExtensionFromFileName(fileName)
-            when (fileExtension) {
+            when(fileExtension){
                 Constants.CONF_FILE_EXTENSION -> saveTunnelFromConfUri(fileName, uri)
                 Constants.ZIP_FILE_EXTENSION -> saveTunnelsFromZipUri(uri)
-                else -> throw WgTunnelException(
+                else -> throw WgTunnelException(application.getString(R.string.file_extension_message))
-                    application.getString(R.string.file_extension_message)
-                )
             }
         } catch (e: Exception) {
             throw WgTunnelException(e)
@@ -170,24 +165,19 @@ constructor(
     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(
+    private suspend fun saveTunnelFromConfUri(name : String, uri: Uri) {
-        name: String,
-        uri: Uri
-    ) {
         val stream = getInputStreamFromUri(uri)
         saveTunnelConfigFromStream(stream, name)
     }
@@ -200,10 +190,7 @@ constructor(
         tunnelRepo.save(tunnelConfig)
     }
 
-    private fun getFileNameByCursor(
+    private fun getFileNameByCursor(context: Context, uri: Uri): String {
-        context: Context,
-        uri: Uri
-    ): String {
         val cursor = context.contentResolver.query(uri, null, null, null, null)
         if (cursor != null) {
             cursor.use {
@@ -237,10 +224,8 @@ constructor(
         }
     }
 
-    private fun getFileName(
+
-        context: Context,
+    private fun getFileName(context: Context, uri: Uri): String {
-        uri: Uri
-    ): String {
         validateUriContentScheme(uri)
         return try {
             getFileNameByCursor(context, uri)

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

@@ -38,7 +38,6 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -66,32 +65,29 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
-import com.wireguard.android.backend.Tunnel
-import com.wireguard.android.backend.WgQuickBackend
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.repository.datastore.DataStoreManager
 import com.zaneschepke.wireguardautotunnel.ui.common.ClickableIconButton
 import com.zaneschepke.wireguardautotunnel.ui.common.config.ConfigurationToggle
 import com.zaneschepke.wireguardautotunnel.ui.common.prompt.AuthorizationPrompt
 import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
-import com.zaneschepke.wireguardautotunnel.util.FileUtils
+import com.zaneschepke.wireguardautotunnel.util.StorageUtil
-import com.zaneschepke.wireguardautotunnel.util.WgTunnelException
-import java.io.File
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import java.io.File
+
 @OptIn(
     ExperimentalPermissionsApi::class,
-    ExperimentalLayoutApi::class,
+    ExperimentalLayoutApi::class, ExperimentalComposeUiApi::class
-    ExperimentalComposeUiApi::class
 )
 @Composable
 fun SettingsScreen(
     viewModel: SettingsViewModel = hiltViewModel(),
     padding: PaddingValues,
     showSnackbarMessage: (String) -> Unit,
-    focusRequester: FocusRequester
+    focusRequester: FocusRequester,
 ) {
+
     val scope = rememberCoroutineScope { Dispatchers.IO }
     val context = LocalContext.current
     val focusManager = LocalFocusManager.current
@@ -104,24 +100,16 @@ fun SettingsScreen(
     val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
     var currentText by remember { mutableStateOf("") }
     val scrollState = rememberScrollState()
+    var isLocationDisclaimerNeeded by remember { mutableStateOf(true) }
     var isBackgroundLocationGranted by remember { mutableStateOf(true) }
     var showAuthPrompt by remember { mutableStateOf(false) }
     var didExportFiles by remember { mutableStateOf(false) }
-    val isLocationDisclosureShown by viewModel.disclosureShown.collectAsStateWithLifecycle(
+
-        null
+
-    )
-    val vpnState = viewModel.vpnState.collectAsStateWithLifecycle(initialValue = Tunnel.State.DOWN)
 
     val screenPadding = 5.dp
     val fillMaxWidth = .85f
 
-    fun setLocationDisclosureShown() = scope.launch {
-        viewModel.dataStoreManager.saveToDataStore(
-            DataStoreManager.LOCATION_DISCLOSURE_SHOWN,
-            true
-        )
-    }
-
     fun exportAllConfigs() {
         try {
             val files = tunnels.map { File(context.cacheDir, "${it.name}.conf") }
@@ -130,35 +118,33 @@ fun SettingsScreen(
                     it.write(tunnels[index].wgQuick.toByteArray())
                 }
             }
-            FileUtils.saveFilesToZip(context, files)
+            StorageUtil.saveFilesToZip(context, files)
             didExportFiles = true
             showSnackbarMessage(context.getString(R.string.exported_configs_message))
-        } catch (e: Exception) {
+        } catch (e : Exception) {
             showSnackbarMessage(e.message!!)
         }
     }
 
+
     fun saveTrustedSSID() {
         if (currentText.isNotEmpty()) {
             scope.launch {
                 try {
                     viewModel.onSaveTrustedSSID(currentText)
                     currentText = ""
-                } catch (e: Exception) {
+                } catch (e : Exception) {
                     showSnackbarMessage(e.message ?: context.getString(R.string.unknown_error))
                 }
             }
         }
     }
 
-    fun isAllAutoTunnelPermissionsEnabled(): Boolean {
+    fun isAllAutoTunnelPermissionsEnabled() : Boolean {
-        return (
+        return(isBackgroundLocationGranted && fineLocationState.status.isGranted && !viewModel.isLocationServicesNeeded())
-                isBackgroundLocationGranted &&
-                        fineLocationState.status.isGranted &&
-                        !viewModel.isLocationServicesNeeded()
-                )
     }
 
+
     fun openSettings() {
         scope.launch {
             val intentSettings =
@@ -169,428 +155,334 @@ fun SettingsScreen(
         }
     }
 
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
         val backgroundLocationState =
             rememberPermissionState(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
-        isBackgroundLocationGranted = if (!backgroundLocationState.status.isGranted) {
+        if(!backgroundLocationState.status.isGranted) {
-            false
-        } else {
-            SideEffect {
-                setLocationDisclosureShown()
-            }
-            true
-        }
-    }
-
-    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
-        if (!fineLocationState.status.isGranted) {
             isBackgroundLocationGranted = false
         } else {
-            SideEffect {
+            isLocationDisclaimerNeeded = false
-                setLocationDisclosureShown()
-            }
             isBackgroundLocationGranted = true
         }
     }
 
-        if (isLocationDisclosureShown != true) {
+    if(Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
-            Column(
+        if(!fineLocationState.status.isGranted) {
-                horizontalAlignment = Alignment.CenterHorizontally,
+            isBackgroundLocationGranted = false
-                verticalArrangement = Arrangement.Top,
+        } else {
-                modifier =
+            isLocationDisclaimerNeeded = false
-                Modifier
+            isBackgroundLocationGranted = true
-                    .fillMaxSize()
-                    .verticalScroll(scrollState)
-                    .padding(padding)
-            ) {
-                Icon(
-                    Icons.Rounded.LocationOff,
-                    contentDescription = stringResource(id = R.string.map),
-                    modifier =
-                    Modifier
-                        .padding(30.dp)
-                        .size(128.dp)
-                )
-                Text(
-                    stringResource(R.string.prominent_background_location_title),
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.padding(30.dp),
-                    fontSize = 20.sp
-                )
-                Text(
-                    stringResource(R.string.prominent_background_location_message),
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.padding(30.dp),
-                    fontSize = 15.sp
-                )
-                Row(
-                    modifier =
-                    if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                        Modifier
-                            .fillMaxWidth()
-                            .padding(10.dp)
-                    } else {
-                        Modifier
-                            .fillMaxWidth()
-                            .padding(30.dp)
-                    },
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.SpaceEvenly
-                ) {
-                    TextButton(onClick = {
-                        setLocationDisclosureShown()
-                    }) {
-                        Text(stringResource(id = R.string.no_thanks))
-                    }
-                    TextButton(modifier = Modifier.focusRequester(focusRequester), onClick = {
-                        openSettings()
-                        setLocationDisclosureShown()
-                    }) {
-                        Text(stringResource(id = R.string.turn_on))
-                    }
-                }
-            }
-            return
-        }
-
-        if (showAuthPrompt) {
-            AuthorizationPrompt(
-                onSuccess = {
-                    showAuthPrompt = false
-                    exportAllConfigs()
-                },
-                onError = { error ->
-                    showSnackbarMessage(error)
-                    showAuthPrompt = false
-                },
-                onFailure = {
-                    showAuthPrompt = false
-                    showSnackbarMessage(context.getString(R.string.authentication_failed))
-                }
-            )
-        }
-
-        if (tunnels.isEmpty()) {
-            Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center,
-                modifier =
-                Modifier
-                    .fillMaxSize()
-                    .padding(padding)
-            ) {
-                Text(
-                    stringResource(R.string.one_tunnel_required),
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.padding(15.dp),
-                    fontStyle = FontStyle.Italic
-                )
-            }
-            return
         }
+    }
 
+    if(isLocationDisclaimerNeeded) {
         Column(
             horizontalAlignment = Alignment.CenterHorizontally,
             verticalArrangement = Arrangement.Top,
-            modifier =
+            modifier = Modifier
-            Modifier
                 .fillMaxSize()
                 .verticalScroll(scrollState)
-                .clickable(indication = null, interactionSource = interactionSource) {
+                .padding(padding)
-                    focusManager.clearFocus()
-                }
         ) {
+            Icon(
+                Icons.Rounded.LocationOff,
+                contentDescription = stringResource(id = R.string.map),
+                modifier = Modifier
+                    .padding(30.dp)
+                    .size(128.dp)
+            )
+            Text(
+                stringResource(R.string.prominent_background_location_title),
+                textAlign = TextAlign.Center,
+                modifier = Modifier.padding(30.dp),
+                fontSize = 20.sp
+            )
+            Text(
+                stringResource(R.string.prominent_background_location_message),
+                textAlign = TextAlign.Center,
+                modifier = Modifier.padding(30.dp),
+                fontSize = 15.sp
+            )
+            Row(
+                modifier = if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) Modifier
+                    .fillMaxWidth()
+                    .padding(10.dp) else Modifier
+                    .fillMaxWidth()
+                    .padding(30.dp),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.SpaceEvenly
+            ) {
+                TextButton(onClick = {
+                    isLocationDisclaimerNeeded = false
+                }) {
+                    Text(stringResource(id = R.string.no_thanks))
+                }
+                TextButton(modifier = Modifier.focusRequester(focusRequester), onClick = {
+                    openSettings()
+                }) {
+                    Text(stringResource(id = R.string.turn_on))
+                }
+            }
+        }
+        return
+    }
+
+
+
+    if(showAuthPrompt) {
+        AuthorizationPrompt(onSuccess = {
+            showAuthPrompt = false
+            exportAllConfigs() },
+            onError = { error ->
+                showSnackbarMessage(error)
+                showAuthPrompt = false
+                },
+            onFailure = {
+                showAuthPrompt = false
+                showSnackbarMessage(context.getString(R.string.authentication_failed))
+            })
+    }
+
+    if (tunnels.isEmpty()) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.Center,
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding)
+        ) {
+            Text(
+                stringResource(R.string.one_tunnel_required),
+                textAlign = TextAlign.Center,
+                modifier = Modifier.padding(15.dp),
+                fontStyle = FontStyle.Italic
+            )
+        }
+        return
+    }
+
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Top,
+        modifier = Modifier
+            .fillMaxSize()
+            .verticalScroll(scrollState)
+            .clickable(indication = null, interactionSource = interactionSource) {
+                focusManager.clearFocus()
+            }
+    ) {
+        Surface(
+            tonalElevation = 2.dp,
+            shadowElevation = 2.dp,
+            shape = RoundedCornerShape(12.dp),
+            color = MaterialTheme.colorScheme.surface,
+            modifier = (if (WireGuardAutoTunnel.isRunningOnAndroidTv(context))
+                Modifier
+                    .height(IntrinsicSize.Min)
+                    .fillMaxWidth(fillMaxWidth)
+                    .padding(top = 10.dp)
+            else Modifier
+                .fillMaxWidth(fillMaxWidth)
+                .padding(top = 60.dp)).padding(bottom = 25.dp)
+        ) {
+            Column(
+                horizontalAlignment = Alignment.Start,
+                verticalArrangement = Arrangement.Top,
+                modifier = Modifier.padding(15.dp)
+            ) {
+                SectionTitle(title = stringResource(id = R.string.auto_tunneling), padding = screenPadding)
+                ConfigurationToggle(
+                    stringResource(id = R.string.tunnel_on_wifi),
+                    enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
+                    checked = settings.isTunnelOnWifiEnabled,
+                    padding = screenPadding,
+                    onCheckChanged = {
+                        scope.launch {
+                            viewModel.onToggleTunnelOnWifi()
+                        }
+                    },
+                    modifier = Modifier.focusRequester(focusRequester)
+                )
+                AnimatedVisibility(visible = settings.isTunnelOnWifiEnabled) {
+                    Column {
+                        FlowRow(
+                            modifier = Modifier.padding(screenPadding),
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                            verticalArrangement = Arrangement.SpaceEvenly
+                        ) {
+                            trustedSSIDs.forEach { ssid ->
+                                ClickableIconButton(
+                                    onIconClick = {
+                                        scope.launch {
+                                            viewModel.onDeleteTrustedSSID(ssid)
+                                        }
+                                    },
+                                    text = ssid,
+                                    icon = Icons.Filled.Close,
+                                    enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled)
+                                )
+                            }
+                            if(trustedSSIDs.isEmpty()) {
+                                Text(stringResource(R.string.none), fontStyle = FontStyle.Italic, color = Color.Gray)
+                            }
+                        }
+                        OutlinedTextField(
+                            enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
+                            value = currentText,
+                            onValueChange = { currentText = it },
+                            label = { Text(stringResource(R.string.add_trusted_ssid)) },
+                            modifier = Modifier
+                                .padding(start = screenPadding, top = 5.dp, bottom = 10.dp)
+                                .onFocusChanged {
+                                    if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                                        keyboardController?.hide()
+                                    }
+                                },
+                            maxLines = 1,
+                            keyboardOptions = KeyboardOptions(
+                                capitalization = KeyboardCapitalization.None,
+                                imeAction = ImeAction.Done
+                            ),
+                            keyboardActions = KeyboardActions(
+                                onDone = {
+                                    saveTrustedSSID()
+                                }
+                            ),
+                            trailingIcon = {
+                                IconButton(onClick = { saveTrustedSSID() }) {
+                                    Icon(
+                                        imageVector = Icons.Outlined.Add,
+                                        contentDescription = if (currentText == "") stringResource(id = R.string.trusted_ssid_empty_description) else stringResource(
+                                            id = R.string.trusted_ssid_value_description
+                                        ),
+                                        tint = if (currentText == "") Color.Transparent else MaterialTheme.colorScheme.primary
+                                    )
+                                }
+                            },
+                        )
+                    }
+                }
+                ConfigurationToggle(stringResource(R.string.tunnel_mobile_data),
+                    enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
+                    checked = settings.isTunnelOnMobileDataEnabled,
+                    padding = screenPadding,
+                    onCheckChanged = {
+                        scope.launch {
+                            viewModel.onToggleTunnelOnMobileData()
+                        }
+                    }
+                )
+                ConfigurationToggle(stringResource(id = R.string.tunnel_on_ethernet),
+                    enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
+                    checked = settings.isTunnelOnEthernetEnabled,
+                    padding = screenPadding,
+                    onCheckChanged = {
+                        scope.launch {
+                            viewModel.onToggleTunnelOnEthernet()
+                        }
+                    }
+                )
+                ConfigurationToggle(
+                    stringResource(R.string.battery_saver),
+                    enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
+                    checked = settings.isBatterySaverEnabled,
+                    padding = screenPadding,
+                    onCheckChanged = {
+                        scope.launch {
+                            viewModel.onToggleBatterySaver()
+                        }
+                    }
+                )
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .padding(top = 5.dp),
+                    horizontalArrangement = Arrangement.Center
+                ) {
+                    TextButton(
+                        enabled = !settings.isAlwaysOnVpnEnabled,
+                        onClick = {
+                            //TODO fix logic for mobile only
+                            if(!isAllAutoTunnelPermissionsEnabled() && settings.isTunnelOnWifiEnabled) {
+                                val message = if(!isBackgroundLocationGranted) {
+                                    context.getString(R.string.background_location_required)
+                                } else if(viewModel.isLocationServicesNeeded()) {
+                                    context.getString(R.string.location_services_required)
+                                } else {
+                                    context.getString(R.string.precise_location_required)
+                                }
+                                showSnackbarMessage(message)
+                            } else scope.launch {
+                                viewModel.toggleAutoTunnel()
+                            }
+                        }) {
+                        val autoTunnelButtonText = if(settings.isAutoTunnelEnabled) stringResource(R.string.disable_auto_tunnel)
+                        else stringResource(id = R.string.enable_auto_tunnel)
+                        Text(autoTunnelButtonText)
+                    }
+                }
+            }
+        }
+        if(!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
             Surface(
                 tonalElevation = 2.dp,
                 shadowElevation = 2.dp,
                 shape = RoundedCornerShape(12.dp),
                 color = MaterialTheme.colorScheme.surface,
-                modifier =
+                modifier = Modifier
-                (
+                    .fillMaxWidth(fillMaxWidth)
-                        if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                    .height(IntrinsicSize.Min)
-                            Modifier
+                    .padding(bottom = 180.dp)
-                                .height(IntrinsicSize.Min)
-                                .fillMaxWidth(fillMaxWidth)
-                                .padding(top = 10.dp)
-                        } else {
-                            Modifier
-                                .fillMaxWidth(fillMaxWidth)
-                                .padding(top = 60.dp)
-                        }
-                        ).padding(bottom = 10.dp)
             ) {
                 Column(
                     horizontalAlignment = Alignment.Start,
                     verticalArrangement = Arrangement.Top,
                     modifier = Modifier.padding(15.dp)
                 ) {
-                    SectionTitle(
+                    SectionTitle(title = stringResource(id = R.string.other), padding = screenPadding)
-                        title = stringResource(id = R.string.auto_tunneling),
+                    ConfigurationToggle(stringResource(R.string.always_on_vpn_support),
-                        padding = screenPadding
+                        enabled = !settings.isAutoTunnelEnabled,
-                    )
+                        checked = settings.isAlwaysOnVpnEnabled,
-                    ConfigurationToggle(
-                        stringResource(id = R.string.tunnel_on_wifi),
-                        enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
-                        checked = settings.isTunnelOnWifiEnabled,
                         padding = screenPadding,
                         onCheckChanged = {
                             scope.launch {
-                                viewModel.onToggleTunnelOnWifi()
+                                viewModel.onToggleAlwaysOnVPN()
-                            }
-                        },
-                        modifier = Modifier.focusRequester(focusRequester)
-                    )
-                    AnimatedVisibility(visible = settings.isTunnelOnWifiEnabled) {
-                        Column {
-                            FlowRow(
-                                modifier = Modifier
-                                    .padding(screenPadding)
-                                    .fillMaxWidth(),
-                                horizontalArrangement = Arrangement.spacedBy(5.dp)
-                            ) {
-                                trustedSSIDs.forEach { ssid ->
-                                    ClickableIconButton(
-                                        onIconClick = {
-                                            scope.launch {
-                                                viewModel.onDeleteTrustedSSID(ssid)
-                                            }
-                                        },
-                                        text = ssid,
-                                        icon = Icons.Filled.Close,
-                                        enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled)
-                                    )
-                                }
-                                if (trustedSSIDs.isEmpty()) {
-                                    Text(
-                                        stringResource(R.string.none),
-                                        fontStyle = FontStyle.Italic,
-                                        color = Color.Gray
-                                    )
-                                }
-                            }
-                            OutlinedTextField(
-                                enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
-                                value = currentText,
-                                onValueChange = { currentText = it },
-                                label = { Text(stringResource(R.string.add_trusted_ssid)) },
-                                modifier =
-                                Modifier
-                                    .padding(start = screenPadding, top = 5.dp, bottom = 10.dp)
-                                    .onFocusChanged {
-                                        if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                                            keyboardController?.hide()
-                                        }
-                                    },
-                                maxLines = 1,
-                                keyboardOptions =
-                                KeyboardOptions(
-                                    capitalization = KeyboardCapitalization.None,
-                                    imeAction = ImeAction.Done
-                                ),
-                                keyboardActions =
-                                KeyboardActions(
-                                    onDone = {
-                                        saveTrustedSSID()
-                                    }
-                                ),
-                                trailingIcon = {
-                                    if (currentText != "") {
-                                        IconButton(onClick = { saveTrustedSSID() }) {
-                                            Icon(
-                                                imageVector = Icons.Outlined.Add,
-                                                contentDescription =
-                                                if (currentText == "") {
-                                                    stringResource(
-                                                        id = R.string.trusted_ssid_empty_description
-                                                    )
-                                                } else {
-                                                    stringResource(
-                                                        id = R.string.trusted_ssid_value_description
-                                                    )
-                                                },
-                                                tint = MaterialTheme.colorScheme.primary
-                                            )
-                                        }
-                                    }
-                                }
-                            )
-                        }
-                    }
-                    ConfigurationToggle(
-                        stringResource(R.string.tunnel_mobile_data),
-                        enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
-                        checked = settings.isTunnelOnMobileDataEnabled,
-                        padding = screenPadding,
-                        onCheckChanged = {
-                            scope.launch {
-                                viewModel.onToggleTunnelOnMobileData()
                             }
                         }
                     )
-                    ConfigurationToggle(
+                    ConfigurationToggle(stringResource(R.string.enabled_app_shortcuts),
-                        stringResource(id = R.string.tunnel_on_ethernet),
+                        enabled = true,
-                        enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
+                        checked = settings.isShortcutsEnabled,
-                        checked = settings.isTunnelOnEthernetEnabled,
                         padding = screenPadding,
                         onCheckChanged = {
                             scope.launch {
-                                viewModel.onToggleTunnelOnEthernet()
+                                viewModel.onToggleShortcutsEnabled()
-                            }
-                        }
-                    )
-                    ConfigurationToggle(
-                        stringResource(R.string.battery_saver),
-                        enabled = !(settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled),
-                        checked = settings.isBatterySaverEnabled,
-                        padding = screenPadding,
-                        onCheckChanged = {
-                            scope.launch {
-                                viewModel.onToggleBatterySaver()
                             }
                         }
                     )
                     Row(
                         verticalAlignment = Alignment.CenterVertically,
-                        modifier =
+                        modifier = Modifier
-                        Modifier
                             .fillMaxSize()
                             .padding(top = 5.dp),
                         horizontalArrangement = Arrangement.Center
                     ) {
                         TextButton(
-                            enabled = !settings.isAlwaysOnVpnEnabled,
+                            enabled = !didExportFiles,
                             onClick = {
-                                if (!isAllAutoTunnelPermissionsEnabled() && settings.isTunnelOnWifiEnabled) {
+                                showAuthPrompt = true
-                                    val message =
+                            }) {
-                                        if (!isBackgroundLocationGranted) {
+                            Text(stringResource(R.string.export_configs))
-                                            context.getString(R.string.background_location_required)
-                                        } else if (viewModel.isLocationServicesNeeded()) {
-                                            context.getString(R.string.location_services_required)
-                                        } else {
-                                            context.getString(R.string.precise_location_required)
-                                        }
-                                    showSnackbarMessage(message)
-                                } else {
-                                    scope.launch {
-                                        viewModel.toggleAutoTunnel()
-                                    }
-                                }
-                            }
-                        ) {
-                            val autoTunnelButtonText =
-                                if (settings.isAutoTunnelEnabled) {
-                                    stringResource(R.string.disable_auto_tunnel)
-                                } else {
-                                    stringResource(id = R.string.enable_auto_tunnel)
-                                }
-                            Text(autoTunnelButtonText)
                         }
                     }
                 }
             }
-            if (WgQuickBackend.hasKernelSupport()) {
+        }
-                Surface(
+        if(WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                    tonalElevation = 2.dp,
+            Spacer(modifier = Modifier.weight(.17f))
-                    shadowElevation = 2.dp,
-                    shape = RoundedCornerShape(12.dp),
-                    color = MaterialTheme.colorScheme.surface,
-                    modifier = Modifier
-                        .fillMaxWidth(fillMaxWidth)
-                        .padding(vertical = 10.dp)
-                ) {
-                    Column(
-                        horizontalAlignment = Alignment.Start,
-                        verticalArrangement = Arrangement.Top,
-                        modifier = Modifier.padding(15.dp)
-                    ) {
-                        SectionTitle(
-                            title = stringResource(id = R.string.kernel),
-                            padding = screenPadding
-                        )
-                        ConfigurationToggle(
-                            stringResource(R.string.use_kernel),
-                            enabled = !(
-                                    settings.isAutoTunnelEnabled || settings.isAlwaysOnVpnEnabled ||
-                                            (vpnState.value == Tunnel.State.UP)
-                                    ),
-                            checked = settings.isKernelEnabled,
-                            padding = screenPadding,
-                            onCheckChanged = {
-                                scope.launch {
-                                    try {
-                                        viewModel.onToggleKernelMode()
-                                    } catch (e: WgTunnelException) {
-                                        showSnackbarMessage(e.message)
-                                    }
-                                }
-                            }
-                        )
-                    }
-                }
-            }
-            if (!WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                Surface(
-                    tonalElevation = 2.dp,
-                    shadowElevation = 2.dp,
-                    shape = RoundedCornerShape(12.dp),
-                    color = MaterialTheme.colorScheme.surface,
-                    modifier = Modifier
-                        .fillMaxWidth(fillMaxWidth).padding(vertical = 10.dp)
-                        .padding(bottom = 140.dp)
-                ) {
-                    Column(
-                        horizontalAlignment = Alignment.Start,
-                        verticalArrangement = Arrangement.Top,
-                        modifier = Modifier.padding(15.dp)
-                    ) {
-                        SectionTitle(
-                            title = stringResource(id = R.string.other),
-                            padding = screenPadding
-                        )
-                        ConfigurationToggle(
-                            stringResource(R.string.always_on_vpn_support),
-                            enabled = !settings.isAutoTunnelEnabled,
-                            checked = settings.isAlwaysOnVpnEnabled,
-                            padding = screenPadding,
-                            onCheckChanged = {
-                                scope.launch {
-                                    viewModel.onToggleAlwaysOnVPN()
-                                }
-                            }
-                        )
-                        ConfigurationToggle(
-                            stringResource(R.string.enabled_app_shortcuts),
-                            enabled = true,
-                            checked = settings.isShortcutsEnabled,
-                            padding = screenPadding,
-                            onCheckChanged = {
-                                scope.launch {
-                                    viewModel.onToggleShortcutsEnabled()
-                                }
-                            }
-                        )
-                        Row(
-                            verticalAlignment = Alignment.CenterVertically,
-                            modifier =
-                            Modifier
-                                .fillMaxSize()
-                                .padding(top = 5.dp),
-                            horizontalArrangement = Arrangement.Center
-                        ) {
-                            TextButton(
-                                enabled = !didExportFiles,
-                                onClick = {
-                                    showAuthPrompt = true
-                                }
-                            ) {
-                                Text(stringResource(R.string.export_configs))
-                            }
-                        }
-                    }
-                }
-            }
-            if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
-                Spacer(modifier = Modifier.weight(.17f))
-            }
         }
     }
+}
+
+

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

@@ -6,45 +6,32 @@ import android.location.LocationManager
 import android.os.Build
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.wireguard.android.util.RootShell
 import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
 import com.zaneschepke.wireguardautotunnel.repository.TunnelConfigDao
-import com.zaneschepke.wireguardautotunnel.repository.datastore.DataStoreManager
 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.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelException
 import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.launch
-import timber.log.Timber
+import javax.inject.Inject
+
 
 @HiltViewModel
-class SettingsViewModel
+class SettingsViewModel @Inject constructor(private val application : Application,
-@Inject
+                                            private val tunnelRepo : TunnelConfigDao, private val settingsRepo : SettingsDoa
-constructor(
-    private val application: Application,
-    private val tunnelRepo: TunnelConfigDao,
-    private val settingsRepo: SettingsDoa,
-    val dataStoreManager: DataStoreManager,
-    private val rootShell: RootShell,
-    private val vpnService: VpnService
 ) : ViewModel() {
 
     private val _trustedSSIDs = MutableStateFlow(emptyList<String>())
     val trustedSSIDs = _trustedSSIDs.asStateFlow()
     private val _settings = MutableStateFlow(Settings())
     val settings get() = _settings.asStateFlow()
-    val vpnState get() = vpnService.state
     val tunnels get() = tunnelRepo.getAllFlow()
-    val disclosureShown = dataStoreManager.locationDisclosureFlow
-
     init {
         isLocationServicesEnabled()
         viewModelScope.launch(Dispatchers.IO) {
@@ -55,6 +42,7 @@ constructor(
             }
         }
     }
+
     suspend fun onSaveTrustedSSID(ssid: String) {
         val trimmed = ssid.trim()
         if (!_settings.value.trustedNetworkSSIDs.contains(trimmed)) {
@@ -66,11 +54,9 @@ constructor(
     }
 
     suspend fun onToggleTunnelOnMobileData() {
-        settingsRepo.save(
+        settingsRepo.save(_settings.value.copy(
-            _settings.value.copy(
+            isTunnelOnMobileDataEnabled = !_settings.value.isTunnelOnMobileDataEnabled
-                isTunnelOnMobileDataEnabled = !_settings.value.isTunnelOnMobileDataEnabled
+        ))
-            )
-        )
     }
 
     suspend fun onDeleteTrustedSSID(ssid: String) {
@@ -78,40 +64,34 @@ constructor(
         settingsRepo.save(_settings.value)
     }
 
-    private fun emitFirstTunnelAsDefault() =
+    private fun emitFirstTunnelAsDefault() = viewModelScope.async {
-        viewModelScope.async {
+        _settings.emit(_settings.value.copy(defaultTunnel = getFirstTunnelConfig().toString()))
-            _settings.emit(_settings.value.copy(defaultTunnel = getFirstTunnelConfig().toString()))
+    }
-        }
 
     suspend fun toggleAutoTunnel() {
-        if (_settings.value.isAutoTunnelEnabled) {
+        if(_settings.value.isAutoTunnelEnabled) {
             ServiceManager.stopWatcherService(application)
         } else {
-            if (_settings.value.defaultTunnel == null) {
+            if(_settings.value.defaultTunnel == null) {
                 emitFirstTunnelAsDefault().await()
             }
             val defaultTunnel = _settings.value.defaultTunnel
             ServiceManager.startWatcherService(application, defaultTunnel!!)
         }
-        settingsRepo.save(
+        settingsRepo.save(_settings.value.copy(
-            _settings.value.copy(
+            isAutoTunnelEnabled = !_settings.value.isAutoTunnelEnabled
-                isAutoTunnelEnabled = !_settings.value.isAutoTunnelEnabled
+        ))
-            )
-        )
     }
 
-    private suspend fun getFirstTunnelConfig(): TunnelConfig {
+    private suspend fun getFirstTunnelConfig() : TunnelConfig {
         return tunnelRepo.getAll().first()
     }
 
     suspend fun onToggleAlwaysOnVPN() {
-        if (_settings.value.defaultTunnel == null) {
+        if(_settings.value.defaultTunnel == null) {
             emitFirstTunnelAsDefault().await()
         }
-        val updatedSettings =
+        val updatedSettings = _settings.value.copy(isAlwaysOnVpnEnabled = !_settings.value.isAlwaysOnVpnEnabled)
-            _settings.value.copy(
-                isAlwaysOnVpnEnabled = !_settings.value.isAlwaysOnVpnEnabled
-            )
         emitSettings(updatedSettings)
         saveSettings(updatedSettings)
     }
@@ -127,71 +107,40 @@ constructor(
     }
 
     suspend fun onToggleTunnelOnEthernet() {
-        if (_settings.value.defaultTunnel == null) {
+        if(_settings.value.defaultTunnel == null) {
             emitFirstTunnelAsDefault().await()
         }
         _settings.emit(
-            _settings.value.copy(
+            _settings.value.copy(isTunnelOnEthernetEnabled = !_settings.value.isTunnelOnEthernetEnabled)
-                isTunnelOnEthernetEnabled = !_settings.value.isTunnelOnEthernetEnabled
-            )
         )
         settingsRepo.save(_settings.value)
     }
 
-    private fun isLocationServicesEnabled(): Boolean {
+    private fun isLocationServicesEnabled() : Boolean {
         val locationManager =
             application.getSystemService(Context.LOCATION_SERVICE) as LocationManager
         return locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
     }
 
-    fun isLocationServicesNeeded(): Boolean {
+    fun isLocationServicesNeeded() : Boolean {
-        return (!isLocationServicesEnabled() && Build.VERSION.SDK_INT > Build.VERSION_CODES.P)
+        return(!isLocationServicesEnabled() && Build.VERSION.SDK_INT > Build.VERSION_CODES.P)
     }
 
     suspend fun onToggleShortcutsEnabled() {
-        settingsRepo.save(
+        settingsRepo.save(_settings.value.copy(
-            _settings.value.copy(
+            isShortcutsEnabled = !_settings.value.isShortcutsEnabled
-                isShortcutsEnabled = !_settings.value.isShortcutsEnabled
+        ))
-            )
-        )
     }
 
     suspend fun onToggleBatterySaver() {
-        settingsRepo.save(
+        settingsRepo.save(_settings.value.copy(
-            _settings.value.copy(
+            isBatterySaverEnabled = !_settings.value.isBatterySaverEnabled
-                isBatterySaverEnabled = !_settings.value.isBatterySaverEnabled
+        ))
-            )
-        )
-    }
-
-    private suspend fun saveKernelMode(on: Boolean) {
-        settingsRepo.save(
-            _settings.value.copy(
-                isKernelEnabled = on
-            )
-        )
-    }
-
-    suspend fun onToggleKernelMode() {
-        if (!_settings.value.isKernelEnabled) {
-            try {
-                rootShell.start()
-                Timber.d("Root shell accepted!")
-                saveKernelMode(on = true)
-            } catch (e: RootShell.RootShellException) {
-                saveKernelMode(on = false)
-                throw WgTunnelException("Root shell denied!")
-            }
-        } else {
-            saveKernelMode(on = false)
-        }
     }
 
     suspend fun onToggleTunnelOnWifi() {
-        settingsRepo.save(
+        settingsRepo.save(_settings.value.copy(
-            _settings.value.copy(
+            isTunnelOnWifiEnabled = !_settings.value.isTunnelOnWifiEnabled
-                isTunnelOnWifiEnabled = !_settings.value.isTunnelOnWifiEnabled
+        ))
-            )
-        )
     }
 }

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

@@ -30,7 +30,6 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
@@ -45,25 +44,17 @@ import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.core.content.ContextCompat.startActivity
-import androidx.hilt.navigation.compose.hiltViewModel
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.zaneschepke.wireguardautotunnel.BuildConfig
 import com.zaneschepke.wireguardautotunnel.Constants
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.ui.screens.settings.SettingsViewModel
 
 @Composable
-fun SupportScreen(
+fun SupportScreen(padding : PaddingValues, focusRequester: FocusRequester) {
-    viewModel: SettingsViewModel = hiltViewModel(),
+
-    padding: PaddingValues,
-    focusRequester: FocusRequester
-) {
     val context = LocalContext.current
     val fillMaxWidth = .85f
 
-    val settings by viewModel.settings.collectAsStateWithLifecycle()
-
     fun openWebPage(url: String) {
         val webpage: Uri = Uri.parse(url)
         val intent = Intent(Intent.ACTION_VIEW, webpage)
@@ -71,174 +62,87 @@ fun SupportScreen(
     }
     
     fun launchEmail() {
-        val intent =
+        val intent = Intent(Intent.ACTION_SEND).apply {
-            Intent(Intent.ACTION_SEND).apply {
+            type = Constants.EMAIL_MIME_TYPE
-                type = Constants.EMAIL_MIME_TYPE
+            putExtra(Intent.EXTRA_EMAIL, context.getString(R.string.my_email))
-                putExtra(Intent.EXTRA_EMAIL, context.getString(R.string.my_email))
+            putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.email_subject))
-                putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.email_subject))
+        }
-            }
+        startActivity(context,createChooser(intent, context.getString(R.string.email_chooser)),null)
-        startActivity(
-            context,
-            createChooser(intent, context.getString(R.string.email_chooser)),
-            null
-        )
     }
 
-    Column(
+        Column(horizontalAlignment = Alignment.CenterHorizontally,
-        horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.Top,
-        verticalArrangement = Arrangement.Top,
+            modifier = Modifier
-        modifier =
+                .fillMaxSize()
-        Modifier
+                .verticalScroll(rememberScrollState())
-            .fillMaxSize()
+                .focusable()
-            .verticalScroll(rememberScrollState())
+                .padding(padding)) {
-            .focusable()
+            Surface(
-            .padding(padding)
+                tonalElevation = 2.dp,
-    ) {
+                shadowElevation = 2.dp,
-        Surface(
+                shape = RoundedCornerShape(12.dp),
-            tonalElevation = 2.dp,
+                color = MaterialTheme.colorScheme.surface,
-            shadowElevation = 2.dp,
+                modifier = (if (WireGuardAutoTunnel.isRunningOnAndroidTv(context))
-            shape = RoundedCornerShape(12.dp),
+                    Modifier
-            color = MaterialTheme.colorScheme.surface,
+                        .height(IntrinsicSize.Min)
-            modifier =
+                        .fillMaxWidth(fillMaxWidth)
-            (
+                        .padding(top = 10.dp)
-                    if (WireGuardAutoTunnel.isRunningOnAndroidTv(context)) {
+                else Modifier
-                        Modifier
+                    .fillMaxWidth(fillMaxWidth)
-                            .height(IntrinsicSize.Min)
+                    .padding(top = 20.dp)).padding(bottom = 25.dp)
-                            .fillMaxWidth(fillMaxWidth)
+            ) {
-                            .padding(top = 10.dp)
+                Column(modifier = Modifier.padding(20.dp)) {
-                    } else {
+                    Text(stringResource(R.string.thank_you), textAlign = TextAlign.Start, modifier = Modifier.padding(bottom = 20.dp), fontSize = 16.sp)
-                        Modifier
+                    Text(stringResource(id = R.string.support_help_text), textAlign = TextAlign.Start, fontSize = 16.sp, modifier = Modifier.padding(bottom = 20.dp))
-                            .fillMaxWidth(fillMaxWidth)
+                    TextButton(onClick = { openWebPage(context.resources.getString(R.string.docs_url)) }, modifier = Modifier.padding(vertical = 5.dp).focusRequester(focusRequester)) {
-                            .padding(top = 20.dp)
+                        Row(horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
-                    }
+                            Row {
-                    ).padding(bottom = 25.dp)
+                                Icon(Icons.Rounded.Book, stringResource(id = R.string.docs))
-        ) {
+                                Text(stringResource(id = R.string.docs_description), textAlign = TextAlign.Justify, modifier = Modifier.padding(start = 10.dp))
-            Column(modifier = Modifier.padding(20.dp)) {
+                            }
-                Text(
+                            Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
-                    stringResource(R.string.thank_you),
-                    textAlign = TextAlign.Start,
-                    modifier = Modifier.padding(bottom = 20.dp),
-                    fontSize = 16.sp
-                )
-                Text(
-                    stringResource(id = R.string.support_help_text),
-                    textAlign = TextAlign.Start,
-                    fontSize = 16.sp,
-                    modifier = Modifier.padding(bottom = 20.dp)
-                )
-                TextButton(onClick = {
-                    openWebPage(context.resources.getString(R.string.docs_url))
-                }, modifier = Modifier.padding(vertical = 5.dp).focusRequester(focusRequester)) {
-                    Row(
-                        horizontalArrangement = Arrangement.SpaceBetween,
-                        verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier.fillMaxWidth()
-                    ) {
-                        Row {
-                            Icon(Icons.Rounded.Book, stringResource(id = R.string.docs))
-                            Text(
-                                stringResource(id = R.string.docs_description),
-                                textAlign = TextAlign.Justify,
-                                modifier = Modifier.padding(start = 10.dp)
-                            )
                         }
-                        Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
                     }
-                }
+                    Divider(color = MaterialTheme.colorScheme.onBackground, thickness = 0.5.dp)
-                Divider(color = MaterialTheme.colorScheme.onBackground, thickness = 0.5.dp)
+                    TextButton(onClick = { openWebPage(context.resources.getString(R.string.discord_url)) }, modifier = Modifier.padding(vertical = 5.dp)) {
-                TextButton(
+                        Row(horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
-                    onClick = { openWebPage(context.resources.getString(R.string.discord_url)) },
+                            Row {
-                    modifier = Modifier.padding(vertical = 5.dp)
+                                Icon(imageVector = ImageVector.vectorResource(R.drawable.discord), stringResource(
-                ) {
+                                    id = R.string.discord), Modifier.size(25.dp))
-                    Row(
+                                Text(stringResource(id = R.string.discord_description), textAlign = TextAlign.Justify, modifier = Modifier.padding(start = 10.dp))
-                        horizontalArrangement = Arrangement.SpaceBetween,
+                            }
-                        verticalAlignment = Alignment.CenterVertically,
+                            Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
-                        modifier = Modifier.fillMaxWidth()
-                    ) {
-                        Row {
-                            Icon(
-                                imageVector = ImageVector.vectorResource(R.drawable.discord),
-                                stringResource(
-                                    id = R.string.discord
-                                ),
-                                Modifier.size(25.dp)
-                            )
-                            Text(
-                                stringResource(id = R.string.discord_description),
-                                textAlign = TextAlign.Justify,
-                                modifier = Modifier.padding(start = 10.dp)
-                            )
                         }
-                        Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
                     }
-                }
+                    Divider(color = MaterialTheme.colorScheme.onBackground, thickness = 0.5.dp)
-                Divider(color = MaterialTheme.colorScheme.onBackground, thickness = 0.5.dp)
+                    TextButton(onClick = { openWebPage(context.resources.getString(R.string.github_url)) }, modifier = Modifier.padding(vertical = 5.dp)) {
-                TextButton(
+                        Row(horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
-                    onClick = { openWebPage(context.resources.getString(R.string.github_url)) },
+                            Row {
-                    modifier = Modifier.padding(vertical = 5.dp)
+                                Icon(imageVector = ImageVector.vectorResource(R.drawable.github), stringResource(
-                ) {
-                    Row(
-                        horizontalArrangement = Arrangement.SpaceBetween,
-                        verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier.fillMaxWidth()
-                    ) {
-                        Row {
-                            Icon(
-                                imageVector = ImageVector.vectorResource(R.drawable.github),
-                                stringResource(
                                     id = R.string.github
-                                ),
+                                ), Modifier.size(25.dp))
-                                Modifier.size(25.dp)
+                                Text("Open an issue", textAlign = TextAlign.Justify, modifier = Modifier.padding(start = 10.dp))
-                            )
+                            }
-                            Text(
+                            Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
-                                "Open an issue",
-                                textAlign = TextAlign.Justify,
-                                modifier = Modifier.padding(start = 10.dp)
-                            )
                         }
-                        Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
                     }
-                }
+                    Divider(color = MaterialTheme.colorScheme.onBackground, thickness = 0.5.dp)
-                Divider(color = MaterialTheme.colorScheme.onBackground, thickness = 0.5.dp)
+                    TextButton(onClick = { launchEmail() }, modifier = Modifier.padding(vertical = 5.dp)) {
-                TextButton(
+                        Row(horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
-                    onClick = { launchEmail() },
+                            Row {
-                    modifier = Modifier.padding(vertical = 5.dp)
+                                Icon(Icons.Rounded.Mail, stringResource(id = R.string.email))
-                ) {
+                                Text(stringResource(id = R.string.email_description), textAlign = TextAlign.Justify, modifier = Modifier.padding(start = 10.dp))
-                    Row(
+                            }
-                        horizontalArrangement = Arrangement.SpaceBetween,
+                            Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
-                        verticalAlignment = Alignment.CenterVertically,
-                        modifier = Modifier.fillMaxWidth()
-                    ) {
-                        Row {
-                            Icon(Icons.Rounded.Mail, stringResource(id = R.string.email))
-                            Text(
-                                stringResource(id = R.string.email_description),
-                                textAlign = TextAlign.Justify,
-                                modifier = Modifier.padding(start = 10.dp)
-                            )
                         }
-                        Icon(Icons.Rounded.ArrowForward, stringResource(id = R.string.go))
                     }
                 }
             }
-        }
+            Spacer(modifier = Modifier.weight(1f))
-        Spacer(modifier = Modifier.weight(1f))
+            Text(stringResource(id = R.string.privacy_policy), style = TextStyle(textDecoration = TextDecoration.Underline),
-        Text(
+                modifier = Modifier.clickable {
-            stringResource(id = R.string.privacy_policy),
-            style = TextStyle(textDecoration = TextDecoration.Underline),
-            fontSize = 16.sp,
-            modifier =
-            Modifier.clickable {
                 openWebPage(context.resources.getString(R.string.privacy_policy_url))
-            }
+            })
-        )
+            Text("App version: ${BuildConfig.VERSION_NAME}", Modifier.padding(25.dp))
-        Row(
-            horizontalArrangement = Arrangement.spacedBy(25.dp),
-            verticalAlignment = Alignment.CenterVertically,
-            modifier = Modifier.padding(25.dp)
-        ) {
-            Text("Version: ${BuildConfig.VERSION_NAME}")
-            Text("Mode: ${if (settings.isKernelEnabled) "Kernel" else "Userspace" }")
         }
     }
-}

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

@@ -1,25 +0,0 @@
-package com.zaneschepke.wireguardautotunnel.ui.screens.support
-
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import com.zaneschepke.wireguardautotunnel.repository.SettingsDoa
-import com.zaneschepke.wireguardautotunnel.repository.model.Settings
-import dagger.hilt.android.lifecycle.HiltViewModel
-import javax.inject.Inject
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.launch
-
-@HiltViewModel
-class SupportViewModel @Inject constructor(
-    private val settingsRepo: SettingsDoa
-) : ViewModel() {
-    private val _settings = MutableStateFlow(Settings())
-    val settings get() = _settings.asStateFlow()
-    init {
-        viewModelScope.launch(Dispatchers.IO) {
-            _settings.value = settingsRepo.getAll().first()
-        }
-    }
-}

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/Color.kt

@@ -11,8 +11,7 @@ val Purple40 = Color(0xFF6650a4)
 val PurpleGrey40 = Color(0xFF625b71)
 val Pink40 = Color(0xFFFFFFFF)
 
-// status colors
+//status colors
 val brickRed = Color(0xFFCE4257)
-val corn = Color(0xFFFBEC5D)
 val pinkRed = Color(0xFFEF476F)
 val mint = Color(0xFF52B788)

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/Theme.kt

@@ -15,52 +15,51 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalView
 import androidx.core.view.WindowCompat
 
-private val DarkColorScheme =
+private val DarkColorScheme = darkColorScheme(
-    darkColorScheme(
+    //primary = Purple80,
-        // primary = Purple80,
+    primary = virdigris,
-        primary = virdigris,
+    secondary = virdigris,
-        secondary = virdigris,
+   // secondary = PurpleGrey80,
-        // secondary = PurpleGrey80,
+    tertiary = virdigris
-        tertiary = virdigris
+    //tertiary = Pink80
-        // tertiary = Pink80
+)
-    )
 
-private val LightColorScheme =
+private val LightColorScheme = lightColorScheme(
-    lightColorScheme(
+    primary = Purple40,
-        primary = Purple40,
+    secondary = PurpleGrey40,
-        secondary = PurpleGrey40,
+    tertiary = Pink40
-        tertiary = Pink40
+
-        /* Other default colors to override
+    /* Other default colors to override
-        background = Color(0xFFFFFBFE),
+    background = Color(0xFFFFFBFE),
-        surface = Color(0xFFFFFBFE),
+    surface = Color(0xFFFFFBFE),
-        onPrimary = Color.White,
+    onPrimary = Color.White,
-        onSecondary = Color.White,
+    onSecondary = Color.White,
-        onTertiary = Color.White,
+    onTertiary = Color.White,
-        onBackground = Color(0xFF1C1B1F),
+    onBackground = Color(0xFF1C1B1F),
-        onSurface = Color(0xFF1C1B1F),
+    onSurface = Color(0xFF1C1B1F),
-         */
+    */
-    )
+)
 
 @Composable
 fun WireguardAutoTunnelTheme(
-    // force dark theme
+    //force dark theme
-    darkTheme: Boolean = true,
+    darkTheme : Boolean = true,
-    // darkTheme: Boolean = isSystemInDarkTheme(),
+    //darkTheme: Boolean = isSystemInDarkTheme(),
     // Dynamic color is available on Android 12+
-    // turning off dynamic color for now
+    //turning off dynamic color for now
     dynamicColor: Boolean = false,
     content: @Composable () -> Unit
 ) {
-    val colorScheme =
-        when {
-            dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
-                val context = LocalContext.current
-                if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
-            }
 
-            darkTheme -> DarkColorScheme
+    val colorScheme = when {
-            else -> LightColorScheme
+        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            val context = LocalContext.current
+            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
         }
+
+        darkTheme -> DarkColorScheme
+        else -> LightColorScheme
+    }
     val view = LocalView.current
     if (!view.isInEditMode) {
         SideEffect {

app/src/main/java/com/zaneschepke/wireguardautotunnel/ui/theme/Type.kt

@@ -7,30 +7,28 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.sp
 
 // Set of Material typography styles to start with
-val Typography =
+val Typography = Typography(
-    Typography(
+    bodyLarge = TextStyle(
-        bodyLarge =
+        fontFamily = FontFamily.Default,
-        TextStyle(
+        fontWeight = FontWeight.Normal,
-            fontFamily = FontFamily.Default,
+        fontSize = 16.sp,
-            fontWeight = FontWeight.Normal,
+        lineHeight = 24.sp,
-            fontSize = 16.sp,
+        letterSpacing = 0.5.sp
-            lineHeight = 24.sp,
-            letterSpacing = 0.5.sp
-        )
-        /* Other default text styles to override
-        titleLarge = TextStyle(
-            fontFamily = FontFamily.Default,
-            fontWeight = FontWeight.Normal,
-            fontSize = 22.sp,
-            lineHeight = 28.sp,
-            letterSpacing = 0.sp
-        ),
-        labelSmall = TextStyle(
-            fontFamily = FontFamily.Default,
-            fontWeight = FontWeight.Medium,
-            fontSize = 11.sp,
-            lineHeight = 16.sp,
-            letterSpacing = 0.5.sp
-        )
-         */
     )
+    /* Other default text styles to override
+    titleLarge = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Normal,
+        fontSize = 22.sp,
+        lineHeight = 28.sp,
+        letterSpacing = 0.sp
+    ),
+    labelSmall = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Medium,
+        fontSize = 11.sp,
+        lineHeight = 16.sp,
+        letterSpacing = 0.5.sp
+    )
+    */
+)

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/NumberUtils.kt

@@ -6,23 +6,24 @@ import java.time.Instant
 import kotlin.math.pow
 
 object NumberUtils {
+
     private const val BYTES_IN_KB = 1024.0
     private val BYTES_IN_MB = BYTES_IN_KB.pow(2.0)
     private val keyValidationRegex = """^[A-Za-z0-9+/]{42}[AEIMQUYcgkosw480]=${'$'}""".toRegex()
 
-    fun bytesToMB(bytes: Long): BigDecimal {
+    fun bytesToMB(bytes : Long) : BigDecimal {
         return bytes.toBigDecimal().divide(BYTES_IN_MB.toBigDecimal())
     }
 
-    fun isValidKey(key: String): Boolean {
+    fun isValidKey(key : String) : Boolean {
         return key.matches(keyValidationRegex)
     }
 
-    fun generateRandomTunnelName(): String {
+    fun generateRandomTunnelName() : String {
         return "tunnel${(Math.random() * 100000).toInt()}"
     }
 
-    fun getSecondsBetweenTimestampAndNow(epoch: Long): Long? {
+    fun getSecondsBetweenTimestampAndNow(epoch : Long) : Long? {
         return if (epoch != 0L) {
             val time = Instant.ofEpochMilli(epoch)
             return Duration.between(time, Instant.now()).seconds

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/StorageUtil.kt

@@ -13,49 +13,36 @@ import java.time.Instant
 import java.util.zip.ZipEntry
 import java.util.zip.ZipOutputStream
 
-object FileUtils {
+object StorageUtil {
     private const val ZIP_FILE_MIME_TYPE = "application/zip"
-
+    private fun createDownloadsFileOutputStream(context: Context, fileName: String, mimeType : String = Constants.ALLOWED_FILE_TYPES) : OutputStream? {
-    private fun createDownloadsFileOutputStream(
-        context: Context,
-        fileName: String,
-        mimeType: String = Constants.ALLOWED_FILE_TYPES
-    ): OutputStream? {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             val resolver = context.contentResolver
-            val contentValues =
+            val contentValues = ContentValues().apply {
-                ContentValues().apply {
+                put(MediaColumns.DISPLAY_NAME, fileName)
-                    put(MediaColumns.DISPLAY_NAME, fileName)
+                put(MediaColumns.MIME_TYPE, mimeType)
-                    put(MediaColumns.MIME_TYPE, mimeType)
+                put(MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
-                    put(MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS)
+            }
-                }
             val uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues)
             if (uri != null) {
+
                 return resolver.openOutputStream(uri)
             }
         } else {
-            val target =
+            val target = File(
-                File(
+                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
-                    Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+                fileName
-                    fileName
+            )
-                )
             return target.outputStream()
         }
         return null
     }
 
-    fun saveFilesToZip(
+    fun saveFilesToZip(context: Context, files : List<File>) {
-        context: Context,
+        val zipOutputStream = createDownloadsFileOutputStream(context, "wg-export_${Instant.now().epochSecond}.zip", ZIP_FILE_MIME_TYPE)
-        files: List<File>
-    ) {
-        val zipOutputStream = createDownloadsFileOutputStream(
-            context,
-            "wg-export_${Instant.now().epochSecond}.zip",
-            ZIP_FILE_MIME_TYPE
-        )
         ZipOutputStream(zipOutputStream).use { zos ->
             files.forEach { file ->
-                val entry = ZipEntry(file.name)
+                val entry = ZipEntry( file.name)
                 zos.putNextEntry(entry)
                 if (file.isFile) {
                     file.inputStream().use { fis -> fis.copyTo(zos) }

app/src/main/java/com/zaneschepke/wireguardautotunnel/util/WgTunnelException.kt

@@ -3,12 +3,11 @@ package com.zaneschepke.wireguardautotunnel.util
 import com.wireguard.config.BadConfigException
 
 class WgTunnelException(e: Exception) : Exception() {
-    constructor(message: String) : this(Exception(message))
+    constructor(message : String) : this(Exception(message))
 
     override val message: String = generateExceptionMessage(e)
-
+    private fun generateExceptionMessage(e : Exception) : String {
-    private fun generateExceptionMessage(e: Exception): String {
+        return when(e) {
-        return when (e) {
             is BadConfigException -> "${e.section.name} ${e.location.name} ${e.reason.name}"
             else -> e.message ?: "Unknown error occurred"
         }

app/src/main/res/values/strings.xml

@@ -152,6 +152,5 @@
     <string name="email">Email</string>
     <string name="email_description">Send me an email</string>
     <string name="support_help_text">If you are experiencing issues, have improvement ideas, or just want to engage, the following resources are available:</string>
-    <string name="kernel">Kernel</string>
+
-    <string name="use_kernel">Use kernel module</string>
 </resources>

build.gradle.kts

@@ -12,5 +12,5 @@ plugins {
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.hilt.android) apply false
     kotlin("plugin.serialization").version(libs.versions.kotlin).apply(false)
-    alias(libs.plugins.ksp) apply false
+    alias(libs.plugins.ksp)  apply false
 }

buildSrc/src/main/kotlin/BuildHelper.kt

@@ -1,36 +1,29 @@
 import org.gradle.api.invocation.Gradle
 
 object BuildHelper {
-    private fun getCurrentFlavor(gradle: Gradle): String {
+    private fun getCurrentFlavor(gradle : Gradle): String {
         val taskRequestsStr = gradle.startParameter.taskRequests.toString()
-        val pattern: java.util.regex.Pattern =
+        val pattern: java.util.regex.Pattern = if (taskRequestsStr.contains("assemble")) {
-            if (taskRequestsStr.contains("assemble")) {
+            java.util.regex.Pattern.compile("assemble(\\w+)(Release|Debug)")
-                java.util.regex.Pattern.compile("assemble(\\w+)(Release|Debug)")
+        } else {
-            } else {
+            java.util.regex.Pattern.compile("bundle(\\w+)(Release|Debug)")
-                java.util.regex.Pattern.compile("bundle(\\w+)(Release|Debug)")
+        }
-            }
 
         val matcher = pattern.matcher(taskRequestsStr)
-        val flavor =
+        val flavor = if (matcher.find()) {
-            if (matcher.find()) {
+            matcher.group(1).lowercase()
-                matcher.group(1).lowercase()
+        } else {
-            } else {
+            print("NO FLAVOR FOUND")
-                print("NO FLAVOR FOUND")
+            ""
-                ""
+        }
-            }
         return flavor
     }
 
-    fun isGeneralFlavor(gradle: Gradle): Boolean {
+    fun isGeneralFlavor(gradle : Gradle) : Boolean {
         return getCurrentFlavor(gradle) == "general"
     }
-
+    fun isReleaseBuild(gradle: Gradle) : Boolean {
-    fun isReleaseBuild(gradle: Gradle): Boolean {
+        return (gradle.startParameter.taskNames.size > 0 && gradle.startParameter.taskNames[0].contains(
-        return (
+                "Release"))
-            gradle.startParameter.taskNames.size > 0 &&
-                gradle.startParameter.taskNames[0].contains(
-                    "Release",
-                )
-        )
     }
 }

buildSrc/src/main/kotlin/Constants.kt

@@ -1,7 +1,7 @@
 object Constants {
-    const val VERSION_NAME = "3.2.4"
+    const val VERSION_NAME = "3.2.3"
     const val JVM_TARGET = "17"
-    const val VERSION_CODE = 32400
+    const val VERSION_CODE = 32300
     const val TARGET_SDK = 34
     const val MIN_SDK = 26
     const val APP_ID = "com.zaneschepke.wireguardautotunnel"

fastlane/metadata/android/en-US/changelogs/32400.txt

@@ -1,5 +0,0 @@
-Enhancements:
-- Add basic WireGuard Kernel support
-- Improved location disclosure flow
-- Fix auto-tunnel permissions bug
-- Various other UI bug fixes

gradle/libs.versions.toml

@@ -1,12 +1,11 @@
 [versions]
 accompanist = "0.32.0"
-activityCompose = "1.8.2"
+activityCompose = "1.8.1"
 androidx-junit = "1.1.5"
 appcompat = "1.6.1"
 biometricKtx = "1.2.0-alpha05"
 coreGoogleShortcuts = "1.1.0"
 coreKtx = "1.12.0"
-datastorePreferences = "1.0.0"
 desugar_jdk_libs = "2.0.4"
 espressoCore = "3.5.1"
 firebase-crashlytics-gradle = "2.9.9"
@@ -18,7 +17,7 @@ kotlinx-serialization-json = "1.6.2"
 lifecycle-runtime-compose = "2.6.2"
 material-icons-extended = "1.5.4"
 material3 = "1.1.2"
-navigationCompose = "2.7.6"
+navigationCompose = "2.7.5"
 roomVersion = "2.6.1"
 timber = "5.0.1"
 tunnel = "1.0.20230706"
@@ -26,7 +25,7 @@ androidGradlePlugin = "8.2.0"
 kotlin="1.9.10"
 ksp="1.9.10-1.0.13"
 composeBom="2023.10.01"
-firebaseBom= "32.7.0"
+firebaseBom= "32.6.0"
 compose="1.5.4"
 crashlytics= "18.6.0"
 analytics="21.5.0"
@@ -46,7 +45,6 @@ accompanist-systemuicontroller = { module = "com.google.accompanist:accompanist-
 androidx-biometric-ktx = { module = "androidx.biometric:biometric-ktx", version.ref = "biometricKtx" }
 androidx-core = { module = "androidx.core:core", version.ref = "coreKtx" }
 androidx-core-google-shortcuts = { module = "androidx.core:core-google-shortcuts", version.ref = "coreGoogleShortcuts" }
-androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastorePreferences" }
 androidx-lifecycle-process = { module = "androidx.lifecycle:lifecycle-process", version.ref = "lifecycle-runtime-compose" }
 androidx-lifecycle-service = { module = "androidx.lifecycle:lifecycle-service", version.ref = "lifecycle-runtime-compose" }
 androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = "roomVersion" }
@@ -63,7 +61,6 @@ androidx-compose-ui-tooling-preview = { module="androidx.compose.ui:ui-tooling-p
 androidx-compose-ui = { module="androidx.compose.ui:ui", version.ref="compose" }
 
 #hilt
-androidx-room-testing = { module = "androidx.room:room-testing", version.ref = "roomVersion" }
 desugar_jdk_libs = { module = "com.android.tools:desugar_jdk_libs", version.ref = "desugar_jdk_libs" }
 hilt-android = { module = "com.google.dagger:hilt-android", version.ref = "hiltAndroid" }
 hilt-android-compiler = { module = "com.google.dagger:hilt-android-compiler", version.ref = "hiltAndroid" }

index.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+<body>
+    <span style="white-space: pre;">  
+Privacy Policy
+==============
+
+WG Tunnel provides an alternative Android client app for network tunnels using the WireGuard Protocol.
+
+Information you provide
+-----------------------
+
+No information provided to the App is transmitted to me or anyone else.
+The App does not collect information for purposes of our collection. Your
+data is not collected.
+
+Background Location
+------------------------
+
+This application does collect location information (specifically Wi-Fi ssid name) in the background
+for the auto tunnel feature. This information is not stored or transmitted but is simple collected 
+by the app to determine whether or not to turn on the VPN. 
+
+Updates to this document
+------------------------
+
+I will keep this document up-to-date. Your continued use of WG Tunnel confirms
+your acceptance of this Privacy Policy.
+
+Contact Me
+----------
+
+If you have questions about this Privacy Policy, please contact me
+zanecschepke@gmail.com or Discord (invite link on this repository).
+
+
+Effective as of May 24, 2023
+Updated May 24, 2023
+</span> 
+</body>
+</html>

settings.gradle.kts

@@ -15,3 +15,4 @@ dependencyResolutionManagement {
 
 rootProject.name = "WG Tunnel"
 include(":app")
+