Release v1.1.0

Author: iampedii

app/build.gradle.kts

@@ -5,9 +5,9 @@ plugins {
 
 val whiteDnsVersionCode = providers.gradleProperty("WHITE_DNS_VERSION_CODE")
     .map { it.toInt() }
-    .orElse(6)
+    .orElse(7)
 val whiteDnsVersionName = providers.gradleProperty("WHITE_DNS_VERSION_NAME")
-    .orElse("1.0.0")
+    .orElse("1.1.0")
 
 android {
     namespace = "shop.whitedns.client"
@@ -83,6 +83,7 @@ dependencies {
     implementation("androidx.compose.foundation:foundation")
     implementation("androidx.compose.material:material-icons-extended")
     implementation("androidx.compose.material3:material3")
+    implementation("com.google.zxing:core:3.5.3")
 
     testImplementation("junit:junit:4.13.2")
     testImplementation("org.json:json:20240303")

app/src/main/AndroidManifest.xml

@@ -26,12 +26,21 @@
 
         <activity
             android:name=".MainActivity"
-            android:exported="true">
+            android:exported="true"
+            android:launchMode="singleTop">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data android:scheme="stormdns" />
+            </intent-filter>
         </activity>
 
         <service
@@ -52,6 +61,20 @@
             android:foregroundServiceType="dataSync"
             android:process=":proxy" />
 
+        <service
+            android:name=".quicksettings.WhiteDnsTileService"
+            android:exported="true"
+            android:icon="@drawable/ic_notification"
+            android:label="@string/app_name"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+            <meta-data
+                android:name="android.service.quicksettings.TOGGLEABLE_TILE"
+                android:value="true" />
+        </service>
+
         <provider
             android:name="androidx.core.content.FileProvider"
             android:authorities="${applicationId}.fileprovider"

app/src/main/java/shop/whitedns/client/MainActivity.kt

@@ -127,6 +127,13 @@ class MainActivity : ComponentActivity() {
                 )
             }
         }
+        handleProfileLinkIntent(intent)
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        handleProfileLinkIntent(intent)
     }
 
     private fun openNotificationSettings() {
@@ -162,4 +169,21 @@ class MainActivity : ComponentActivity() {
             viewModel.refreshBatteryOptimizationStatusWithRetry()
         }
     }
+
+    private fun handleProfileLinkIntent(intent: Intent?) {
+        if (intent?.action != Intent.ACTION_VIEW || intent.data?.scheme != StormDnsScheme) {
+            return
+        }
+        if (intent.getBooleanExtra(ExtraProfileImportHandled, false)) {
+            return
+        }
+        val link = intent.dataString?.takeIf(String::isNotBlank) ?: return
+        intent.putExtra(ExtraProfileImportHandled, true)
+        viewModel.importProfileLink(link)
+    }
+
+    private companion object {
+        const val StormDnsScheme = "stormdns"
+        const val ExtraProfileImportHandled = "shop.whitedns.client.extra.PROFILE_IMPORT_HANDLED"
+    }
 }

app/src/main/java/shop/whitedns/client/model/WhiteDnsModels.kt

