Fix mdns issue on hotspot network

ismartcoding · ismartcoding · commit 7af94432f163 · 2026-04-12T04:40:18.000+08:00
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -81,9 +81,9 @@ android {
                 else -> 0
             }
 
-        val vCode = 535
+        val vCode = 538
         versionCode = vCode - singleAbiNum
-        versionName = "3.0.12"
+        versionName = "3.0.13"
 
         ndk {
             //noinspection ChromeOsAbiSupport
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
@@ -217,6 +217,7 @@
             android:name=".receivers.ServiceStopBroadcastReceiver"
             android:exported="true">
             <intent-filter>
+                <action android:name="${applicationId}.action.START_HTTP_SERVER" />
                 <action android:name="${applicationId}.action.STOP_HTTP_SERVER" />
                 <action android:name="${applicationId}.action.STOP_SCREEN_MIRROR" />
                 <action android:name="${applicationId}.action.REPOST_HTTP_NOTIFICATION" />
diff --git a/app/src/main/java/com/ismartcoding/plain/Constants.kt b/app/src/main/java/com/ismartcoding/plain/Constants.kt
@@ -14,6 +14,7 @@ object Constants {
     const val MAX_MESSAGE_LENGTH = 2048 // Maximum length of a message in the chat
     const val TEXT_FILE_SUMMARY_LENGTH = 250
     const val AUTHORITY = "${BuildConfig.APPLICATION_ID}.provider"
+    const val ACTION_START_HTTP_SERVER = "${BuildConfig.APPLICATION_ID}.action.START_HTTP_SERVER"
     const val ACTION_STOP_HTTP_SERVER = "${BuildConfig.APPLICATION_ID}.action.STOP_HTTP_SERVER"
     const val ACTION_STOP_SCREEN_MIRROR = "${BuildConfig.APPLICATION_ID}.action.STOP_SCREEN_MIRROR"
     const val ACTION_PEER_CHAT_REPLY = "${BuildConfig.APPLICATION_ID}.action.PEER_CHAT_REPLY"
diff --git a/app/src/main/java/com/ismartcoding/plain/receivers/ServiceStopBroadcastReceiver.kt b/app/src/main/java/com/ismartcoding/plain/receivers/ServiceStopBroadcastReceiver.kt
@@ -18,6 +18,10 @@ class ServiceStopBroadcastReceiver : BroadcastReceiver() {
         intent: Intent,
     ) {
         when (intent.action) {
+            Constants.ACTION_START_HTTP_SERVER -> {
+                coIO { WebPreference.putAsync(context, true) }
+                ContextCompat.startForegroundService(context, Intent(context, HttpServerService::class.java))
+            }
             Constants.ACTION_STOP_HTTP_SERVER -> coIO {
                 WebPreference.putAsync(context, false)
                 HttpServerManager.stopServiceAsync(context)
diff --git a/app/src/main/java/com/ismartcoding/plain/web/HttpModule.kt b/app/src/main/java/com/ismartcoding/plain/web/HttpModule.kt
@@ -934,7 +934,7 @@ object HttpModule {
                                         if (decryptedBytes != null) {
                                             LogCat.d("ws: add session ${session.id}, ts: ${decryptedBytes.decodeToString()}")
                                             HttpServerManager.wsSessions.add(session)
-                                            HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.size
+                                            HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.distinctBy { it.clientId }.size
                                         } else {
                                             LogCat.d("ws: invalid_request")
                                             close(CloseReason(CloseReason.Codes.TRY_AGAIN_LATER, "invalid_request"))
@@ -954,7 +954,7 @@ object HttpModule {
                 } finally {
                     LogCat.d("ws: remove session ${session.id}")
                     HttpServerManager.wsSessions.removeIf { it.id == session.id }
-                    HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.size
+                    HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.distinctBy { it.clientId }.size
                 }
             }
         }
diff --git a/app/src/main/java/com/ismartcoding/plain/web/HttpServerManager.kt b/app/src/main/java/com/ismartcoding/plain/web/HttpServerManager.kt
@@ -320,19 +320,18 @@ object HttpServerManager {
         // When there are active sessions/clients we update frequently, otherwise we back off.
         val activeIntervalMs = 5_000L
         val idleIntervalMs = 60_000L
-        val activeWindowMs = 5_000L
-
+        var lastSyncTs = 0L
         clientTsJob = coIO {
             while (kotlinx.coroutines.currentCoroutineContext().isActive) {
-                val now = System.currentTimeMillis()
                 val updates =
                     clientRequestTs
-                        .filter { it.value + activeWindowMs > now }
+                        .filter { it.value > lastSyncTs }
                         .map { SessionClientTsUpdate(it.key, Instant.fromEpochMilliseconds(it.value)) }
-
                 if (updates.isNotEmpty()) {
+                    val maxTsInThisBatch = updates.maxOf { it.updatedAt.toEpochMilliseconds() }
                     runCatching {
                         AppDatabase.instance.sessionDao().updateTs(updates)
+                        lastSyncTs = maxTsInThisBatch
                     }.onFailure {
                         LogCat.e("Failed to update client session timestamps: ${it.message}")
                     }
diff --git a/app/src/main/java/com/ismartcoding/plain/web/MdnsHostResponder.kt b/app/src/main/java/com/ismartcoding/plain/web/MdnsHostResponder.kt
@@ -2,9 +2,9 @@ package com.ismartcoding.plain.web
 
 import android.content.Context
 import android.net.wifi.WifiManager
-import com.ismartcoding.lib.helpers.NetworkHelper
 import com.ismartcoding.lib.logcat.LogCat
 import java.net.DatagramPacket
+import java.net.DatagramSocket
 import java.net.Inet4Address
 import java.net.InetAddress
 import java.net.InetSocketAddress
@@ -13,117 +13,124 @@ import java.net.NetworkInterface
 import java.net.SocketTimeoutException
 
 /**
- * Lightweight mDNS responder for hostname-to-IPv4 resolution (A record).
- * Keeps local hostname pingable (e.g. plainapp.local) without external libs.
+ * Lightweight mDNS responder — single receive socket, per-packet unicast reply.
+ *
+ * RECEIVE: One MulticastSocket bound to 0.0.0.0:5353 joins 224.0.0.251 on every
+ * valid LAN interface (wlan0 Wi-Fi, ap0/wlan1 hotspot, both when active).
+ * A single socket avoids the Linux SO_REUSEPORT limitation.
+ *
+ * SEND: For each query the candidate interface list is re-fetched fresh (never
+ * cached), then a throwaway DatagramSocket bound to localIp:0 sends a unicast
+ * reply to the querier's source IP. Binding to a specific local IP forces the
+ * kernel to route the packet via the interface that owns localIp — no
+ * IP_MULTICAST_IF mutation on the shared receive socket is needed.
+ *
+ * Restart lifecycle: MdnsReregistrar (ConnectivityManager) + MdnsHotspotWatcher
+ * (WIFI_AP_STATE_CHANGED) recreate the socket whenever the active interface set
+ * changes, keeping receive memberships current.
  */
 object MdnsHostResponder {
     private const val MDNS_GROUP = "224.0.0.251"
     private const val MDNS_PORT = 5353
 
-    @Volatile
-    private var hostname = "plainapp.local"
+    @Volatile private var hostname = "plainapp.local"
 
-    @Volatile
-    private var worker: Thread? = null
-
-    @Volatile
+    private val stateLock = Any()
     private var socket: MulticastSocket? = null
-
-    @Volatile
+    private var worker: Thread? = null
     private var multicastLock: WifiManager.MulticastLock? = null
 
     fun start(context: Context, mdnsHostname: String): Boolean {
         val normalized = normalizeHostname(mdnsHostname)
         if (normalized.isEmpty()) {
-            LogCat.e("mDNS responder start skipped: empty hostname")
+            LogCat.e("mDNS start skipped: empty hostname")
             return false
         }
-
         stop()
         hostname = normalized
 
-        val group = InetAddress.getByName(MDNS_GROUP)
-        val lock = acquireMulticastLock(context)
+        val candidates = candidateInterfaces()
+        if (candidates.isEmpty()) {
+            LogCat.e("mDNS: no candidate interfaces found")
+            return false
+        }
 
-        return runCatching {
-            val s = MulticastSocket(null).apply {
-                reuseAddress = true
-                soTimeout = 1000
-                bind(InetSocketAddress(MDNS_PORT))
-                timeToLive = 255
-                joinGroup(group)
+        val multicastGroup = InetAddress.getByName(MDNS_GROUP)
+        val groupSockAddr = InetSocketAddress(multicastGroup, MDNS_PORT)
+        synchronized(stateLock) {
+            val lock = acquireMulticastLock(context)
+            val s = runCatching {
+                MulticastSocket(null).apply {
+                    reuseAddress = true
+                    soTimeout = 1000
+                    bind(InetSocketAddress(MDNS_PORT))
+                    for ((iface, ip) in candidates) {
+                        runCatching { joinGroup(groupSockAddr, iface) }
+                            .onSuccess { LogCat.d("mDNS joined ${iface.name} (${ip.hostAddress})") }
+                            .onFailure { LogCat.e("mDNS joinGroup ${iface.name}: ${it.message}") }
+                    }
+                }
+            }.getOrElse {
+                lock?.let { l -> runCatching { l.release() } }
+                LogCat.e("mDNS socket create failed: ${it.message}")
+                return false
             }
             socket = s
             multicastLock = lock
-
-            worker = Thread {
-                runLoop(s, group)
-            }.apply {
+            worker = Thread { runLoop(s) }.apply {
                 name = "plain-mdns-responder"
                 isDaemon = true
                 start()
             }
-            LogCat.d("mDNS responder started for $hostname")
-            true
-        }.getOrElse {
-            lock?.let { l -> runCatching { l.release() } }
-            LogCat.e("Failed to start mDNS responder: ${it.message}")
-            false
         }
+        LogCat.d("mDNS responder started for $hostname on ${candidates.size} interface(s)")
+        return true
     }
 
     fun stop() {
-        val t = worker
-        worker = null
-
-        val s = socket
-        socket = null
-        runCatching { s?.close() }
-
-        runCatching { t?.join(300) }
-
-        multicastLock?.let { lock ->
-            runCatching {
-                if (lock.isHeld) lock.release()
-            }
+        synchronized(stateLock) {
+            val t = worker; worker = null
+            val s = socket; socket = null
+            runCatching { s?.close() }
+            runCatching { t?.join(300) }
+            multicastLock?.let { ml -> runCatching { if (ml.isHeld) ml.release() } }
+            multicastLock = null
         }
-        multicastLock = null
     }
 
-    private fun runLoop(socket: MulticastSocket, group: InetAddress) {
-        val buffer = ByteArray(1500)
-        while (Thread.currentThread().isAlive) {
-            val packet = DatagramPacket(buffer, buffer.size)
+    private fun runLoop(s: MulticastSocket) {
+        val buf = ByteArray(1500)
+        while (!s.isClosed) {
+            val packet = DatagramPacket(buf, buf.size)
             try {
-                socket.receive(packet)
+                s.receive(packet)
+                val senderIp = packet.address as? Inet4Address ?: continue
+                val fresh = candidateInterfaces()
+                if (fresh.isEmpty()) continue
+                val (_, localIp) = findResponseIface(senderIp, fresh)
                 val response = MdnsPacketCodec.buildResponseIfMatch(
                     query = packet.data.copyOf(packet.length),
                     hostname = hostname,
-                    ips = getResponderIps(),
-                )
-                if (response != null) {
-                    socket.send(DatagramPacket(response, response.size, group, MDNS_PORT))
-                }
+                    ips = listOf(localIp),
+                ) ?: continue
+                sendUnicast(response, localIp, senderIp)
             } catch (_: SocketTimeoutException) {
-                // timeout keeps the thread responsive to stop()
+                // expected — keeps thread responsive to socket close
             } catch (_: Exception) {
-                if (worker == null) break
+                if (s.isClosed) break
             }
         }
     }
 
-    private fun getResponderIps(): List<Inet4Address> {
-        return NetworkHelper.getDeviceIP4s()
-            .mapNotNull { ip -> runCatching { InetAddress.getByName(ip) }.getOrNull() }
-            .filterIsInstance<Inet4Address>()
-            .filter { ip ->
-                val ni = runCatching { NetworkInterface.getByInetAddress(ip) }.getOrNull()
-                ni != null && !NetworkHelper.isVpnInterface(ni.name) && !ip.isLoopbackAddress
+    internal fun sendUnicast(response: ByteArray, localIp: Inet4Address, dest: Inet4Address) {
+        runCatching {
+            DatagramSocket(InetSocketAddress(localIp, 0)).use { ds ->
+                ds.send(DatagramPacket(response, response.size, dest, MDNS_PORT))
             }
-            .distinctBy { it.hostAddress }
+        }.onFailure { LogCat.e("mDNS send to ${dest.hostAddress}: ${it.message}") }
     }
 
-    private fun normalizeHostname(value: String): String {
+    internal fun normalizeHostname(value: String): String {
         val trimmed = value.trim().trim('.').lowercase()
         if (trimmed.isEmpty()) return ""
         return if (trimmed.endsWith(".local")) trimmed else "$trimmed.local"
diff --git a/app/src/main/java/com/ismartcoding/plain/web/MdnsHotspotWatcher.kt b/app/src/main/java/com/ismartcoding/plain/web/MdnsHotspotWatcher.kt
@@ -0,0 +1,60 @@
+package com.ismartcoding.plain.web
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import com.ismartcoding.lib.logcat.LogCat
+
+/**
+ * Listens for Android Wi-Fi AP (hotspot) state changes and invokes [onStateChanged].
+ *
+ * ConnectivityManager.NetworkCallback does not fire on the host device when hotspot
+ * is toggled (the tethered network belongs to the clients, not the host). This watcher
+ * fills the gap so MdnsReregistrar can restart the responder on the correct interfaces
+ * whenever the hotspot interface (ap0 / wlan1) appears or disappears.
+ *
+ * The action and state constants are `@hide` in the public SDK; raw values are used
+ * directly to avoid compilation errors on all target SDK versions.
+ */
+internal class MdnsHotspotWatcher(
+    private val context: Context,
+    private val onStateChanged: () -> Unit,
+) {
+    // android.net.wifi.WifiManager constants (all @hide; raw values are stable since API 1)
+    private val apStateChangedAction = "android.net.wifi.WIFI_AP_STATE_CHANGED"
+    private val extraApState = "wifi_state"
+    private val apStateEnabled = 13
+    private val apStateDisabled = 11
+
+    private var receiver: BroadcastReceiver? = null
+
+    fun start() {
+        if (receiver != null) return
+        val r = object : BroadcastReceiver() {
+            override fun onReceive(ctx: Context, intent: Intent) {
+                val s = intent.getIntExtra(extraApState, -1)
+                if (s == apStateEnabled || s == apStateDisabled) onStateChanged()
+            }
+        }
+        val filter = IntentFilter(apStateChangedAction)
+        runCatching {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                context.registerReceiver(r, filter, Context.RECEIVER_NOT_EXPORTED)
+            } else {
+                @Suppress("UnspecifiedRegisterReceiverFlag")
+                context.registerReceiver(r, filter)
+            }
+            receiver = r
+            LogCat.d("MdnsHotspotWatcher started")
+        }.onFailure { LogCat.e("MdnsHotspotWatcher start failed: ${it.message}") }
+    }
+
+    fun stop() {
+        val r = receiver ?: return
+        receiver = null
+        runCatching { context.unregisterReceiver(r) }
+            .onFailure { LogCat.e("MdnsHotspotWatcher stop failed: ${it.message}") }
+    }
+}
diff --git a/app/src/main/java/com/ismartcoding/plain/web/MdnsIfaceSelector.kt b/app/src/main/java/com/ismartcoding/plain/web/MdnsIfaceSelector.kt
diff --git a/app/src/main/java/com/ismartcoding/plain/web/MdnsReregistrar.kt b/app/src/main/java/com/ismartcoding/plain/web/MdnsReregistrar.kt
diff --git a/app/src/test/java/com/ismartcoding/plain/web/MdnsHostResponderTest.kt b/app/src/test/java/com/ismartcoding/plain/web/MdnsHostResponderTest.kt
diff --git a/app/src/test/java/com/ismartcoding/plain/web/MdnsIfaceSelectorTest.kt b/app/src/test/java/com/ismartcoding/plain/web/MdnsIfaceSelectorTest.kt

Original file line number	Diff line number	Diff line change
`@@ -934,7 +934,7 @@ object HttpModule {`
`934`	`934`	`if (decryptedBytes != null) {`
`935`	`935`	`LogCat.d("ws: add session ${session.id}, ts: ${decryptedBytes.decodeToString()}")`
`936`	`936`	`HttpServerManager.wsSessions.add(session)`
`937`		`- HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.size`
	`937`	`+ HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.distinctBy { it.clientId }.size`
`938`	`938`	`} else {`
`939`	`939`	`LogCat.d("ws: invalid_request")`
`940`	`940`	`close(CloseReason(CloseReason.Codes.TRY_AGAIN_LATER, "invalid_request"))`
`@@ -954,7 +954,7 @@ object HttpModule {`
`954`	`954`	`} finally {`
`955`	`955`	`LogCat.d("ws: remove session ${session.id}")`
`956`	`956`	`HttpServerManager.wsSessions.removeIf { it.id == session.id }`
`957`		`- HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.size`
	`957`	`+ HttpServerManager.wsSessionCount.value = HttpServerManager.wsSessions.distinctBy { it.clientId }.size`
`958`	`958`	`}`
`959`	`959`	`}`
`960`	`960`	`}`