fix: nightly release bug

Fixes bug where auto tunnel tile was the opposite state

Closes #241

.github/workflows/pre-release.yml

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

.github/workflows/release.yml

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

README.md

@@ -65,22 +65,20 @@ and on while on different networks. This app was created to offer a free solutio
 * Battery preservation measures
 * Restart tunnel on ping failure (beta)
 
+## Fdroid
+
+Want updates faster?
+
+Check out my personal [fdroid repository](https://github.com/zaneschepke/fdroid) to get updates the
+moment they are released.
+
 ## Docs
 
-Basic documentation of the feature and behaviors of this app can be
+Information about features, behaviors, and answers to common questions can be found in the
-found [here](https://zaneschepke.com/wgtunnel-docs/overview.html).
+app [documentation](https://zaneschepke.com/wgtunnel-docs/overview.html).
 
 The repository for these docs can be found [here](https://github.com/zaneschepke/wgtunnel-docs).
 
-## Contributing
-
-Any contributions in the form of feedback, issues, code, or translations are welcome and much
-appreciated!
-
-Please read
-the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct)
-before contributing.
-
 ## Translation
 
 This app is using [Weblate](https://weblate.org) to assist with translations.
@@ -102,4 +100,11 @@ And then build the app:
 $ ./gradlew assembleDebug
 ```
 
-</span>
+## Contributing
+
+Any contributions in the form of feedback, issues, code, or translations are welcome and much
+appreciated!
+
+Please read
+the [code of conduct](https://github.com/zaneschepke/wgtunnel?tab=coc-ov-file#contributor-code-of-conduct)
+before contributing.

app/build.gradle.kts

@@ -1,16 +1,17 @@
-import java.util.Properties
-
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.hilt.android)
     alias(libs.plugins.kotlinxSerialization)
     alias(libs.plugins.ksp)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.grgit)
 }
 
 android {
     namespace = Constants.APP_ID
     compileSdk = Constants.TARGET_SDK
+    compileSdkPreview = "VanillaIceCream"
 
     androidResources {
         generateLocaleConfig = true
@@ -35,44 +36,10 @@ android {
 
     signingConfigs {
         create(Constants.RELEASE) {
-            val properties =
+            storeFile = getStoreFile()
-                Properties().apply {
+            storePassword = getSigningProperty(Constants.STORE_PASS_VAR)
-                    // created local file for signing details
+            keyAlias = getSigningProperty(Constants.KEY_ALIAS_VAR)
-                    try {
+            keyPassword = getSigningProperty(Constants.KEY_PASS_VAR)
-                        load(file("signing.properties").reader())
-                    } catch (_: Exception) {
-                        load(file("signing_template.properties").reader())
-                    }
-                }
-
-            // try to get secrets from env first for pipeline build, then properties file for local
-            // build
-            storeFile =
-                file(
-                    System.getenv()
-                        .getOrDefault(
-                            Constants.KEY_STORE_PATH_VAR,
-                            properties.getProperty(Constants.KEY_STORE_PATH_VAR),
-                        ),
-                )
-            storePassword =
-                System.getenv()
-                    .getOrDefault(
-                        Constants.STORE_PASS_VAR,
-                        properties.getProperty(Constants.STORE_PASS_VAR),
-                    )
-            keyAlias =
-                System.getenv()
-                    .getOrDefault(
-                        Constants.KEY_ALIAS_VAR,
-                        properties.getProperty(Constants.KEY_ALIAS_VAR),
-                    )
-            keyPassword =
-                System.getenv()
-                    .getOrDefault(
-                        Constants.KEY_PASS_VAR,
-                        properties.getProperty(Constants.KEY_PASS_VAR),
-                    )
         }
     }
 
@@ -103,6 +70,12 @@ android {
             signingConfig = signingConfigs.getByName(Constants.RELEASE)
         }
         debug { isDebuggable = true }
+
+        create(Constants.NIGHTLY) {
+            initWith(getByName("release"))
+            defaultConfig.versionName = nightlyVersionName()
+            defaultConfig.versionCode = nightlyVersionCode()
+        }
     }
     flavorDimensions.add(Constants.TYPE)
     productFlavors {
@@ -112,9 +85,6 @@ android {
         }
         create("general") {
             dimension = Constants.TYPE
-            if (BuildHelper.isReleaseBuild(gradle) && BuildHelper.isGeneralFlavor(gradle)) {
-                //any plugins general specific
-            }
         }
     }
     compileOptions {
@@ -127,7 +97,6 @@ android {
         compose = true
         buildConfig = true
     }
-    composeOptions { kotlinCompilerExtensionVersion = Constants.COMPOSE_COMPILER_EXTENSION_VERSION }
     packaging { resources { excludes += "/META-INF/{AL2.0,LGPL2.1}" } }
 }
 
@@ -211,4 +180,15 @@ dependencies {
     // shortcuts
     implementation(libs.androidx.core)
     implementation(libs.androidx.core.google.shortcuts)
+
+    // splash
+    implementation(libs.androidx.core.splashscreen)
+}
+
+fun nightlyVersionCode() : Int {
+    return Constants.VERSION_CODE + Constants.NIGHTLY_CODE
+}
+
+fun nightlyVersionName() : String {
+    return Constants.VERSION_NAME + "-${grgitService.service.get().grgit.head().abbreviatedId}"
 }

app/src/main/AndroidManifest.xml

@@ -51,7 +51,7 @@
     </queries>
     <application
         android:name=".WireGuardAutoTunnel"
-        android:allowBackup="true"
+        android:allowBackup="false"
         android:banner="@drawable/ic_banner"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:enableOnBackInvokedCallback="true"
@@ -60,31 +60,35 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.WireguardAutoTunnel"
+        android:theme="@style/Theme.AppSplashScreen"
         tools:targetApi="tiramisu">
         <activity
-            android:name=".ui.MainActivity"
+            android:name=".ui.SplashActivity"
             android:exported="true"
-            android:theme="@style/Theme.WireguardAutoTunnel">
+            android:theme="@style/Theme.AppSplashScreen">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
                 <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
 
-                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
             </intent-filter>
             <meta-data
                 android:name="android.app.shortcuts"
                 android:resource="@xml/shortcuts" />
         </activity>
         <activity
-            android:name=".ui.CaptureActivityPortrait"
+            android:name=".ui.MainActivity"
-            android:screenOrientation="fullSensor"
+            android:exported="true"
-            android:stateNotNeeded="true"
+            android:theme="@style/Theme.WireguardAutoTunnel">
-            android:theme="@style/zxing_CaptureTheme"
+            <intent-filter>
-            android:windowSoftInputMode="stateAlwaysHidden"
+                <action android:name="android.service.quicksettings.action.QS_TILE_PREFERENCES" />
-            tools:ignore="DiscouragedApi" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name="com.journeyapps.barcodescanner.CaptureActivity"
+            android:screenOrientation="portrait"
+            tools:replace="screenOrientation" />
         <activity
             android:name=".service.shortcut.ShortcutsActivity"
             android:enabled="true"

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

@@ -6,34 +6,15 @@ import android.content.pm.PackageManager
 import android.os.StrictMode
 import android.os.StrictMode.ThreadPolicy
 import android.service.quicksettings.TileService
-import com.zaneschepke.logcatter.LocalLogCollector
-import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
-import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.service.tile.AutoTunnelControlTile
 import com.zaneschepke.wireguardautotunnel.service.tile.TunnelControlTile
 import com.zaneschepke.wireguardautotunnel.util.ReleaseTree
 import dagger.hilt.android.HiltAndroidApp
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
 import timber.log.Timber
-import xyz.teamgravity.pin_lock_compose.PinManager
-import javax.inject.Inject
 
 @HiltAndroidApp
 class WireGuardAutoTunnel : Application() {
 
-    @Inject
-    lateinit var localLogCollector: LocalLogCollector
-
-    @Inject
-    @ApplicationScope
-    lateinit var applicationScope: CoroutineScope
-
-    @Inject
-    @IoDispatcher
-    lateinit var ioDispatcher: CoroutineDispatcher
-
     override fun onCreate() {
         super.onCreate()
         instance = this
@@ -48,10 +29,6 @@ class WireGuardAutoTunnel : Application() {
                     .build(),
             )
         } else Timber.plant(ReleaseTree())
-        applicationScope.launch(ioDispatcher) {
-            PinManager.initialize(this@WireGuardAutoTunnel)
-            if (!isRunningOnAndroidTv()) localLogCollector.start()
-        }
     }
 
     companion object {

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

@@ -28,6 +28,7 @@ class DataStoreManager(
             booleanPreferencesKey("TUNNEL_RUNNING_FROM_MANUAL_START")
         val ACTIVE_TUNNEL = intPreferencesKey("ACTIVE_TUNNEL")
         val CURRENT_SSID = stringPreferencesKey("CURRENT_SSID")
+        val IS_PIN_LOCK_ENABLED = booleanPreferencesKey("PIN_LOCK_ENABLED")
     }
 
     // preferences

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

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

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

@@ -7,6 +7,9 @@ interface AppStateRepository {
     suspend fun isLocationDisclosureShown(): Boolean
     suspend fun setLocationDisclosureShown(shown: Boolean)
 
+    suspend fun isPinLockEnabled(): Boolean
+    suspend fun setPinLockEnabled(enabled: Boolean)
+
     suspend fun isBatteryOptimizationDisableShown(): Boolean
     suspend fun setBatteryOptimizationDisableShown(shown: Boolean)
 

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

@@ -17,6 +17,15 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
         dataStoreManager.saveToDataStore(DataStoreManager.LOCATION_DISCLOSURE_SHOWN, shown)
     }
 
+    override suspend fun isPinLockEnabled(): Boolean {
+        return dataStoreManager.getFromStore(DataStoreManager.IS_PIN_LOCK_ENABLED)
+            ?: GeneralState.PIN_LOCK_ENABLED_DEFAULT
+    }
+
+    override suspend fun setPinLockEnabled(enabled: Boolean) {
+        dataStoreManager.saveToDataStore(DataStoreManager.IS_PIN_LOCK_ENABLED, enabled)
+    }
+
     override suspend fun isBatteryOptimizationDisableShown(): Boolean {
         return dataStoreManager.getFromStore(DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN)
             ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT
@@ -65,11 +74,13 @@ class DataStoreAppStateRepository(private val dataStoreManager: DataStoreManager
             prefs?.let { pref ->
                 try {
                     GeneralState(
-                        locationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
+                        isLocationDisclosureShown = pref[DataStoreManager.LOCATION_DISCLOSURE_SHOWN]
                             ?: GeneralState.LOCATION_DISCLOSURE_SHOWN_DEFAULT,
-                        batteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
+                        isBatteryOptimizationDisableShown = pref[DataStoreManager.BATTERY_OPTIMIZE_DISABLE_SHOWN]
                             ?: GeneralState.BATTERY_OPTIMIZATION_DISABLE_SHOWN_DEFAULT,
-                        tunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
+                        isTunnelRunningFromManualStart = pref[DataStoreManager.TUNNEL_RUNNING_FROM_MANUAL_START]
+                            ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
+                        isPinLockEnabled = pref[DataStoreManager.IS_PIN_LOCK_ENABLED]
                             ?: GeneralState.TUNNELING_RUNNING_FROM_MANUAL_START_DEFAULT,
                     )
                 } catch (e: IllegalArgumentException) {

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

@@ -17,6 +17,7 @@ import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.components.SingletonComponent
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
+import javax.inject.Provider
 import javax.inject.Singleton
 
 @Module
@@ -51,9 +52,9 @@ class TunnelModule {
     @Provides
     @Singleton
     fun provideVpnService(
-        amneziaBackend: org.amnezia.awg.backend.Backend,
+        amneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
-        @Userspace userspaceBackend: Backend,
+        @Userspace userspaceBackend: Provider<Backend>,
-        @Kernel kernelBackend: Backend,
+        @Kernel kernelBackend: Provider<Backend>,
         appDataRepository: AppDataRepository,
         @ApplicationScope applicationScope: CoroutineScope,
         @IoDispatcher ioDispatcher: CoroutineDispatcher

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

@@ -4,9 +4,11 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
-import com.zaneschepke.wireguardautotunnel.util.goAsync
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
@@ -19,27 +21,36 @@ class BootReceiver : BroadcastReceiver() {
     @Inject
     lateinit var serviceManager: ServiceManager
 
-    override fun onReceive(context: Context?, intent: Intent?) = goAsync {
+    @Inject
-        if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return@goAsync
+    @ApplicationScope
+    lateinit var applicationScope: CoroutineScope
+
+    override fun onReceive(context: Context?, intent: Intent?) {
+        if (Intent.ACTION_BOOT_COMPLETED != intent?.action) return
         context?.run {
-            val settings = appDataRepository.settings.getSettings()
+            applicationScope.launch {
-            if (settings.isAutoTunnelEnabled) {
+                val settings = appDataRepository.settings.getSettings()
-                Timber.i("Starting watcher service from boot")
+                if(settings.isRestoreOnBootEnabled) {
-                serviceManager.startWatcherServiceForeground(context)
+                    if (settings.isAutoTunnelEnabled) {
-            }
+                        Timber.i("Starting watcher service from boot")
-            if (appDataRepository.appState.isTunnelRunningFromManualStart()) {
+                        serviceManager.startWatcherServiceForeground(context)
-                appDataRepository.appState.getActiveTunnelId()?.let {
+                    }
-                    Timber.i("Starting tunnel that was active before reboot")
+                    if (appDataRepository.appState.isTunnelRunningFromManualStart()) {
-                    serviceManager.startVpnServiceForeground(
+                        appDataRepository.appState.getActiveTunnelId()?.let {
-                        context,
+                            Timber.i("Starting tunnel that was active before reboot")
-                        appDataRepository.tunnels.getById(it)?.id,
+                            serviceManager.startVpnServiceForeground(
-                    )
+                                context,
+                                appDataRepository.tunnels.getById(it)?.id,
+                            )
+                            return@launch
+                        }
+                    }
+                    if (settings.isAlwaysOnVpnEnabled) {
+                        Timber.i("Starting vpn service from boot AOVPN")
+                        serviceManager.startVpnServiceForeground(context)
+                    }
                 }
             }
-            if (settings.isAlwaysOnVpnEnabled) {
-                Timber.i("Starting vpn service from boot AOVPN")
-                serviceManager.startVpnServiceForeground(context)
-            }
         }
     }
 }

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

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

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

@@ -390,19 +390,14 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
                         }
 
                         watcherState.isMobileDataConditionMet() -> {
-                            Timber.i("$autoTunnel - tunnel on on mobile data condition met")
+                            Timber.i("$autoTunnel - tunnel on mobile data condition met")
                             val mobileDataTunnel = getMobileDataTunnel()
                             val tunnel =
                                 mobileDataTunnel ?: appDataRepository.getPrimaryOrFirstTunnel()
-                            if (isTunnelDown()) return@collectLatest serviceManager.startVpnServiceForeground(
+                            if (isTunnelDown() || tunnelConfig?.isMobileDataTunnel == false) {
-                                context,
-                                tunnel?.id,
-                            )
-                            if (tunnelConfig?.isMobileDataTunnel == false && mobileDataTunnel != null) {
-                                Timber.i("$autoTunnel - tunnel connected on mobile data is not preferred condition met, switching to preferred")
                                 serviceManager.startVpnServiceForeground(
                                     context,
-                                    mobileDataTunnel.id,
+                                    tunnel?.id,
                                 )
                             }
                         }
@@ -417,8 +412,8 @@ class WireGuardConnectivityWatcherService : ForegroundService() {
                                 tunnelConfig == null) {
                                 Timber.i("$autoTunnel - tunnel on ssid not associated with current tunnel condition met")
                                 getSsidTunnel(watcherState.currentNetworkSSID)?.let {
-                                    Timber.i("Found tunnel associated with this SSID, bringing tunnel up")
+                                    Timber.i("Found tunnel associated with this SSID, bringing tunnel up: ${it.name}")
-                                    if (isTunnelDown()) serviceManager.startVpnServiceForeground(
+                                    if (isTunnelDown() || tunnelConfig?.id != it.id) serviceManager.startVpnServiceForeground(
                                         context,
                                         it.id,
                                     )

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

@@ -10,6 +10,7 @@ import android.graphics.Color
 import androidx.core.app.NotificationCompat
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.ui.MainActivity
+import com.zaneschepke.wireguardautotunnel.ui.SplashActivity
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 
@@ -59,7 +60,7 @@ class WireGuardNotification @Inject constructor(@ApplicationContext private val
                 }
         notificationManager.createNotificationChannel(channel)
         val pendingIntent: PendingIntent =
-            Intent(context, MainActivity::class.java).let { notificationIntent ->
+            Intent(context, SplashActivity::class.java).let { notificationIntent ->
                 PendingIntent.getActivity(
                     context,
                     0,

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

@@ -3,10 +3,15 @@ package com.zaneschepke.wireguardautotunnel.service.tile
 import android.os.Build
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ServiceLifecycleDispatcher
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
+import com.zaneschepke.wireguardautotunnel.module.ServiceScope
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
@@ -16,7 +21,7 @@ import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
-class AutoTunnelControlTile : TileService() {
+class AutoTunnelControlTile : TileService(), LifecycleOwner {
 
     @Inject
     lateinit var appDataRepository: AppDataRepository
@@ -24,15 +29,13 @@ class AutoTunnelControlTile : TileService() {
     @Inject
     lateinit var serviceManager: ServiceManager
 
-    @Inject
+    private val dispatcher = ServiceLifecycleDispatcher(this)
-    @ApplicationScope
-    lateinit var applicationScope: CoroutineScope
 
     private var manualStartConfig: TunnelConfig? = null
 
     override fun onStartListening() {
         super.onStartListening()
-        applicationScope.launch {
+        lifecycleScope.launch {
             val settings = appDataRepository.settings.getSettings()
             when (settings.isAutoTunnelEnabled) {
                 true -> {
@@ -44,7 +47,6 @@ class AutoTunnelControlTile : TileService() {
                         setTileDescription(this@AutoTunnelControlTile.getString(R.string.active))
                     }
                 }
-
                 false -> {
                     setTileDescription(this@AutoTunnelControlTile.getString(R.string.disabled))
                     setUnavailable()
@@ -61,9 +63,10 @@ class AutoTunnelControlTile : TileService() {
     override fun onClick() {
         super.onClick()
         unlockAndRun {
-            applicationScope.launch {
+            lifecycleScope.launch {
                 try {
                     appDataRepository.toggleWatcherServicePause()
+                    onStartListening()
                 } catch (e: Exception) {
                     Timber.e(e.message)
                 } finally {
@@ -98,4 +101,7 @@ class AutoTunnelControlTile : TileService() {
         }
         qsTile.updateTile()
     }
+
+    override val lifecycle: Lifecycle
+        get() = dispatcher.lifecycle
 }

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

@@ -3,6 +3,11 @@ package com.zaneschepke.wireguardautotunnel.service.tile
 import android.os.Build
 import android.service.quicksettings.Tile
 import android.service.quicksettings.TileService
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LifecycleService
+import androidx.lifecycle.ServiceLifecycleDispatcher
+import androidx.lifecycle.lifecycleScope
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
 import com.zaneschepke.wireguardautotunnel.module.ApplicationScope
@@ -11,14 +16,13 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
 import javax.inject.Inject
 
 @AndroidEntryPoint
-class TunnelControlTile : TileService() {
+class TunnelControlTile : TileService(), LifecycleOwner {
 
     @Inject
     lateinit var appDataRepository: AppDataRepository
@@ -29,38 +33,31 @@ class TunnelControlTile : TileService() {
     @Inject
     lateinit var serviceManager: ServiceManager
 
-    @Inject
+    private val dispatcher = ServiceLifecycleDispatcher(this)
-    @ApplicationScope
-    lateinit var applicationScope: CoroutineScope
 
     private var manualStartConfig: TunnelConfig? = null
 
-    private var job: Job? = null;
-
     override fun onStartListening() {
         super.onStartListening()
         Timber.d("On start listening called")
-        //TODO Fix this
+        lifecycleScope.launch {
-        if (job == null || job?.isCancelled == true) job = applicationScope.launch {
+            when (vpnService.getState()) {
-            vpnService.vpnState.collect { it ->
+                TunnelState.UP -> {
-                when (it.status) {
+                    setActive()
-                    TunnelState.UP -> {
+                    setTileDescription(vpnService.name)
-                        setActive()
-                        it.tunnelConfig?.name?.let { name -> setTileDescription(name) }
-                    }
-
-                    TunnelState.DOWN -> {
-                        setInactive()
-                        val config = appDataRepository.getStartTunnelConfig()?.also { config ->
-                            manualStartConfig = config
-                        } ?: appDataRepository.getPrimaryOrFirstTunnel()
-                        config?.let {
-                            setTileDescription(it.name)
-                        } ?: setUnavailable()
-                    }
-
-                    else -> setInactive()
                 }
+
+                TunnelState.DOWN -> {
+                    setInactive()
+                    val config = appDataRepository.getStartTunnelConfig()?.also { config ->
+                        manualStartConfig = config
+                    } ?: appDataRepository.getPrimaryOrFirstTunnel()
+                    config?.let {
+                        setTileDescription(it.name)
+                    } ?: setUnavailable()
+                }
+
+                else -> setInactive()
             }
         }
     }
@@ -73,7 +70,7 @@ class TunnelControlTile : TileService() {
     override fun onClick() {
         super.onClick()
         unlockAndRun {
-            applicationScope.launch {
+            lifecycleScope.launch {
                 try {
                     if (vpnService.getState() == TunnelState.UP) {
                         serviceManager.stopVpnServiceForeground(
@@ -119,4 +116,7 @@ class TunnelControlTile : TileService() {
         }
         qsTile.updateTile()
     }
+
+    override val lifecycle: Lifecycle
+        get() = dispatcher.lifecycle
 }

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

@@ -27,13 +27,14 @@ import kotlinx.coroutines.withContext
 import org.amnezia.awg.backend.Tunnel
 import timber.log.Timber
 import javax.inject.Inject
+import javax.inject.Provider
 
 class WireGuardTunnel
 @Inject
 constructor(
-    private val userspaceAmneziaBackend: org.amnezia.awg.backend.Backend,
+    private val userspaceAmneziaBackend: Provider<org.amnezia.awg.backend.Backend>,
-    @Userspace private val userspaceBackend: Backend,
+    @Userspace private val userspaceBackend: Provider<Backend>,
-    @Kernel private val kernelBackend: Backend,
+    @Kernel private val kernelBackend: Provider<Backend>,
     private val appDataRepository: AppDataRepository,
     @ApplicationScope private val applicationScope: CoroutineScope,
     @IoDispatcher private val ioDispatcher: CoroutineDispatcher
@@ -44,8 +45,6 @@ constructor(
 
     private var statsJob: Job? = null
 
-    private var backend: Backend = userspaceBackend
-
     private var backendIsWgUserspace = true
 
     private var backendIsAmneziaUserspace = false
@@ -55,12 +54,10 @@ constructor(
             appDataRepository.settings.getSettingsFlow().collect {
                 if (it.isKernelEnabled && (backendIsWgUserspace || backendIsAmneziaUserspace)) {
                     Timber.i("Setting kernel backend")
-                    backend = kernelBackend
                     backendIsWgUserspace = false
                     backendIsAmneziaUserspace = false
                 } else if (!it.isKernelEnabled && !it.isAmneziaEnabled && !backendIsWgUserspace) {
                     Timber.i("Setting WireGuard userspace backend")
-                    backend = userspaceBackend
                     backendIsWgUserspace = true
                     backendIsAmneziaUserspace = false
                 } else if (it.isAmneziaEnabled && !backendIsAmneziaUserspace) {
@@ -81,12 +78,13 @@ constructor(
                     TunnelConfig.configFromAmQuick(it.wgQuick)
                 }
             }
-            val state = userspaceAmneziaBackend.setState(this, tunnelState.toAmState(), config)
+            val state =
+                userspaceAmneziaBackend.get().setState(this, tunnelState.toAmState(), config)
             TunnelState.from(state)
         } else {
             Timber.i("Using Wg backend")
             val wgConfig = tunnelConfig?.let { TunnelConfig.configFromWgQuick(it.wgQuick) }
-            val state = backend.setState(
+            val state = backend().setState(
                 this,
                 tunnelState.toWgState(),
                 wgConfig,
@@ -99,6 +97,7 @@ constructor(
         return withContext(ioDispatcher) {
             try {
                 //TODO we need better error handling here
+                // need to bubble up these errors to the UI
                 val config = tunnelConfig ?: appDataRepository.getPrimaryOrFirstTunnel()
                 if (config != null) {
                     emitTunnelConfig(config)
@@ -111,6 +110,22 @@ constructor(
         }
     }
 
+    private fun backend(): Backend {
+        return when {
+            backendIsWgUserspace -> {
+                userspaceBackend.get()
+            }
+
+            !backendIsWgUserspace && !backendIsAmneziaUserspace -> {
+                kernelBackend.get()
+            }
+
+            else -> {
+                userspaceBackend.get()
+            }
+        }
+    }
+
     private fun emitTunnelState(state: TunnelState) {
         _vpnState.tryEmit(
             _vpnState.value.copy(
@@ -156,8 +171,10 @@ constructor(
     }
 
     override fun getState(): TunnelState {
-        return if (backendIsAmneziaUserspace) TunnelState.from(userspaceAmneziaBackend.getState(this))
+        return if (backendIsAmneziaUserspace) TunnelState.from(
-        else TunnelState.from(backend.getState(this))
+            userspaceAmneziaBackend.get().getState(this),
+        )
+        else TunnelState.from(backend().getState(this))
     }
 
     override fun getName(): String {
@@ -187,9 +204,13 @@ constructor(
     private fun startTunnelStatisticsJob() = applicationScope.launch(ioDispatcher) {
         while (true) {
             if (backendIsAmneziaUserspace) {
-                emitBackendStatistics(AmneziaStatistics(userspaceAmneziaBackend.getStatistics(this@WireGuardTunnel)))
+                emitBackendStatistics(
+                    AmneziaStatistics(
+                        userspaceAmneziaBackend.get().getStatistics(this@WireGuardTunnel),
+                    ),
+                )
             } else {
-                emitBackendStatistics(WireGuardStatistics(backend.getStatistics(this@WireGuardTunnel)))
+                emitBackendStatistics(WireGuardStatistics(backend().getStatistics(this@WireGuardTunnel)))
             }
             delay(Constants.VPN_STATISTIC_CHECK_INTERVAL)
         }

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

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

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

@@ -43,7 +43,7 @@ import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
-import com.zaneschepke.wireguardautotunnel.data.datastore.DataStoreManager
+import com.zaneschepke.wireguardautotunnel.data.repository.AppStateRepository
 import com.zaneschepke.wireguardautotunnel.data.repository.SettingsRepository
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.ui.common.navigation.BottomNavBar
@@ -61,14 +61,13 @@ import com.zaneschepke.wireguardautotunnel.util.StringValue
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
-import xyz.teamgravity.pin_lock_compose.PinManager
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : AppCompatActivity() {
 
     @Inject
-    lateinit var dataStoreManager: DataStoreManager
+    lateinit var appStateRepository: AppStateRepository
 
     @Inject
     lateinit var settingsRepository: SettingsRepository
@@ -82,17 +81,18 @@ class MainActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
+        val isPinLockEnabled = intent.extras?.getBoolean(SplashActivity.IS_PIN_LOCK_ENABLED_KEY)
+
         enableEdgeToEdge(navigationBarStyle = SystemBarStyle.dark(Color.Transparent.toArgb()))
 
-        // load preferences into memory and init data
         lifecycleScope.launch {
-            dataStoreManager.init()
             WireGuardAutoTunnel.requestTunnelTileServiceStateUpdate()
             val settings = settingsRepository.getSettings()
             if (settings.isAutoTunnelEnabled) {
                 serviceManager.startWatcherService(application.applicationContext)
             }
         }
+
         setContent {
             val appViewModel = hiltViewModel<AppViewModel>()
             val appUiState by appViewModel.appUiState.collectAsStateWithLifecycle()
@@ -201,10 +201,8 @@ class MainActivity : AppCompatActivity() {
                 ) { padding ->
                     NavHost(
                         navController,
-                        startDestination =
+                        startDestination = (if (isPinLockEnabled == true) Screen.Lock.route else Screen.Main.route),
-                        (if (PinManager.pinExists()) Screen.Lock.route else Screen.Main.route),
+                        modifier = Modifier
-                        modifier =
-                        Modifier
                             .padding(padding)
                             .fillMaxSize(),
                     ) {

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

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

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

@@ -15,6 +15,8 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
@@ -31,11 +33,12 @@ fun RowListItem(
     onClick: () -> Unit,
     rowButton: @Composable () -> Unit,
     expanded: Boolean,
-    statistics: TunnelStatistics?
+    statistics: TunnelStatistics?,
+    focusRequester: FocusRequester,
 ) {
     Box(
         modifier =
-        Modifier
+        Modifier.focusRequester(focusRequester)
             .animateContentSize()
             .clip(RoundedCornerShape(30.dp))
             .combinedClickable(

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

@@ -101,7 +101,6 @@ import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
 import com.zaneschepke.wireguardautotunnel.service.tunnel.HandshakeStatus
 import com.zaneschepke.wireguardautotunnel.service.tunnel.TunnelState
 import com.zaneschepke.wireguardautotunnel.ui.AppViewModel
-import com.zaneschepke.wireguardautotunnel.ui.CaptureActivityPortrait
 import com.zaneschepke.wireguardautotunnel.ui.Screen
 import com.zaneschepke.wireguardautotunnel.ui.common.RowListItem
 import com.zaneschepke.wireguardautotunnel.ui.common.screen.LoadingScreen
@@ -262,8 +261,6 @@ fun MainScreen(
             context.getString(R.string.scanning_qr),
         )
         scanOptions.setBeepEnabled(false)
-        scanOptions.captureActivity =
-            CaptureActivityPortrait::class.java
         scanLauncher.launch(scanOptions)
     }
 
@@ -492,6 +489,7 @@ fun MainScreen(
             }
             item {
                 if (uiState.settings.isAutoTunnelEnabled) {
+                    val itemFocusRequester = remember { FocusRequester() }
                     val autoTunnelingLabel = buildAnnotatedString {
                         append(stringResource(id = R.string.auto_tunneling))
                         append(": ")
@@ -519,22 +517,29 @@ fun MainScreen(
                         rowButton = {
                             if (uiState.settings.isAutoTunnelPaused) {
                                 TextButton(
+                                    modifier = Modifier.focusRequester(itemFocusRequester),
                                     onClick = { viewModel.resumeAutoTunneling() },
                                 ) {
                                     Text(stringResource(id = R.string.resume))
                                 }
                             } else {
                                 TextButton(
+                                    modifier = Modifier.focusRequester(itemFocusRequester),
                                     onClick = { viewModel.pauseAutoTunneling() },
                                 ) {
                                     Text(stringResource(id = R.string.pause))
                                 }
                             }
                         },
-                        onClick = {},
+                        onClick = {
+                            if (WireGuardAutoTunnel.isRunningOnAndroidTv()) {
+                                itemFocusRequester.requestFocus()
+                            }
+                        },
                         onHold = {},
                         expanded = false,
                         statistics = null,
+                        focusRequester = focusRequester
                     )
                 }
             }
@@ -565,6 +570,7 @@ fun MainScreen(
                     } else {
                         Color.Gray
                     })
+                val itemFocusRequester = remember { FocusRequester() }
                 val expanded = remember { mutableStateOf(false) }
                 RowListItem(
                     icon = {
@@ -610,11 +616,12 @@ fun MainScreen(
                             }
                         } else {
                             selectedTunnel = tunnel
-                            focusRequester.requestFocus()
+                            itemFocusRequester.requestFocus()
                         }
                     },
                     statistics = uiState.vpnState.statistics,
                     expanded = expanded.value,
+                    focusRequester = focusRequester,
                     rowButton = {
                         if (
                             tunnel.id == selectedTunnel?.id &&
@@ -670,7 +677,7 @@ fun MainScreen(
                             @Composable
                             fun TunnelSwitch() =
                                 Switch(
-                                    modifier = Modifier.focusRequester(focusRequester),
+                                    modifier = Modifier.focusRequester(itemFocusRequester),
                                     checked = checked,
                                     onCheckedChange = { checked ->
                                         if (!checked) expanded.value = false
@@ -681,7 +688,7 @@ fun MainScreen(
                                 Row {
                                     IconButton(
                                         onClick = {
-                                            if (uiState.settings.isAutoTunnelEnabled) {
+                                            if (uiState.settings.isAutoTunnelEnabled && !uiState.settings.isAutoTunnelPaused) {
                                                 appViewModel.showSnackbarMessage(
                                                     context.getString(R.string.turn_off_auto),
                                                 )

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

@@ -44,6 +44,7 @@ import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -70,7 +71,6 @@ import androidx.navigation.NavController
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
 import com.google.accompanist.permissions.isGranted
 import com.google.accompanist.permissions.rememberPermissionState
-import com.wireguard.android.backend.WgQuickBackend
 import com.zaneschepke.wireguardautotunnel.R
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.TunnelConfig
@@ -84,7 +84,6 @@ import com.zaneschepke.wireguardautotunnel.ui.common.text.SectionTitle
 import com.zaneschepke.wireguardautotunnel.util.getMessage
 import kotlinx.coroutines.launch
 import timber.log.Timber
-import xyz.teamgravity.pin_lock_compose.PinManager
 import java.io.File
 
 @OptIn(
@@ -103,9 +102,9 @@ fun SettingsScreen(
     val scope = rememberCoroutineScope()
     val scrollState = rememberScrollState()
     val interactionSource = remember { MutableInteractionSource() }
-    val pinExists = remember { mutableStateOf(PinManager.pinExists()) }
 
     val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val kernelSupport by viewModel.kernelSupport.collectAsStateWithLifecycle()
 
     val fineLocationState = rememberPermissionState(Manifest.permission.ACCESS_FINE_LOCATION)
     var currentText by remember { mutableStateOf("") }
@@ -117,6 +116,10 @@ fun SettingsScreen(
     val screenPadding = 5.dp
     val fillMaxWidth = .85f
 
+    LaunchedEffect(Unit) {
+        viewModel.checkKernelSupport()
+    }
+
     val startForResult =
         rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult()) { result: ActivityResult ->
             if (result.resultCode == Activity.RESULT_OK) {
@@ -591,7 +594,7 @@ fun SettingsScreen(
                             viewModel.onToggleAmnezia()
                         },
                     )
-                    if (WgQuickBackend.hasKernelSupport()) {
+                    if (kernelSupport) {
                         ConfigurationToggle(
                             stringResource(R.string.use_kernel),
                             enabled =
@@ -601,8 +604,10 @@ fun SettingsScreen(
                             checked = uiState.settings.isKernelEnabled,
                             padding = screenPadding,
                             onCheckChanged = {
-                                viewModel.onToggleKernelMode().onFailure {
+                                scope.launch {
-                                    appViewModel.showSnackbarMessage(it.getMessage(context))
+                                    viewModel.onToggleKernelMode().onFailure {
+                                        appViewModel.showSnackbarMessage(it.getMessage(context))
+                                    }
                                 }
                             },
                         )
@@ -646,15 +651,24 @@ fun SettingsScreen(
                         )
                     }
                     ConfigurationToggle(
-                        stringResource(R.string.enable_app_lock),
+                        stringResource(R.string.restart_at_boot),
                         enabled = true,
-                        checked = pinExists.value,
+                        checked = uiState.settings.isRestoreOnBootEnabled,
                         padding = screenPadding,
                         onCheckChanged = {
-                            if (pinExists.value) {
+                            viewModel.onToggleRestartAtBoot()
-                                PinManager.clearPin()
+                        },
-                                pinExists.value = PinManager.pinExists()
+                    )
+                    ConfigurationToggle(
+                        stringResource(R.string.enable_app_lock),
+                        enabled = true,
+                        checked = uiState.isPinLockEnabled,
+                        padding = screenPadding,
+                        onCheckChanged = {
+                            if (uiState.isPinLockEnabled) {
+                                viewModel.onPinLockDisabled()
                             } else {
+                                viewModel.onPinLockEnabled()
                                 navController.navigate(Screen.Lock.route)
                             }
                         },

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

@@ -9,5 +9,6 @@ data class SettingsUiState(
     val tunnels: List<TunnelConfig> = emptyList(),
     val vpnState: VpnState = VpnState(),
     val isLocationDisclosureShown: Boolean = true,
-    val isBatteryOptimizeDisableShown: Boolean = false
+    val isBatteryOptimizeDisableShown: Boolean = false,
+    val isPinLockEnabled: Boolean = false
 )

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

@@ -5,23 +5,32 @@ import android.location.LocationManager
 import androidx.core.location.LocationManagerCompat
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.wireguard.android.backend.WgQuickBackend
 import com.wireguard.android.util.RootShell
 import com.zaneschepke.wireguardautotunnel.WireGuardAutoTunnel
 import com.zaneschepke.wireguardautotunnel.data.domain.Settings
 import com.zaneschepke.wireguardautotunnel.data.repository.AppDataRepository
+import com.zaneschepke.wireguardautotunnel.module.IoDispatcher
 import com.zaneschepke.wireguardautotunnel.service.foreground.ServiceManager
 import com.zaneschepke.wireguardautotunnel.service.tunnel.VpnService
 import com.zaneschepke.wireguardautotunnel.util.Constants
 import com.zaneschepke.wireguardautotunnel.util.FileUtils
 import com.zaneschepke.wireguardautotunnel.util.WgTunnelExceptions
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import timber.log.Timber
+import xyz.teamgravity.pin_lock_compose.PinManager
 import java.io.File
 import javax.inject.Inject
+import javax.inject.Provider
 
 @HiltViewModel
 class SettingsViewModel
@@ -29,11 +38,15 @@ class SettingsViewModel
 constructor(
     private val appDataRepository: AppDataRepository,
     private val serviceManager: ServiceManager,
-    private val rootShell: RootShell,
+    private val rootShell: Provider<RootShell>,
     private val fileUtils: FileUtils,
+    @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
     vpnService: VpnService
 ) : ViewModel() {
 
+    private val _kernelSupport = MutableStateFlow(false)
+    val kernelSupport = _kernelSupport.asStateFlow()
+
     val uiState =
         combine(
             appDataRepository.settings.getSettingsFlow(),
@@ -45,8 +58,9 @@ constructor(
                 settings,
                 tunnels,
                 tunnelState,
-                generalState.locationDisclosureShown,
+                generalState.isLocationDisclosureShown,
-                generalState.batteryOptimizationDisableShown,
+                generalState.isBatteryOptimizationDisableShown,
+                generalState.isPinLockEnabled,
             )
         }
             .stateIn(
@@ -181,27 +195,29 @@ constructor(
         )
     }
 
-    fun onToggleKernelMode(): Result<Unit> {
+    suspend fun onToggleKernelMode(): Result<Unit> {
-        if (!uiState.value.settings.isKernelEnabled) {
+        return withContext(ioDispatcher) {
-            try {
+            if (!uiState.value.settings.isKernelEnabled) {
-                rootShell.start()
+                try {
-                Timber.i("Root shell accepted!")
+                    rootShell.get().start()
-                saveSettings(
+                    Timber.i("Root shell accepted!")
-                    uiState.value.settings.copy(
+                    saveSettings(
-                        isKernelEnabled = true,
+                        uiState.value.settings.copy(
-                        isAmneziaEnabled = false,
+                            isKernelEnabled = true,
-                    ),
+                            isAmneziaEnabled = false,
-                )
+                        ),
+                    )
 
-            } catch (e: RootShell.RootShellException) {
+                } catch (e: RootShell.RootShellException) {
-                Timber.e(e)
+                    Timber.e(e)
+                    saveKernelMode(on = false)
+                    return@withContext Result.failure(WgTunnelExceptions.RootDenied())
+                }
+            } else {
                 saveKernelMode(on = false)
-                return Result.failure(WgTunnelExceptions.RootDenied())
             }
-        } else {
+            Result.success(Unit)
-            saveKernelMode(on = false)
         }
-        return Result.success(Unit)
     }
 
     fun onToggleRestartOnPing() = viewModelScope.launch {
@@ -211,4 +227,31 @@ constructor(
             ),
         )
     }
+
+    fun checkKernelSupport() = viewModelScope.launch {
+        val kernelSupport = withContext(ioDispatcher) {
+            WgQuickBackend.hasKernelSupport()
+        }
+        _kernelSupport.update {
+            kernelSupport
+        }
+    }
+
+    fun onPinLockDisabled() = viewModelScope.launch {
+        PinManager.clearPin()
+        appDataRepository.appState.setPinLockEnabled(false)
+    }
+
+    fun onPinLockEnabled() = viewModelScope.launch {
+        PinManager.initialize(WireGuardAutoTunnel.instance)
+        appDataRepository.appState.setPinLockEnabled(true)
+    }
+
+    fun onToggleRestartAtBoot() = viewModelScope.launch {
+        saveSettings(
+            uiState.value.settings.copy(
+                isRestoreOnBootEnabled = !uiState.value.settings.isRestoreOnBootEnabled
+            )
+        )
+    }
 }

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

@@ -1,6 +1,5 @@
 package com.zaneschepke.wireguardautotunnel.util
 
-import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.pm.PackageInfo
 import com.zaneschepke.wireguardautotunnel.R
@@ -10,7 +9,6 @@ import com.zaneschepke.wireguardautotunnel.service.tunnel.statistics.TunnelStati
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.ObsoleteCoroutinesApi
 import kotlinx.coroutines.channels.ClosedReceiveChannelException
 import kotlinx.coroutines.channels.ReceiveChannel
@@ -19,7 +17,6 @@ import kotlinx.coroutines.channels.ticker
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.channelFlow
-import kotlinx.coroutines.launch
 import kotlinx.coroutines.selects.whileSelect
 import org.amnezia.awg.config.Config
 import timber.log.Timber
@@ -27,25 +24,8 @@ import java.math.BigDecimal
 import java.text.DecimalFormat
 import java.time.Duration
 import java.util.concurrent.ConcurrentLinkedQueue
-import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.coroutines.cancellation.CancellationException
 
-fun BroadcastReceiver.goAsync(
-    context: CoroutineContext = EmptyCoroutineContext,
-    block: suspend CoroutineScope.() -> Unit
-) {
-    val pendingResult = goAsync()
-    @OptIn(DelicateCoroutinesApi::class) // Must run globally; there's no teardown callback.
-    GlobalScope.launch(context) {
-        try {
-            block()
-        } finally {
-            pendingResult.finish()
-        }
-    }
-}
-
 fun BigDecimal.toThreeDecimalPlaceString(): String {
     val df = DecimalFormat("#.###")
     return df.format(this)

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

@@ -144,4 +144,11 @@
     <string name="general">Obecné</string>
     <string name="settings">Nastavení</string>
     <string name="support">Podpora</string>
+    <string name="app_name">WG Tunnel</string>
+    <string name="mtu">MTU</string>
+    <string name="db_name">wg-tunnel-db</string>
+    <string name="listen_port">Naslouchací port</string>
+    <string name="auto">(automaticky)</string>
+    <string name="kernel">Kernel</string>
+    <string name="backend">Backend</string>
 </resources>

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

@@ -135,7 +135,7 @@
     <string name="pin_created">Pin creado con éxito</string>
     <string name="enter_pin">Introduce tu pin</string>
     <string name="create_pin">Crear pin</string>
-    <string name="enable_app_lock">Bloqueo de app activado</string>
+    <string name="enable_app_lock">Activar el bloqueo de aplicaciones</string>
     <string name="restart_on_ping">Reiniciar al fallar ping (beta)</string>
     <string name="set_primary_tunnel">Establecer como túnel Principal</string>
     <string name="no_wifi_names_configured">No hay nombres Wi-Fi configurados para este túnel</string>
@@ -152,4 +152,9 @@
     <string name="watcher_channel_id">Canal del obvervador</string>
     <string name="watcher_channel_name">Canal de notificación del obvervador</string>
     <string name="prominent_background_location_message">La monitorización SSID Wi-Fi necesita de permiso de ubicación en segundo plano incluso si la app está cerrada. Mira el enlace a la Política de Privacidad en la pantalla de ayuda para más detalles.</string>
+    <string name="export_configs_failed">Error al exportar la configuración</string>
+    <string name="use_amnezia">"Utilizar el entorno de usuario de Amnezia "</string>
+    <string name="junk_packet_count">Recuento de paquetes basura</string>
+    <string name="backend">Backend</string>
+    <string name="junk_packet_minimum_size">Tamaño mínimo del paquete basura</string>
 </resources>

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

@@ -0,0 +1,162 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="watcher_notification_text_active">Monitoramento de mudanças do estado da rede: Ativo</string>
+    <string name="watcher_notification_text_paused">Monitoramento de mudanças do estado da rede: pausado</string>
+    <string name="tunnel_start_title">VPN conectada</string>
+    <string name="tunnel_on_ethernet">Túnel na ethernet</string>
+    <string name="save_changes">Salvar</string>
+    <string name="public_key">Chave pública</string>
+    <string name="addresses">Endereços</string>
+    <string name="dns_servers">Servidores DNS</string>
+    <string name="endpoint">Endpoint</string>
+    <string name="name">Nome</string>
+    <string name="restart">Reiniciar Túnel</string>
+    <string name="create_import">Criar do zero</string>
+    <string name="turn_off_auto">Esta ação precisa do auto-túnel desativado ou pausado</string>
+    <string name="rotate_keys">Revezar chaves</string>
+    <string name="private_key">Chave privada</string>
+    <string name="base64_key">Chave base64</string>
+    <string name="optional_no_recommend">(opcional, não recomendado)</string>
+    <string name="preshared_key">Chave pré-compartilhada</string>
+    <string name="seconds">segundos</string>
+    <string name="export_configs">Exportar configurações</string>
+    <string name="export_configs_failed">Falhou ao exportar configurações</string>
+    <string name="go">ir</string>
+    <string name="error_no_file_explorer">Nenhum explorador de arquivos instalado</string>
+    <string name="error_invalid_code">Código QR inválido</string>
+    <string name="auto_tunnel_title">Serviço de Auto-túnel</string>
+    <string name="excluded">excluído</string>
+    <string name="all">todos</string>
+    <string name="enter_pin">Digite seu pin</string>
+    <string name="use_tunnel_on_wifi_name">Usar túnel em wifi com nome</string>
+    <string name="auto_tun_on">Continuar auto-túnel</string>
+    <string name="auto_tun_off">Pausar auto-túnel</string>
+    <string name="version">Versão</string>
+    <string name="mode">Modo</string>
+    <string name="use_amnezia">"Usar Amnezia em modo usuário "</string>
+    <string name="junk_packet_count">Número de pacotes-lixo</string>
+    <string name="junk_packet_minimum_size">Tamanho mínimo de pacote-lixo</string>
+    <string name="junk_packet_maximum_size">Tamanho máximo de pacote-lixo</string>
+    <string name="init_packet_junk_size">Tamanho de pacote-lixo inicial</string>
+    <string name="response_packet_junk_size">Tamanho de resposta de pacote-lixo</string>
+    <string name="app_name">WG Tunnel</string>
+    <string name="no_tunnels">Nenhum túnel foi adicionado!</string>
+    <string name="error_file_extension">O arquivo não é .conf ou .zip</string>
+    <string name="prominent_background_location_message">Este recurso precisa de permissões de localização em segundo plano para habilitar o monitoramento do SSID da rede Wi-Fi mesmo quando o aplicativo está fechado. Para mais detalhes, por favor veja a Política de Privacidade na tela de Suporte.</string>
+    <string name="turn_off_tunnel">Esta ação só é possível com o túnel inativo</string>
+    <string name="enabled_app_shortcuts">Habilitar atalhos do aplicativo</string>
+    <string name="notification_permission_required">Necessita permissões de notificação.</string>
+    <string name="add_trusted_ssid">Adicionar nome de Wi-Fi confiável</string>
+    <string name="enable_auto_tunnel">Iniciar auto-túnel</string>
+    <string name="tunnels">Túneis</string>
+    <string name="disable_auto_tunnel">Parar auto-túnel</string>
+    <string name="tunnel_start_text">Conectado ao túnel</string>
+    <string name="trusted_ssid_empty_description">Digite o SSID</string>
+    <string name="no_thanks">Não, obrigado</string>
+    <string name="privacy_policy">Ver a Política de Privacidade</string>
+    <string name="okay">OK</string>
+    <string name="tunnel_mobile_data">Túnel em dados móveis</string>
+    <string name="one_tunnel_required">Pelo menos um túnel é necessário para usar este recurso</string>
+    <string name="prominent_background_location_title">Revelar a localização em segundo plano</string>
+    <string name="thank_you">Obrigado por usar o WG Tunnel!</string>
+    <string name="trusted_ssid_value_description">Envie o SSID</string>
+    <string name="open_file">Abrir Arquivo</string>
+    <string name="add_from_qr">Adicionar a partir de código QR</string>
+    <string name="add_tunnels_text">Adicionar a partir de arquivo ou zip</string>
+    <string name="tunnel_all">Todos os aplicativos pelo túnel</string>
+    <string name="icon">Ícone</string>
+    <string name="turn_on">Ligar</string>
+    <string name="qr_scan">Escanear o código QR</string>
+    <string name="tunnel_name">Nome do Túnel</string>
+    <string name="add_tunnel">Adicionar Túnel</string>
+    <string name="config_changes_saved">Mudanças nas configurações salvas.</string>
+    <string name="exclude">Excluir</string>
+    <string name="include">Incluir</string>
+    <string name="map">Mapa</string>
+    <string name="vpn_connection_failed">Falha na conexão</string>
+    <string name="mtu">MTU</string>
+    <string name="always_on_vpn_support">Permitir VPN sempre ligada</string>
+    <string name="allowed_ips">IPs Permitidos</string>
+    <string name="attempt_connection">Tentando conexão..</string>
+    <string name="peer">Par</string>
+    <string name="location_services_not_detected">Serviço de localização não foi detectado</string>
+    <string name="hint_search_packages">Procurar pacotes</string>
+    <string name="vpn_starting">Iniciando VPN</string>
+    <string name="other">Outro</string>
+    <string name="scanning_qr">Escaneando código QR</string>
+    <string name="none">Nenhum nome de Wi-Fi confiável</string>
+    <string name="auto_tunneling">Auto-túnel</string>
+    <string name="default_vpn_on">VPN Principal ligada</string>
+    <string name="vpn_on">VPN ligada</string>
+    <string name="vpn_off">VPN desligada</string>
+    <string name="listen_port">Porta de escuta</string>
+    <string name="default_vpn_off">VPN Principal desligada</string>
+    <string name="turn_on_tunnel">Esta ação precisa um túnel ativo</string>
+    <string name="done">Feito</string>
+    <string name="add_peer">Adicionar par</string>
+    <string name="interface_">Interface</string>
+    <string name="copy_public_key">Copiar chave pública</string>
+    <string name="comma_separated_list">Lista separada por vírgulas</string>
+    <string name="optional">(opcional)</string>
+    <string name="random">(aleatório)</string>
+    <string name="persistent_keepalive">Manter a conexão persistente (keepalive)</string>
+    <string name="cancel">Cancelar</string>
+    <string name="error_authentication_failed">Autenticação falhou</string>
+    <string name="error_authorization_failed">Autorização falhou</string>
+    <string name="restart_on_ping">Reiniciar em falha de ping (beta)</string>
+    <string name="background_location_required">Necessita a localização em segundo plano</string>
+    <string name="location_services_required">Necessita dos serviços de localização</string>
+    <string name="email_description">Me envie um email</string>
+    <string name="error_ssid_exists">SSID já existe</string>
+    <string name="delete_tunnel_message">Tem certeza que você quer apagar este túnel?</string>
+    <string name="yes">Sim</string>
+    <string name="precise_location_required">Necessita da localização precisa</string>
+    <string name="exported_configs_message">Configurações exportadas para downloads</string>
+    <string name="unknown_error">Ocorreu um erro desconhecido</string>
+    <string name="email_subject">Suporte para o WG Tunnel</string>
+    <string name="tunnel_on_wifi">Túnel em Wi-Fi não confiável</string>
+    <string name="error_none">Nenhum erro</string>
+    <string name="delete_tunnel">Apagar túnel</string>
+    <string name="email_chooser">Enviar um email…</string>
+    <string name="use_kernel">Usar o módulo do kernel</string>
+    <string name="discord_description">Juntar-se à comunidade</string>
+    <string name="docs_description">Ler a documentação</string>
+    <string name="support_help_text">Se você enfrentar problemas, tiver ideias para melhorias ou apenas quiser participar, os seguintes recursos estão disponíveis:</string>
+    <string name="error_root_denied">Shell Root negado</string>
+    <string name="location_services_missing_message">O aplicativo não detectou o serviço de localização habilitado no seu dispositivo. Dependendo do dispositivo, isto pode causar que a função de Wi-Fi não confiável falhe em ler o nome do Wi-Fi. Quer continuar mesmo assim?</string>
+    <string name="paused">pausado</string>
+    <string name="included">incluso</string>
+    <string name="resume">Continuar</string>
+    <string name="pause">Pausar</string>
+    <string name="active">ativo</string>
+    <string name="always_on_disabled">VPN sempre ligada tentou iniciar um túnel, mas este recurso está desligado nas configurações.</string>
+    <string name="open_issue">Abrir um problema</string>
+    <string name="tunneling_apps">Aplicativos em túnel</string>
+    <string name="no_email_detected">Nenhum aplicativo de email detectado</string>
+    <string name="no_browser_detected">Nenhum navegador detectado</string>
+    <string name="logs_saved">Registros salvos em downloads</string>
+    <string name="incorrect_pin">O Pin está errado</string>
+    <string name="auto">(automático)</string>
+    <string name="disabled">desligado</string>
+    <string name="read_logs">Ler os registros</string>
+    <string name="config_parse_error">Falha na interpretação das configurações</string>
+    <string name="pin_created">Pin criado com sucesso</string>
+    <string name="auto_on">Continuar auto-túnel</string>
+    <string name="create_pin">Criar um pin</string>
+    <string name="enable_app_lock">Ligar trava de aplicativo</string>
+    <string name="no_wifi_names_configured">Nenhum Wi-Fi configurado para este túnel</string>
+    <string name="edit_tunnel">Editar túnel</string>
+    <string name="mobile_data_tunnel">Selecionar como túnel em dados móveis</string>
+    <string name="set_primary_tunnel">Selecionar como túnel principal</string>
+    <string name="general">Geral</string>
+    <string name="userspace">Modo usuário</string>
+    <string name="support">Suporte</string>
+    <string name="kernel">Kernel</string>
+    <string name="auto_off">Pausar auto-túnel</string>
+    <string name="backend">Backend</string>
+    <string name="settings">Configurações</string>
+    <string name="unsure_how">se não tiver certeza em como continuar</string>
+    <string name="see_the">Veja o</string>
+    <string name="getting_started_guide">guia de início rápido</string>
+    <string name="error_file_format">Formato de arquivo de configuração inválido</string>
+</resources>

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

@@ -59,7 +59,7 @@
     <string name="cancel">Отмена</string>
     <string name="docs_description">Посмотреть документацию</string>
     <string name="discord_description">Присоединиться к сообществу</string>
-    <string name="email_chooser">Отправить письмо</string>
+    <string name="email_chooser">Отправить письмо…</string>
     <string name="add_trusted_ssid">Добавить доверенное имя сети Wi-Fi</string>
     <string name="included">включено</string>
     <string name="vpn_starting">Идёт запуск VPN</string>

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

@@ -1,4 +1,3 @@
-<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <string name="app_name">WG Tunnel</string>
     <string name="vpn_channel_id">VPN Kanalı</string>
@@ -8,38 +7,38 @@
     <string name="github_url" translatable="false">https://github.com/zaneschepke/wgtunnel/issues</string>
     <string name="docs_url" translatable="false">https://zaneschepke.com/wgtunnel-docs/overview.html</string>
     <string name="privacy_policy_url" translatable="false">https://zaneschepke.com/wgtunnel-docs/privacypolicy.html</string>
-    <string name="error_file_extension">Dosya bir .conf veya .zip değil</string>
+    <string name="error_file_extension">Dosya .conf veya .zip değil</string>
-    <string name="turn_off_tunnel">Eylem tünelin kapalı olmasını gerektiriyor</string>
+    <string name="turn_off_tunnel">İşlem için tünelin kapalı olması gerekiyor</string>
-    <string name="no_tunnels">Henüz bir tünel ekli değil!</string>
+    <string name="no_tunnels">Henüz tünel eklenmedi!</string>
     <string name="discord_url" translatable="false">https://discord.gg/rbRRNh6H7V</string>
-    <string name="watcher_notification_text_active">Ağ durumu değişikliklerini izleme: etkin</string>
+    <string name="watcher_notification_text_active">Ağ durum değişiklikleri izleniyor: aktif</string>
-    <string name="watcher_notification_text_paused">Ağ durumu değişikliklerini izleme: duraklatıldı</string>
+    <string name="watcher_notification_text_paused">Ağ durum değişiklikleri izleniyor: duraklatıldı</string>
     <string name="tunnel_start_title">VPN bağlandı</string>
-    <string name="tunnel_start_text">Tünele bağlı</string>
+    <string name="tunnel_start_text">Tünele bağlandı</string>
     <string name="notification_permission_required">Bildirim izni gerekli.</string>
-    <string name="add_trusted_ssid">Güvenilir Wi-Fi adı ekle</string>
+    <string name="add_trusted_ssid">Güvenilir wifi adı ekle</string>
     <string name="tunnels">Tüneller</string>
     <string name="enable_auto_tunnel">Otomatik tünellemeyi başlat</string>
     <string name="disable_auto_tunnel">Otomatik tünellemeyi durdur</string>
-    <string name="tunnel_mobile_data">Mobil veri üzerinde tünel</string>
+    <string name="tunnel_mobile_data">Mobil veride tünel</string>
-    <string name="one_tunnel_required">Bu özelliği kullanabilmek için en az bir tünel gereklidir.</string>
+    <string name="one_tunnel_required">Bu özelliği kullanmak için en az bir tünel gerekli</string>
-    <string name="privacy_policy">Gizlilik Politikası</string>
+    <string name="privacy_policy">Gizlilik Politikasını Görüntüle</string>
     <string name="okay">Tamam</string>
-    <string name="tunnel_on_ethernet">Ethernet üzerinde tünel</string>
+    <string name="tunnel_on_ethernet">Ethernet\'te tünel</string>
-    <string name="prominent_background_location_message">Bu özellik, uygulama kapalıyken bile Wi-Fi SSID izlemesini etkinleştirmek için arka plan konumu izni gerektirir. Daha fazla bilgi için lütfen Destek ekranında bağlantısı verilen Gizlilik Politikasına bakın.</string>
+    <string name="prominent_background_location_message">Bu özellik, uygulama kapalıyken bile Wi-Fi SSID izlemesini etkinleştirmek için arka plan konum iznine ihtiyaç duyar. Daha fazla ayrıntı için lütfen Destek ekranında bağlantısı verilen Gizlilik Politikasına bakın.</string>
     <string name="prominent_background_location_title">Arka Plan Konum Açıklaması</string>
-    <string name="thank_you">WG Tunnel\'i kullandığınız için teşekkür ederiz!</string>
+    <string name="thank_you">WG Tunnel\'ı kullandığınız için teşekkürler!</string>
-    <string name="trusted_ssid_empty_description">SSID\'yi gir</string>
+    <string name="trusted_ssid_empty_description">SSID girin</string>
     <string name="trusted_ssid_value_description">SSID\'yi gönder</string>
-    <string name="add_tunnels_text">Dosyadan veya ZIP\'ten ekle</string>
+    <string name="add_tunnels_text">Dosyadan veya zip\'ten ekle</string>
     <string name="open_file">Dosya Aç</string>
     <string name="add_from_qr">QR kodundan ekle</string>
-    <string name="qr_scan">QR kodu tarat</string>
+    <string name="qr_scan">QR Tarama</string>
-    <string name="tunnel_name">Tünel adı</string>
+    <string name="tunnel_name">Tünel Adı</string>
-    <string name="add_tunnel">Tünel ekle</string>
+    <string name="add_tunnel">Tünel Ekle</string>
     <string name="exclude">Hariç tut</string>
     <string name="include">Dahil et</string>
-    <string name="tunnel_all">Tüm uygulamaları dahil et</string>
+    <string name="tunnel_all">Tüm uygulamaları tünelle</string>
     <string name="config_changes_saved">Yapılandırma değişiklikleri kaydedildi.</string>
     <string name="save_changes">Kaydet</string>
     <string name="icon">Simge</string>
@@ -55,15 +54,15 @@
     <string name="endpoint">Uç nokta (endpoint)</string>
     <string name="name">Ad</string>
     <string name="restart">Tüneli Yeniden Başlat</string>
-    <string name="vpn_connection_failed">Bağlantı kurulamadı</string>
+    <string name="vpn_connection_failed">Bağlantı başarısız</string>
     <string name="always_on_vpn_support">Her Zaman Açık VPN\'e İzin Ver</string>
     <string name="location_services_not_detected">Konum Hizmetleri Algılanmadı</string>
-    <string name="hint_search_packages">Uygulama arayın</string>
+    <string name="hint_search_packages">Paketlerde ara</string>
-    <string name="attempt_connection">Bağlantı kurulmaya çalışılıyor..</string>
+    <string name="attempt_connection">Bağlantı deneniyor..</string>
     <string name="vpn_starting">VPN başlatılıyor</string>
     <string name="db_name">wg-tunnel-db</string>
-    <string name="scanning_qr">QR taranıyor</string>
+    <string name="scanning_qr">QR için taranıyor</string>
-    <string name="none">Güvenilir Wi-Fi adı yok</string>
+    <string name="none">Güvenilir wifi adı yok</string>
     <string name="other">Diğer</string>
     <string name="auto_tunneling">Otomatik tünelleme</string>
     <string name="vpn_on">VPN açık</string>
@@ -71,50 +70,50 @@
     <string name="default_vpn_on">Birincil VPN açık</string>
     <string name="default_vpn_off">Birincil VPN kapalı</string>
     <string name="create_import">Sıfırdan oluştur</string>
-    <string name="turn_off_auto">Eylem, otomatik tünelin devre dışı bırakılmasını veya duraklatılmasını gerektirir</string>
+    <string name="turn_off_auto">İşlem için otomatik tünelin devre dışı veya duraklatılmış olması gerekiyor</string>
-    <string name="turn_on_tunnel">Eylem aktif tünel gerektirir</string>
+    <string name="turn_on_tunnel">İşlem için aktif tünel gerekiyor</string>
-    <string name="add_peer">Eş (peer) ekle</string>
+    <string name="add_peer">Eş ekle</string>
     <string name="done">Tamam</string>
     <string name="interface_">Arayüz</string>
-    <string name="rotate_keys">Tuşları döndür</string>
+    <string name="rotate_keys">Anahtarları döndür</string>
     <string name="private_key">Özel anahtar</string>
     <string name="copy_public_key">Genel anahtarı kopyala</string>
-    <string name="base64_key">Base64 anahtarı</string>
+    <string name="base64_key">base64 anahtar</string>
-    <string name="comma_separated_list">Virgül ile ayrılmış liste ekleyin</string>
+    <string name="comma_separated_list">virgülle ayrılmış liste</string>
-    <string name="listen_port">Bağlantı noktası</string>
+    <string name="listen_port">Dinleme portu</string>
-    <string name="random">(Rastgele)</string>
+    <string name="random">(rastgele)</string>
-    <string name="optional">(İsteğe bağlı)</string>
+    <string name="optional">(isteğe bağlı)</string>
-    <string name="optional_no_recommend">(İsteğe bağlı, önerilmez)</string>
+    <string name="optional_no_recommend">(isteğe bağlı, önerilmez)</string>
-    <string name="preshared_key">Ön paylaşımlı anahtar</string>
+    <string name="preshared_key">Önceden paylaşılmış anahtar</string>
     <string name="seconds">saniye</string>
-    <string name="persistent_keepalive">Kalıcı olarak canlı tutma</string>
+    <string name="persistent_keepalive">Kalıcı canlı tutma</string>
     <string name="cancel">İptal</string>
     <string name="error_authentication_failed">Kimlik doğrulama başarısız oldu</string>
-    <string name="error_authorization_failed">Yetkilendirilemedi</string>
+    <string name="error_authorization_failed">Yetkilendirme başarısız oldu</string>
     <string name="enabled_app_shortcuts">Uygulama kısayollarını etkinleştir</string>
     <string name="export_configs">Yapılandırmaları dışa aktar</string>
-    <string name="location_services_required">Gerekli konum hizmetleri</string>
+    <string name="export_configs_failed">Yapılandırmaları dışa aktarma başarısız oldu</string>
+    <string name="location_services_required">Konum hizmetleri gerekli</string>
     <string name="background_location_required">Arka plan konumu gerekli</string>
-    <string name="precise_location_required">Kesin konum gerekli</string>
+    <string name="precise_location_required">Hassas konum gerekli</string>
     <string name="unknown_error">Bilinmeyen bir hata oluştu</string>
-    <string name="exported_configs_message">Yapılandırmalar indirilenler\'e aktarıldı</string>
+    <string name="exported_configs_message">Yapılandırmalar indirilenler klasörüne aktarıldı</string>
-    <string name="tunnel_on_wifi">Güvenilmeyen kablosuz internet bağlantısında tünel</string>
+    <string name="tunnel_on_wifi">Güvenilmeyen wifi\'da tünel</string>
     <string name="my_email" translatable="false">support@zaneschepke.com</string>
     <string name="email_subject">WG Tunnel Desteği</string>
-    <string name="email_chooser">Bir e-posta gönderin…</string>
+    <string name="email_chooser">E-posta gönder…</string>
     <string name="go">git</string>
     <string name="docs_description">Belgeleri oku</string>
     <string name="discord_description">Topluluğa katıl</string>
     <string name="email_description">Bana e-posta gönder</string>
-    <string name="support_help_text">Sorun yaşıyorsanız, iyileştirme fikirleriniz varsa veya sadece etkileşimde bulunmak istiyorsanız, aşağıdaki kaynaklar mevcuttur:</string>
+    <string name="support_help_text">Sorun yaşıyorsanız, iyileştirme fikirleriniz varsa veya sadece iletişime geçmek istiyorsanız, aşağıdaki kaynaklar mevcuttur:</string>
-    <string name="kernel">Çekirdek</string>
+    <string name="use_kernel">Kernel modülünü kullan</string>
-    <string name="use_kernel">Çekirdek modülünü kullan</string>
+    <string name="error_ssid_exists">SSID zaten mevcut</string>
-    <string name="error_ssid_exists">SSID zaten var</string>
+    <string name="error_root_denied">Root kabuğu reddedildi</string>
-    <string name="error_root_denied">Kök kabuğu reddedildi</string>
+    <string name="error_no_file_explorer">Dosya gezgini yüklü değil</string>
-    <string name="error_no_file_explorer">Yüklü dosya gezgini yok</string>
     <string name="error_invalid_code">Geçersiz QR kodu</string>
     <string name="error_none">Hata yok</string>
-    <string name="location_services_missing_message">Uygulama, cihazınızda etkinleştirilen herhangi bir konum hizmeti algılamıyor. Cihaza bağlı olarak bu, güvenilmeyen Wi-Fi özelliğinin Wi-Fi adını okuyamamasına neden olabilir. Yine de devam etmek ister misiniz?</string>
+    <string name="location_services_missing_message">Uygulama, cihazınızda etkinleştirilmiş herhangi bir konum hizmeti algılamıyor. Cihaza bağlı olarak, bu durum güvenilmeyen wifi özelliğinin wifi adını okumasını engelleyebilir. Yine de devam etmek istiyor musunuz?</string>
     <string name="auto_tunnel_title">Otomatik Tünel Hizmeti</string>
     <string name="delete_tunnel">Tüneli sil</string>
     <string name="delete_tunnel_message">Bu tüneli silmek istediğinizden emin misiniz?</string>
@@ -124,37 +123,58 @@
     <string name="paused">duraklatıldı</string>
     <string name="active">aktif</string>
     <string name="tunneling_apps">Tünellenen uygulamalar</string>
-    <string name="included">dahil edildi</string>
+    <string name="included">dahil</string>
-    <string name="excluded">hariç tutuldu</string>
+    <string name="excluded">hariç</string>
     <string name="all">tümü</string>
-    <string name="always_on_disabled">Her zaman açık VPN bir tünel başlatmaya çalıştı, ancak bu özellik ayarlarda devre dışı bırakıldı.</string>
+    <string name="always_on_disabled">Her Zaman Açık VPN bir tüneli başlatmaya çalıştı, ancak bu özellik ayarlarda devre dışı bırakılmış.</string>
     <string name="no_email_detected">E-posta uygulaması algılanmadı</string>
     <string name="no_browser_detected">Tarayıcı algılanmadı</string>
-    <string name="logs_saved">İndirilenlere kaydedilen günlükler</string>
+    <string name="logs_saved">Günlükler indirilenler klasörüne kaydedildi</string>
-    <string name="open_issue">Bir sorun bildir</string>
+    <string name="open_issue">Sorun bildir</string>
     <string name="read_logs">Günlükleri oku</string>
-    <string name="auto">(Otomatik)</string>
+    <string name="auto">(otomatik)</string>
-    <string name="config_parse_error">Yapılandırma kaydedilemedi</string>
+    <string name="config_parse_error">Yapılandırma ayrıştırılamadı</string>
-    <string name="incorrect_pin">PIN kodu yanlış</string>
+    <string name="incorrect_pin">PIN yanlış</string>
-    <string name="pin_created">Pin başarıyla oluşturuldu</string>
+    <string name="pin_created">PIN başarıyla oluşturuldu</string>
-    <string name="enter_pin">PIN kodunuzu girin</string>
+    <string name="enter_pin">PIN\'inizi girin</string>
-    <string name="create_pin">PIN kodu oluştur</string>
+    <string name="create_pin">PIN oluştur</string>
     <string name="enable_app_lock">Uygulama kilidini etkinleştir</string>
     <string name="restart_on_ping">Ping başarısız olduğunda yeniden başlat (beta)</string>
     <string name="mobile_data_tunnel">Mobil veri tüneli olarak ayarla</string>
     <string name="set_primary_tunnel">Birincil tünel olarak ayarla</string>
-    <string name="use_tunnel_on_wifi_name">Wi-Fi adında tünel kullan</string>
+    <string name="use_tunnel_on_wifi_name">Wifi adında tünel kullan</string>
-    <string name="no_wifi_names_configured">Bu tünel için yapılandırılmış Wi-Fi adı yok</string>
+    <string name="no_wifi_names_configured">Bu tünel için yapılandırılmış wifi adı yok</string>
     <string name="general">Genel</string>
     <string name="edit_tunnel">Tüneli düzenle</string>
-    <string name="disabled">Devre dışı</string>
+    <string name="disabled">devre dışı</string>
-    <string name="auto_on">Otomatik ayarlamayı sürdür</string>
+    <string name="auto_on">Otomatik tüneli devam ettir</string>
-    <string name="auto_off">Otomatik ayarlamayı duraklat</string>
+    <string name="auto_off">Otomatik tüneli duraklat</string>
-    <string name="auto_tun_on">Otomatik tüneli sürdür</string>
+    <string name="auto_tun_on">Otomatik tüneli devam ettir</string>
     <string name="auto_tun_off">Otomatik tüneli duraklat</string>
     <string name="version">Sürüm</string>
     <string name="mode">Mod</string>
     <string name="userspace">Kullanıcı alanı</string>
     <string name="settings">Ayarlar</string>
     <string name="support">Destek</string>
-</resources>
+    <string name="backend">Arka uç</string>
+    <string name="kernel">Çekirdek</string>
+    <string name="use_amnezia">"Amnezia kullanıcı alanını kullan "</string>
+    <string name="junk_packet_count">Gereksiz paket sayısı</string>
+    <string name="junk_packet_minimum_size">Gereksiz paket minimum boyutu</string>
+    <string name="junk_packet_maximum_size">Gereksiz paket maksimum boyutu</string>
+    <string name="init_packet_junk_size">Başlatma paketi gereksiz boyutu</string>
+    <string name="response_packet_junk_size">Yanıt paketi gereksiz boyutu</string>
+    <string name="init_packet_magic_header">Başlatma paketi sihirli başlığı</string>
+    <string name="response_packet_magic_header">Yanıt paketi sihirli başlığı</string>
+    <string name="transport_packet_magic_header">Taşıma paketi sihirli başlığı</string>
+    <string name="underload_packet_magic_header">Düşük yük paketi sihirli başlığı</string>
+    <string name="telegram_url" translatable="false">https://t.me/wgtunnel</string>
+    <string name="unsure_how">nasıl devam edeceğinizden emin değilseniz</string>
+    <string name="see_the">Bakın:</string>
+    <string name="getting_started_url" translatable="false">https://zaneschepke.com/wgtunnel-docs/getting-started.html</string>
+    <string name="getting_started_guide">başlangıç kılavuzu</string>
+    <string name="amnezia" translatable="false">Amnezia</string>
+    <string name="wireguard" translatable="false">WireGuard</string>
+    <string name="error_file_format">Geçersiz tünel yapılandırma formatı</string>
+    <string name="restart_at_boot">Önyüklemede yeniden başlat</string>
+</resources>

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

@@ -0,0 +1,169 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="comma_separated_list">список розділений комами</string>
+    <string name="no_tunnels">Тунелі ще не додані!</string>
+    <string name="app_name">WG Tunnel</string>
+    <string name="add_trusted_ssid">Додати ім\'я довіреної мережі Wi-Fi</string>
+    <string name="tunnels">Тунелі</string>
+    <string name="enable_auto_tunnel">Запустити авто-тунелі</string>
+    <string name="disable_auto_tunnel">Зупинити авто-тунелі</string>
+    <string name="okay">ОК</string>
+    <string name="tunnel_on_ethernet">Тунелювати Ethernet</string>
+    <string name="prominent_background_location_title">Фонова передача місцезнаходження</string>
+    <string name="trusted_ssid_value_description">Підтвердити SSID</string>
+    <string name="qr_scan">Сканувати QR</string>
+    <string name="tunnel_name">Ім\'я тунелю</string>
+    <string name="add_tunnel">Додати тунель</string>
+    <string name="include">Включити</string>
+    <string name="tunnel_all">Тунель для всіх додатків</string>
+    <string name="config_changes_saved">Зміни налаштувань збережено.</string>
+    <string name="icon">Іконка</string>
+    <string name="no_thanks">Ні, дякую</string>
+    <string name="default_vpn_off">Основний VPN вимк.</string>
+    <string name="turn_on_tunnel">Дія потребує активного тунелю</string>
+    <string name="rotate_keys">Оновити ключі</string>
+    <string name="private_key">Закритий ключ</string>
+    <string name="base64_key">Ключ в base64</string>
+    <string name="random">(випадково)</string>
+    <string name="optional">(необов\'язково)</string>
+    <string name="optional_no_recommend">(необов\'язково, не рекомендується)</string>
+    <string name="cancel">Скасувати</string>
+    <string name="export_configs_failed">Помилка експорту конфігурації</string>
+    <string name="location_services_required">Необхідно сервіси місцезнаходження</string>
+    <string name="precise_location_required">Необхідно доступ до точного місцезнаходження</string>
+    <string name="exported_configs_message">Експорт конфігурації в Завантаження</string>
+    <string name="email_chooser">Надіслати E-Mail…</string>
+    <string name="error_root_denied">Root доступ заборонено</string>
+    <string name="error_invalid_code">Некоректний QR-код</string>
+    <string name="error_none">Нема помилок</string>
+    <string name="logs_saved">Логи збережено в Завантаженнях</string>
+    <string name="config_parse_error">Помилка аналізу файлу конфігурації</string>
+    <string name="incorrect_pin">Невірний PIN-код</string>
+    <string name="use_tunnel_on_wifi_name">Використовувати тунель в мережі Wi-Fi</string>
+    <string name="disabled">відключено</string>
+    <string name="version">Версія</string>
+    <string name="mode">Режим</string>
+    <string name="transport_packet_magic_header">Заголовок транспортного пакету</string>
+    <string name="getting_started_guide">інструкція щодо початку роботи</string>
+    <string name="error_file_format">некоректний формат конфігурації тунелю</string>
+    <string name="watcher_notification_text_active">Моніторинг стану мережі: активний</string>
+    <string name="vpn_channel_name">Канал сповіщення VPN</string>
+    <string name="vpn_channel_id">Канал VPN</string>
+    <string name="error_file_extension">Файл не є .conf або .zip файлом</string>
+    <string name="turn_off_tunnel">Дія потребує вимкнення тунелю</string>
+    <string name="watcher_notification_text_paused">Моніторинг стану мережі: призупинено</string>
+    <string name="tunnel_start_text">Підключення до тунелю</string>
+    <string name="tunnel_start_title">VPN підключено</string>
+    <string name="notification_permission_required">Потрібен дозвіл на відображення сповіщень.</string>
+    <string name="tunnel_mobile_data">Тунелювати мобільні дані</string>
+    <string name="one_tunnel_required">Для використання даної функції потрібно налаштувати мінімум один тунель</string>
+    <string name="privacy_policy">Переглянути політику конфіденційності</string>
+    <string name="thank_you">Спасибі за використання WG Tunnel!</string>
+    <string name="prominent_background_location_message">Дана функція потребує фоновий доступ до служби місцезнаходження для моніторингу назви мереж Wi-Fi навіть коли додаток закрито. Для отримання додаткової інформації прочитайте політику приватності на екрані Підтримки.</string>
+    <string name="trusted_ssid_empty_description">Введіть SSID</string>
+    <string name="add_tunnels_text">Додати з файлу або архіву</string>
+    <string name="open_file">Відкрити файл</string>
+    <string name="exclude">Виключити</string>
+    <string name="add_from_qr">Додати з QR коду</string>
+    <string name="save_changes">Зберегти</string>
+    <string name="turn_on">Увімкнути</string>
+    <string name="map">Карта</string>
+    <string name="public_key">Публічний ключ</string>
+    <string name="addresses">Адреса</string>
+    <string name="allowed_ips">Дозволені IP</string>
+    <string name="dns_servers">DNS-сервери</string>
+    <string name="mtu">MTU</string>
+    <string name="peer">Пір</string>
+    <string name="endpoint">Кінцева точка</string>
+    <string name="hint_search_packages">Пошук програм</string>
+    <string name="name">Ім\'я</string>
+    <string name="vpn_connection_failed">Помилка з\'єднання</string>
+    <string name="restart">Перезапустити тунель</string>
+    <string name="always_on_vpn_support">Дозволили Always-ON VPN</string>
+    <string name="location_services_not_detected">Сервіси місце знаходження не знайдено</string>
+    <string name="db_name">wg-tunnel-db</string>
+    <string name="scanning_qr">Сканування QR коду</string>
+    <string name="attempt_connection">Спроба з\'єднання...</string>
+    <string name="other">Інше</string>
+    <string name="vpn_starting">Запуск VPN</string>
+    <string name="auto_tunneling">Авто-тунелювання</string>
+    <string name="none">Нема довірених мереж Wi-Fi</string>
+    <string name="vpn_on">VPN увімк.</string>
+    <string name="vpn_off">VPN вимк.</string>
+    <string name="default_vpn_on">Основний VPN увімк.</string>
+    <string name="create_import">Створити з нуля</string>
+    <string name="turn_off_auto">Необхідно вимкнути або призупинити авто-тунелювання</string>
+    <string name="add_peer">Додати peer</string>
+    <string name="done">Готово</string>
+    <string name="interface_">Інтерфейс</string>
+    <string name="copy_public_key">Копіювати відкритий ключ</string>
+    <string name="listen_port">Слухати порт</string>
+    <string name="preshared_key">Pre-shared key</string>
+    <string name="seconds">секунд</string>
+    <string name="persistent_keepalive">Persistent keepalive</string>
+    <string name="error_authorization_failed">Не вдалося авторизуватися</string>
+    <string name="enabled_app_shortcuts">Дозволити ярлики</string>
+    <string name="error_authentication_failed">Помилка автентифікації</string>
+    <string name="export_configs">Експорт конфігурації</string>
+    <string name="background_location_required">Необхідний фоновий доступ до місцезнаходження</string>
+    <string name="unknown_error">Невідома помилка</string>
+    <string name="tunnel_on_wifi">Тунелювати недовірені мережі Wi-Fi</string>
+    <string name="email_subject">Підтримка WG-Tunnel</string>
+    <string name="go">вперед</string>
+    <string name="docs_description">Переглянути документацію</string>
+    <string name="email_description">Відправити email автору</string>
+    <string name="discord_description">Приєднатися до спільноти</string>
+    <string name="support_help_text">Якщо у вас виникли проблеми, є ідеї щодо покращення, чи бажання долучитися, скористайтесь наступними ресурсами:</string>
+    <string name="use_kernel">Використовувати модуль режиму ядра</string>
+    <string name="error_ssid_exists">SSID вже існує</string>
+    <string name="error_no_file_explorer">Не знайдено файловий менеджер</string>
+    <string name="auto_tunnel_title">Сервіс авто-тунелювання</string>
+    <string name="delete_tunnel">Видалити тунель</string>
+    <string name="location_services_missing_message">Додаток не знайшов служб місце знаходження на вашому пристрої. На деяких пристроях це може привести до неможливості визначення назви мережі Wi-Fi і помилок функції недовірених Wi-Fi мереж. Все рівно хочете продовжити?</string>
+    <string name="included">включено</string>
+    <string name="delete_tunnel_message">Ви дійсно хочете видалити цей тунель?</string>
+    <string name="yes">Так</string>
+    <string name="active">активно</string>
+    <string name="resume">Відновити</string>
+    <string name="pause">Призупинити</string>
+    <string name="paused">призупинено</string>
+    <string name="tunneling_apps">Тунельовані додатки</string>
+    <string name="excluded">виключено</string>
+    <string name="always_on_disabled">Функція Always-on VPN спробувала запустити тунель, але функція вимкнена в налаштуваннях.</string>
+    <string name="auto">(авто)</string>
+    <string name="all">всі</string>
+    <string name="no_email_detected">Програми для надсилання email не знайдено</string>
+    <string name="open_issue">Повідомити про проблему</string>
+    <string name="read_logs">Переглянути логи</string>
+    <string name="no_browser_detected">Веб браузер не знайдено</string>
+    <string name="pin_created">PIN-код створено успішно</string>
+    <string name="enter_pin">Введіть PIN-код</string>
+    <string name="create_pin">Створити PINhкод</string>
+    <string name="enable_app_lock">Увімкнути блокування додатку</string>
+    <string name="edit_tunnel">Редагувати тунель</string>
+    <string name="auto_on">Відновити авто-тунель</string>
+    <string name="restart_on_ping">Перезапуск при помилці ping (бета)</string>
+    <string name="mobile_data_tunnel">Встановити як тунель для мобільних даних</string>
+    <string name="set_primary_tunnel">Встановити як основний тунель</string>
+    <string name="no_wifi_names_configured">Імена мереж Wi-Fi не налаштовано для цього тунелю</string>
+    <string name="general">Загальне</string>
+    <string name="auto_tun_off">Призупинити авто-тунель</string>
+    <string name="auto_off">Призупинити авто-тунель</string>
+    <string name="auto_tun_on">Відновити авто-тунель</string>
+    <string name="userspace">Користувача</string>
+    <string name="support">Підтримка</string>
+    <string name="settings">Налаштування</string>
+    <string name="use_amnezia">"Використовувати модуль Amnezia режиму користувача "</string>
+    <string name="backend">Модуль</string>
+    <string name="kernel">Модуль ядра</string>
+    <string name="junk_packet_count">Кількість «сміттєвих» пакетів</string>
+    <string name="junk_packet_minimum_size">Мінімальний розмір «сміттєвого» пакету</string>
+    <string name="junk_packet_maximum_size">Максимальний розмір «сміттєвого» пакету</string>
+    <string name="init_packet_junk_size">Початковий розмір «сміттєвого» пакету</string>
+    <string name="response_packet_junk_size">Розмір відповіді «сміттєвого» пакету</string>
+    <string name="init_packet_magic_header">Заголовок пакету ініціалізації</string>
+    <string name="underload_packet_magic_header">Заголовок пакету під навантаженням</string>
+    <string name="response_packet_magic_header">Заголовок пакету відповіді</string>
+    <string name="unsure_how">, якщо не впевнені що робити далі</string>
+    <string name="see_the">Дивіться</string>
+</resources>

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

@@ -176,4 +176,5 @@
     <string name="amnezia" translatable="false">Amnezia</string>
     <string name="wireguard" translatable="false">WireGuard</string>
     <string name="error_file_format">Invalid tunnel config format</string>
+    <string name="restart_at_boot">Restart on boot</string>
 </resources>

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

@@ -4,4 +4,12 @@
     <style name="Theme.WireguardAutoTunnel" parent="@style/Theme.AppCompat.NoActionBar">
         <item name="android:windowBackground">@color/black_background</item>
     </style>
-</resources>
+
+    <style name="Theme.AppSplashScreen" parent="Theme.SplashScreen">
+        <!--<item name="windowSplashScreenBackground">@color/white</item>-->
+        <!-- icon has to be a circle -->
+        <item name="windowSplashScreenAnimatedIcon">@mipmap/ic_launcher</item>
+        <item name="windowSplashScreenAnimationDuration">500</item>
+        <item name="postSplashScreenTheme">@style/Theme.WireguardAutoTunnel</item>
+    </style>
+</resources>

build.gradle.kts

@@ -5,4 +5,5 @@ plugins {
     alias(libs.plugins.kotlinxSerialization) apply false
     alias(libs.plugins.ksp) apply false
     alias(libs.plugins.androidLibrary) apply false
+    alias(libs.plugins.compose.compiler) apply false
 }

buildSrc/src/main/kotlin/BuildHelper.kt

@@ -1,47 +0,0 @@
-import org.gradle.api.invocation.Gradle
-import java.io.File
-
-object BuildHelper {
-    private fun getCurrentFlavor(gradle: Gradle): String {
-        val taskRequestsStr = gradle.startParameter.taskRequests.toString()
-        val pattern: java.util.regex.Pattern =
-            if (taskRequestsStr.contains("assemble")) {
-                java.util.regex.Pattern.compile("assemble(\\w+)(Release|Debug)")
-            } else {
-                java.util.regex.Pattern.compile("bundle(\\w+)(Release|Debug)")
-            }
-
-        val matcher = pattern.matcher(taskRequestsStr)
-        val flavor =
-            if (matcher.find()) {
-                matcher.group(1).lowercase()
-            } else {
-                print("NO FLAVOR FOUND")
-                ""
-            }
-        return flavor
-    }
-
-    fun getLocalProperty(key: String, file: String = "local.properties"): String? {
-        val properties = java.util.Properties()
-        val localProperties = File(file)
-        if (localProperties.isFile) {
-            java.io.InputStreamReader(java.io.FileInputStream(localProperties), Charsets.UTF_8)
-                .use { reader ->
-                    properties.load(reader)
-                }
-        } else return null
-        return properties.getProperty(key)
-    }
-
-    fun isGeneralFlavor(gradle: Gradle): Boolean {
-        return getCurrentFlavor(gradle) == "general"
-    }
-
-    fun isReleaseBuild(gradle: Gradle): Boolean {
-        return (gradle.startParameter.taskNames.size > 0 &&
-            gradle.startParameter.taskNames[0].contains(
-                "Release",
-            ))
-    }
-}

buildSrc/src/main/kotlin/Constants.kt

@@ -1,13 +1,11 @@
 object Constants {
-    const val VERSION_NAME = "3.4.5"
+    const val VERSION_NAME = "3.4.8"
     const val JVM_TARGET = "17"
-    const val VERSION_CODE = 34500
+    const val VERSION_CODE = 34800
     const val TARGET_SDK = 34
     const val MIN_SDK = 26
     const val APP_ID = "com.zaneschepke.wireguardautotunnel"
     const val APP_NAME = "wgtunnel"
-    const val COMPOSE_COMPILER_EXTENSION_VERSION = "1.5.11"
-
 
     const val STORE_PASS_VAR = "SIGNING_STORE_PASSWORD"
     const val KEY_ALIAS_VAR = "SIGNING_KEY_ALIAS"
@@ -15,5 +13,9 @@ object Constants {
     const val KEY_STORE_PATH_VAR = "KEY_STORE_PATH"
 
     const val RELEASE = "release"
+    const val NIGHTLY = "nightly"
+    const val DEBUG = "debug"
     const val TYPE = "type"
+
+    const val NIGHTLY_CODE = 42
 }

buildSrc/src/main/kotlin/Extensions.kt

@@ -0,0 +1,75 @@
+import org.gradle.api.Project
+import org.gradle.api.invocation.Gradle
+import java.io.File
+import java.util.Properties
+
+private fun getCurrentFlavor(gradle: Gradle): String {
+    val taskRequestsStr = gradle.startParameter.taskRequests.toString()
+    val pattern: java.util.regex.Pattern =
+        if (taskRequestsStr.contains("assemble")) {
+            java.util.regex.Pattern.compile("assemble(\\w+)(Release|Debug)")
+        } else {
+            java.util.regex.Pattern.compile("bundle(\\w+)(Release|Debug)")
+        }
+
+    val matcher = pattern.matcher(taskRequestsStr)
+    val flavor =
+        if (matcher.find()) {
+            matcher.group(1).lowercase()
+        } else {
+            print("NO FLAVOR FOUND")
+            ""
+        }
+    return flavor
+}
+
+fun getLocalProperty(key: String, file: String = "local.properties"): String? {
+    val properties = java.util.Properties()
+    val localProperties = File(file)
+    if (localProperties.isFile) {
+        java.io.InputStreamReader(java.io.FileInputStream(localProperties), Charsets.UTF_8)
+            .use { reader ->
+                properties.load(reader)
+            }
+    } else return null
+    return properties.getProperty(key)
+}
+
+fun Project.isGeneralFlavor(gradle: Gradle): Boolean {
+    return getCurrentFlavor(gradle) == "general"
+}
+
+
+fun Project.getSigningProperties() : Properties {
+    return Properties().apply {
+        // created local file for signing details
+        try {
+            load(file("signing.properties").reader())
+        } catch (_: Exception) {
+            load(file("signing_template.properties").reader())
+        }
+    }
+}
+
+fun Project.getStoreFile() : File {
+    return file(
+        System.getenv()
+            .getOrDefault(
+                Constants.KEY_STORE_PATH_VAR,
+                getSigningProperties().getProperty(Constants.KEY_STORE_PATH_VAR),
+            ),
+    )
+}
+
+fun Project.getSigningProperty(property: String) : String {
+    // try to get secrets from env first for pipeline build, then properties file for local
+    return System.getenv()
+        .getOrDefault(
+            property,
+            getSigningProperties().getProperty(property),
+        )
+}
+
+
+
+

fastlane/metadata/android/cs-CZ/title.txt

@@ -0,0 +1 @@
+WG Tunnel

fastlane/metadata/android/de-DE/changelogs/32300.txt

@@ -1,5 +1,5 @@
 Verbesserungen:
-- Unterstützung für Tunnelung nur bei Verwendung von Mobilen Daten
+- Unterstützung für Auto-Tunneln nur bei Verwendung von Mobilen Daten
 - Verbesserungen der Support Oberfläche
 - Aktualisierung der Ressourcenlinks
 - Verschiedene andere Fehlerbehebungen

fastlane/metadata/android/de-DE/changelogs/34500.txt

@@ -0,0 +1,5 @@
+Was ist neu?
+- Zusätzliche Sprachunterstützung
+- Fehler beim automatischen Tunneln von mobilen Daten behoben
+- AndroidTV-Schaltfläche für schwebende Aktionen behoben
+- Weitere Optimierungen und Erweiterungen

fastlane/metadata/android/de-DE/changelogs/34600.txt

@@ -0,0 +1,4 @@
+Was ist neu?
+- Behebt Auto-Tunneling-Fehler
+- Behebt Android-Backup-Fehler
+- Versionen erhöhen

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

@@ -0,0 +1,4 @@
+What's new:
+- Fixes auto tunneling bugs
+- Fixes android backup bug
+- Bump versions

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

@@ -0,0 +1,6 @@
+What's new:
+- Fix crashing issues
+- Improve tile performance
+- Re-enable pin lock
+- Make restart on boot a setting
+- Various performance and bug fixes

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

@@ -0,0 +1,5 @@
+What's new:
+- Fixes for AndroidTV UI tunnel control
+- Fixes portrait lock bug
+- Fixes pin lock bypass bug
+- Fixes auto tunnel tile bug

fastlane/metadata/android/es-ES/changelogs/33800.txt

@@ -0,0 +1,4 @@
+Novedades:
+- Config editar corrección de errores de interfaz de usuario
+- Añadir GrapheneOS primer lanzamiento AOVPN notificación
+- Versiones Bump

fastlane/metadata/android/es-ES/changelogs/33900.txt

@@ -0,0 +1,5 @@
+Novedades:
+- Añadir pantalla de registros
+- Añadir bloqueo local de aplicaciones
+- Añadir reiniciar vpn en ping fallido
+- Varios errores corregidos

fastlane/metadata/android/es-ES/changelogs/34000.txt

@@ -0,0 +1,5 @@
+Novedades:
+- Selección automática de túnel por nombre de WiFi
+- Control automático de túneles a través de mosaicos y atajos.
+- Reinicio automático del túnel manual después de un reinicio del sistema.
+- Varias correcciones de errores y mejoras de rendimiento

fastlane/metadata/android/es-ES/changelogs/34100.txt

@@ -0,0 +1,5 @@
+Novedades:
+- Mejora de la fiabilidad del túnel automático
+- Mejora de la sincronización de azulejos
+- Añadidos activos AndroidTV
+- Añadida huella digital al apk

fastlane/metadata/android/es-ES/full_description.txt

@@ -1,13 +1,14 @@
-Características:
+Características
 
-- Añadir túneles vía .conf file, zip, manualmente, o código QR
+- Añade túneles a través de un archivo .conf, zip, entrada manual o código QR
-- Conexión automática a la VPN basado en el SSID Wi-Fi, ethernet, o datos móviles
+- Conexión automática a VPN basada en Wi-Fi SSID, ethernet o datos móviles
-- División de túnel por aplicacióno con búsqueda
+- Túneles divididos por aplicación con búsqueda
-- Compatibilidad WireGuard para modos kernel y userspace
+- Soporte de WireGuard para los modos kernel y espacio de usuario
-- Compatibilidad con VPN Siempre-Activada
+- Soporte de Amnezia para el modo de espacio de usuario para protección DPI/censura
-- Exportar túmeles como zip
+- Compatible con VPN siempre activa
-- Añadido interruptor VPN en el Centro de Control
+- Exportación de túneles Amnezia y WireGuard a zip
-- Accesos directos estáticos para túnel principal para intergración con apps de automatización
+- Compatibilidad con Quick Tile para alternar entre VPN
-- Intents de apps de automatización para todos los túneles
+- Soporte de accesos directos estáticos para el túnel principal para la integración de automatización.
-- Inicio automático del servicio tras reinicio
+- Soporte de automatización de intenciones para todos los túneles
-- Medidas para ahorro de batería
+- Reinicio automático del servicio tras reiniciar
+- Medidas de conservación de la batería

fastlane/metadata/android/pt/changelogs/32100.txt

@@ -0,0 +1,3 @@
+Melhorias:
+- Corrige o bug de permissões do Android 9
+- Outras otimizações

fastlane/metadata/android/pt/changelogs/32200.txt

@@ -0,0 +1,5 @@
+Melhorias:
+- Adicionada estatísticas do túnel na tela principal
+- Melhoria de navegação de configurações na tela do AndroidTV
+- Removida a vibração nas notificações
+- Outras correções de bugs

fastlane/metadata/android/pt/full_description.txt

@@ -0,0 +1,14 @@
+Recursos
+
+- Adiciona túneis por arquivos .conf, zip, manualmente ou por código QR
+- Auto connecta à VPN baseado no nome (SSID) do Wi-Fi, ethernet ou dados móveis
+- Túnel dividido por aplicativo com busca
+- Suporte à WireGuard em modo kernel ou usuário
+- Suporte à Amnezia em modo usuário para proteção contra censura e DPI (Inspeção Profunda de Pacote)
+- Suporte à VPN sempre ligada
+- Exportação de túneis Amnezia e WireGuard em arquivos zip
+- Suporte à quick tile para ligar e desligar a VPN
+- Atalhos para o túnel principal para integração com automações
+- Intent automation para todos os túneis
+- Início automático depois de reiniciar o aparelho
+- Medidas para economia de bateria

fastlane/metadata/android/pt/short_description.txt

@@ -0,0 +1 @@
+Um cliente de VPN alternativo para WireGuard com recursos adicionais

fastlane/metadata/android/pt/title.txt

@@ -0,0 +1 @@
+WG Tunnel

fastlane/metadata/android/ru-RU/changelogs/34500.txt

@@ -0,0 +1,5 @@
+Что нового:
+- Добавлены новые переводы
+- Исправлена работа авто-туннеля на мобильном интернете
+- Исправлена проблема с плавающей кнопкой на Android TV
+- Другие оптимизации и улучшения

fastlane/metadata/android/ru-RU/changelogs/34600.txt

@@ -0,0 +1,4 @@
+Что нового:
+- Исправлены проблемы с работой авто-туннеля
+- Исправлена проблема с резервным копированием Android
+- Увеличен номер версии

fastlane/metadata/android/uk/full_description.txt

@@ -0,0 +1,14 @@
+Можливості:
+
+- Додавання тунелів з .conf, .zip файлів, ручним введенням або за допомогою QR коду
+- Автоматичне підключення до VPN залежно від імені мережі Wi-Fi, підключення по Ethernet чи мобільних даних
+- Розділення тунелів між програмами з пошуком
+- Підтримка Wireguard в режимі ядра і простору користувача
+- Підтримка Amnezia в режимі простору користувача для обходу DPI/інтернет цензури
+- Підтримка Always-ON VPN
+- Експорт тунелів Amnezia і Wireguard в zip файл
+- Підтримка плиток для швидкого переключенняVPN
+- Підтримка статичних ярликів основного тунелю для автоматизації
+- Підтримка автоматизації через intents для всіх тунелів
+- Автоматичний перезапуск сервісу після перезавантаження пристрою
+- Заходи по збережено заряду акумулятора

fastlane/metadata/android/uk/short_description.txt

@@ -0,0 +1 @@
+Альтернативний VPN-клієнт для WireGuard з додатковими функціями

fastlane/metadata/android/uk/title.txt

@@ -0,0 +1 @@
+WG Tunnel

gradle/libs.versions.toml

@@ -1,20 +1,20 @@
 [versions]
 accompanist = "0.34.0"
-activityCompose = "1.9.0"
+activityCompose = "1.9.1"
 amneziawgAndroid = "1.2.0"
-androidx-junit = "1.1.5"
+androidx-junit = "1.2.1"
-appcompat = "1.6.1"
+appcompat = "1.7.0"
-biometricKtx = "1.2.0-alpha05"
+biometricKtx = "1.4.0-alpha01"
 coreGoogleShortcuts = "1.1.0"
 coreKtx = "1.13.1"
 datastorePreferences = "1.1.1"
 desugar_jdk_libs = "2.0.4"
-espressoCore = "3.5.1"
+espressoCore = "3.6.1"
 hiltAndroid = "2.51.1"
 hiltNavigationCompose = "1.2.0"
 junit = "4.13.2"
-kotlinx-serialization-json = "1.6.3"
+kotlinx-serialization-json = "1.7.1"
-lifecycle-runtime-compose = "2.7.0"
+lifecycle-runtime-compose = "2.8.4"
 material3 = "1.2.1"
 multifabVersion = "1.1.0"
 navigationCompose = "2.7.7"
@@ -22,15 +22,16 @@ pinLockCompose = "1.0.3"
 roomVersion = "2.6.1"
 timber = "5.0.1"
 tunnel = "1.0.20230706"
-androidGradlePlugin = "8.4.1"
+androidGradlePlugin = "8.5.1"
-kotlin = "1.9.23"
+kotlin = "2.0.0"
-ksp = "1.9.23-1.0.19"
+ksp = "2.0.0-1.0.23"
-composeBom = "2024.05.00"
+composeBom = "2024.06.00"
-compose = "1.6.7"
+compose = "1.6.8"
 zxingAndroidEmbedded = "4.3.0"
+coreSplashscreen = "1.0.1"
+gradlePlugins-grgit="5.2.2"
 
 #plugins
-gradlePlugins-kotlinxSerialization = "1.9.23"
 material = "1.12.0"
 
 
@@ -74,6 +75,7 @@ androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "coreKtx"
 androidx-espresso-core = { module = "androidx.test.espresso:espresso-core", version.ref = "espressoCore" }
 androidx-hilt-navigation-compose = { module = "androidx.hilt:hilt-navigation-compose", version.ref = "hiltNavigationCompose" }
 androidx-junit = { module = "androidx.test.ext:junit", version.ref = "androidx-junit" }
+androidx-core-splashscreen = { module = "androidx.core:core-splashscreen", version.ref = "coreSplashscreen" }
 androidx-lifecycle-runtime-ktx = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "lifecycle-runtime-compose" }
 androidx-material3 = { module = "androidx.compose.material3:material3", version.ref = "material3" }
 androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "navigationCompose" }
@@ -96,5 +98,7 @@ android-application = { id = "com.android.application", version.ref = "androidGr
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 hilt-android = { id = "com.google.dagger.hilt.android", version.ref = "hiltAndroid" }
 ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
-kotlinxSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "gradlePlugins-kotlinxSerialization" }
+kotlinxSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
-androidLibrary = { id = "com.android.library", version.ref = "androidGradlePlugin" }
+androidLibrary = { id = "com.android.library", version.ref = "androidGradlePlugin" }
+compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+grgit = { id = "org.ajoberstar.grgit.service", version.ref = "gradlePlugins-grgit" }

logcatter/build.gradle.kts

@@ -22,13 +22,17 @@ android {
                 "proguard-rules.pro",
             )
         }
+
+        create("nightly") {
+            initWith(getByName("release"))
+        }
     }
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_1_8
+        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_17
     }
     kotlinOptions {
-        jvmTarget = "1.8"
+        jvmTarget = Constants.JVM_TARGET
     }
 }