@@ -105,9 +105,9 @@ data class WhiteDnsSettings(
     val downloadCompression: Int = 2,
     val baseEncodeData: Boolean = false,
     val minUploadMtu: String = "40",
-    val minDownloadMtu: String = "100",
-    val maxUploadMtu: String = "64",
-    val maxDownloadMtu: String = "140",
+    val minDownloadMtu: String = "300",
+    val maxUploadMtu: String = "140",
+    val maxDownloadMtu: String = "3000",
     val mtuTestRetriesResolvers: String = "3",
     val mtuTestTimeoutResolvers: String = "2.0",
     val mtuTestParallelismResolvers: String = "100",
@@ -124,6 +124,8 @@ data class WhiteDnsSettings(
     val streamQueueInitialCapacity: String = "128",
     val orphanQueueInitialCapacity: String = "32",
     val dnsResponseFragmentStoreCapacity: String = "256",
+    val maxActiveStreams: String = "2048",
+    val localHandshakeTimeoutSeconds: String = "5.0",
     val socksUdpAssociateReadTimeoutSeconds: String = "30.0",
     val clientTerminalStreamRetentionSeconds: String = "45.0",
     val clientCancelledSetupRetentionSeconds: String = "120.0",
@@ -182,6 +184,8 @@ data class ResolvedWhiteDnsSettings(
     val streamQueueInitialCapacity: Int,
     val orphanQueueInitialCapacity: Int,
     val dnsResponseFragmentStoreCapacity: Int,
+    val maxActiveStreams: Int,
+    val localHandshakeTimeoutSeconds: Double,
     val socksUdpAssociateReadTimeoutSeconds: Double,
     val clientTerminalStreamRetentionSeconds: Double,
     val clientCancelledSetupRetentionSeconds: Double,
@@ -247,6 +251,19 @@ data class ConnectionProgressState(
         }
 }
 
+object ConnectionVerificationStatus {
+    const val Idle = "idle"
+    const val Checking = "checking"
+    const val Verified = "verified"
+    const val Failed = "failed"
+}
+
+data class ConnectionVerificationState(
+    val status: String = ConnectionVerificationStatus.Idle,
+    val message: String = "",
+    val checkedAtMillis: Long = 0,
+)
+
 data class WhiteDnsUiState(
     val connectionStatus: ConnectionStatus = ConnectionStatus.DISCONNECTED,
     val settings: WhiteDnsSettings = WhiteDnsSettings(),
@@ -259,6 +276,7 @@ data class WhiteDnsUiState(
     val connectionStats: ConnectionStats = ConnectionStats(),
     val resolverRuntimeState: ResolverRuntimeState = ResolverRuntimeState(),
     val connectionProgress: ConnectionProgressState = ConnectionProgressState(),
+    val connectionVerification: ConnectionVerificationState = ConnectionVerificationState(),
 )
 
 object WhiteDnsRuntimeProxy {
@@ -694,6 +712,8 @@ fun WhiteDnsSettings.resetAdvancedSettings(): WhiteDnsSettings {
         streamQueueInitialCapacity = defaults.streamQueueInitialCapacity,
         orphanQueueInitialCapacity = defaults.orphanQueueInitialCapacity,
         dnsResponseFragmentStoreCapacity = defaults.dnsResponseFragmentStoreCapacity,
+        maxActiveStreams = defaults.maxActiveStreams,
+        localHandshakeTimeoutSeconds = defaults.localHandshakeTimeoutSeconds,
         socksUdpAssociateReadTimeoutSeconds = defaults.socksUdpAssociateReadTimeoutSeconds,
         clientTerminalStreamRetentionSeconds = defaults.clientTerminalStreamRetentionSeconds,
         clientCancelledSetupRetentionSeconds = defaults.clientCancelledSetupRetentionSeconds,
@@ -740,13 +760,29 @@ private fun normalizeResolverText(raw: String): String {
 }
 
 private fun resolverTextTokens(raw: String): Sequence<String> {
-    return raw
+    val lines = raw
         .replace("\r\n", "\n")
         .replace('\r', '\n')
         .lineSequence()
         .map(String::trim)
         .filter { it.isNotEmpty() && !it.startsWith("#") }
-        .flatMap { line -> line.split(',', ';').asSequence() }
+        .toList()
+
+    val separators = if (detectResolverTextEntryType(lines) == ResolverTextEntryType.CommaSeparated) {
+        charArrayOf(',', ';')
+    } else {
+        charArrayOf()
+    }
+
+    return lines
+        .asSequence()
+        .flatMap { line ->
+            if (separators.isEmpty()) {
+                sequenceOf(line)
+            } else {
+                line.split(*separators).asSequence()
+            }
+        }
         .map(String::trim)
         .filter { it.isNotEmpty() && !it.startsWith("#") }
 }
@@ -757,6 +793,9 @@ private fun normalizeResolverEntry(entry: String): String? {
     val hostPort = splitResolverHostPort(entry) ?: return null
     val target = normalizeResolverTarget(hostPort.first) ?: return null
     val port = hostPort.second.toIntOrNull()?.takeIf { it in 1..65535 } ?: return null
+    if (port == DefaultResolverPort) {
+        return target
+    }
     return if (resolverTargetNeedsBrackets(target)) {
         "[$target]:$port"
     } else {
@@ -853,6 +892,21 @@ private fun resolverTargetNeedsBrackets(target: String): Boolean {
     return target.substringBefore('/').contains(':')
 }
 
+private fun detectResolverTextEntryType(lines: List<String>): ResolverTextEntryType {
+    return if (lines.any { it.contains(',') || it.contains(';') }) {
+        ResolverTextEntryType.CommaSeparated
+    } else {
+        ResolverTextEntryType.LineSeparated
+    }
+}
+
+private enum class ResolverTextEntryType {
+    LineSeparated,
+    CommaSeparated,
+}
+
+private const val DefaultResolverPort = 53
+
 private val ResolverIpv6Chars = Regex("^[0-9A-Fa-f:.]+$")
 
 private fun normalizeSplitTunnelMode(raw: String): String {
@@ -896,12 +950,15 @@ fun WhiteDnsSettings.resolve(): ResolvedWhiteDnsSettings {
         return value.coerceIn(minValue, maxValue)
     }
 
-    val resolvers = resolverText
-        .lineSequence()
-        .map(String::trim)
-        .filter(String::isNotEmpty)
-        .distinct()
-        .toList()
+    fun boundedPositiveDouble(raw: String, defaultValue: Double, minValue: Double, maxValue: Double): Double {
+        val value = raw.trim().toDoubleOrNull() ?: return defaultValue
+        if (value <= 0.0) {
+            return defaultValue
+        }
+        return value.coerceIn(minValue, maxValue)
+    }
+
+    val resolvers = validateResolverText(resolverText).normalizedResolvers
 
     val resolvedRxTxWorkers = boundedInt(rxTxWorkers, defaultValue = 4, minValue = 1, maxValue = 64)
     val resolvedTunnelProcessWorkers = boundedInt(
@@ -916,6 +973,12 @@ fun WhiteDnsSettings.resolve(): ResolvedWhiteDnsSettings {
         minValue = 0.1,
         maxValue = 60.0,
     )
+    val resolvedMinUploadMtu = boundedInt(minUploadMtu, defaultValue = 40, minValue = 1, maxValue = 65535)
+    val resolvedMinDownloadMtu = boundedInt(minDownloadMtu, defaultValue = 300, minValue = 1, maxValue = 65535)
+    val resolvedMaxUploadMtu = boundedInt(maxUploadMtu, defaultValue = 140, minValue = 1, maxValue = 65535)
+        .coerceAtLeast(resolvedMinUploadMtu)
+    val resolvedMaxDownloadMtu = boundedInt(maxDownloadMtu, defaultValue = 3000, minValue = 1, maxValue = 65535)
+        .coerceAtLeast(resolvedMinDownloadMtu)
 
     return ResolvedWhiteDnsSettings(
         connectionMode = when (connectionMode) {
@@ -937,10 +1000,10 @@ fun WhiteDnsSettings.resolve(): ResolvedWhiteDnsSettings {
         uploadCompression = uploadCompression.coerceIn(0, 3),
         downloadCompression = downloadCompression.coerceIn(0, 3),
         baseEncodeData = baseEncodeData,
-        minUploadMtu = boundedInt(minUploadMtu, defaultValue = 40, minValue = 1, maxValue = 65535),
-        minDownloadMtu = boundedInt(minDownloadMtu, defaultValue = 100, minValue = 1, maxValue = 65535),
-        maxUploadMtu = boundedInt(maxUploadMtu, defaultValue = 64, minValue = 1, maxValue = 65535),
-        maxDownloadMtu = boundedInt(maxDownloadMtu, defaultValue = 140, minValue = 1, maxValue = 65535),
+        minUploadMtu = resolvedMinUploadMtu,
+        minDownloadMtu = resolvedMinDownloadMtu,
+        maxUploadMtu = resolvedMaxUploadMtu,
+        maxDownloadMtu = resolvedMaxDownloadMtu,
         mtuTestRetriesResolvers = boundedInt(mtuTestRetriesResolvers, defaultValue = 3, minValue = 1, maxValue = 100),
         mtuTestTimeoutResolvers = positiveDouble(mtuTestTimeoutResolvers, defaultValue = 2.0),
         mtuTestParallelismResolvers = boundedInt(mtuTestParallelismResolvers, defaultValue = 100, minValue = 1, maxValue = 1024),
@@ -987,6 +1050,18 @@ fun WhiteDnsSettings.resolve(): ResolvedWhiteDnsSettings {
             minValue = 16,
             maxValue = 16384,
         ),
+        maxActiveStreams = boundedInt(
+            maxActiveStreams,
+            defaultValue = 2048,
+            minValue = 1,
+            maxValue = 65535,
+        ),
+        localHandshakeTimeoutSeconds = boundedPositiveDouble(
+            localHandshakeTimeoutSeconds,
+            defaultValue = 5.0,
+            minValue = 0.5,
+            maxValue = 60.0,
+        ),
         socksUdpAssociateReadTimeoutSeconds = boundedDouble(
             socksUdpAssociateReadTimeoutSeconds,
             defaultValue = 30.0,

app/src/main/java/shop/whitedns/client/model/WhiteDnsSettingsStore.kt

@@ -115,6 +115,12 @@ class WhiteDnsSettingsStore(
                 KeyDnsResponseFragmentStoreCapacity,
                 defaults.dnsResponseFragmentStoreCapacity,
             ) ?: defaults.dnsResponseFragmentStoreCapacity,
+            maxActiveStreams = preferences.getString(KeyMaxActiveStreams, defaults.maxActiveStreams)
+                ?: defaults.maxActiveStreams,
+            localHandshakeTimeoutSeconds = preferences.getString(
+                KeyLocalHandshakeTimeoutSeconds,
+                defaults.localHandshakeTimeoutSeconds,
+            ) ?: defaults.localHandshakeTimeoutSeconds,
             socksUdpAssociateReadTimeoutSeconds = preferences.getString(
                 KeySocksUdpAssociateReadTimeoutSeconds,
                 defaults.socksUdpAssociateReadTimeoutSeconds,
@@ -219,6 +225,8 @@ class WhiteDnsSettingsStore(
             .putString(KeyStreamQueueInitialCapacity, normalizedSettings.streamQueueInitialCapacity)
             .putString(KeyOrphanQueueInitialCapacity, normalizedSettings.orphanQueueInitialCapacity)
             .putString(KeyDnsResponseFragmentStoreCapacity, normalizedSettings.dnsResponseFragmentStoreCapacity)
+            .putString(KeyMaxActiveStreams, normalizedSettings.maxActiveStreams)
+            .putString(KeyLocalHandshakeTimeoutSeconds, normalizedSettings.localHandshakeTimeoutSeconds)
             .putString(KeySocksUdpAssociateReadTimeoutSeconds, normalizedSettings.socksUdpAssociateReadTimeoutSeconds)
             .putString(KeyClientTerminalStreamRetentionSeconds, normalizedSettings.clientTerminalStreamRetentionSeconds)
             .putString(KeyClientCancelledSetupRetentionSeconds, normalizedSettings.clientCancelledSetupRetentionSeconds)
@@ -363,12 +371,20 @@ class WhiteDnsSettingsStore(
         replaceOldDefault(KeyDnsResponseFragmentStoreCapacity, oldValue = "1024", newValue = "256")
         replaceOldDefault(KeyClientCancelledSetupRetentionSeconds, oldValue = "90.0", newValue = "120.0")
         replaceOldDefault(KeySessionInitRetryMaxSeconds, oldValue = "30.0", newValue = "60.0")
+        replaceOldDefault(KeyMinUploadMtu, oldValue = "100", newValue = "40")
+        replaceOldDefault(KeyMinDownloadMtu, oldValue = "100", newValue = "300")
+        replaceOldDefault(KeyMinDownloadMtu, oldValue = "1000", newValue = "300")
+        replaceOldDefault(KeyMaxUploadMtu, oldValue = "64", newValue = "140")
+        replaceOldDefault(KeyMaxUploadMtu, oldValue = "200", newValue = "140")
+        replaceOldDefault(KeyMaxDownloadMtu, oldValue = "140", newValue = "3000")
+        replaceOldDefault(KeyMaxDownloadMtu, oldValue = "4000", newValue = "3000")
+        replaceOldDefault(KeyStartupMode, oldValue = "logs", newValue = "resolvers")
         editor.putInt(KeyAdvancedDefaultsRevision, AdvancedDefaultsRevision).apply()
     }
 
     private companion object {
         const val PreferencesName = "white_dns_settings"
-        const val AdvancedDefaultsRevision = 1
+        const val AdvancedDefaultsRevision = 4
         const val LegacyDefaultResolverText = "1.1.1.1\n8.8.8.8\n9.9.9.9"
         const val KeyAdvancedDefaultsRevision = "advanced_defaults_revision"
         const val KeySelectedConnectionProfileId = "selected_connection_profile_id"
@@ -415,6 +431,8 @@ class WhiteDnsSettingsStore(
         const val KeyStreamQueueInitialCapacity = "stream_queue_initial_capacity"
         const val KeyOrphanQueueInitialCapacity = "orphan_queue_initial_capacity"
         const val KeyDnsResponseFragmentStoreCapacity = "dns_response_fragment_store_capacity"
+        const val KeyMaxActiveStreams = "max_active_streams"
+        const val KeyLocalHandshakeTimeoutSeconds = "local_handshake_timeout_seconds"
         const val KeySocksUdpAssociateReadTimeoutSeconds = "socks_udp_associate_read_timeout_seconds"
         const val KeyClientTerminalStreamRetentionSeconds = "client_terminal_stream_retention_seconds"
         const val KeyClientCancelledSetupRetentionSeconds = "client_cancelled_setup_retention_seconds"

app/src/main/java/shop/whitedns/client/proxy/WhiteDnsProxyService.kt

@@ -417,12 +417,19 @@ class WhiteDnsProxyService : Service() {
             openAppIntent,
             pendingIntentFlags,
         )
+        val stopPendingIntent = PendingIntent.getService(
+            this,
+            1,
+            Intent(this, WhiteDnsProxyService::class.java).setAction(ActionStop),
+            pendingIntentFlags,
+        )
 
         return NotificationCompat.Builder(this, NotificationChannelId)
             .setSmallIcon(R.drawable.ic_notification)
             .setContentTitle("WhiteDNS Proxy")
             .setContentText(statusText)
             .setContentIntent(openAppPendingIntent)
+            .addAction(R.drawable.ic_notification, "Disconnect", stopPendingIntent)
             .setCategory(NotificationCompat.CATEGORY_SERVICE)
             .setPriority(NotificationCompat.PRIORITY_LOW)
             .setOngoing(true)