@@ -52,16 +52,21 @@ open class NsdDiscovery(context: Context?) {
5252 }
5353 // Thread-safe: mutated by the resolver coroutine and the (main-thread) lost callback.
5454 val found = java.util.concurrent.ConcurrentHashMap<String, DiscoveredServer>()
55− // Names reported lost before the serialized resolver reached them. Without this, a
56− // service that disappears between onServiceFound and the resolver dequeuing it would
57− // be re-inserted into `found` after onServiceLost already fired (and returned null),
58− // leaving a phantom entry that lingers until discovery stops — the lost callback never
59− // fires twice for the same name. The resolver consults this set and skips the insert.
60− val lostPending = java.util.Collections.newSetFromMap(java.util.concurrent.ConcurrentHashMap<String, Boolean>())
61− val toResolve = Channel<NsdServiceInfo>(Channel.UNLIMITED)
55+ // Per-name epoch, bumped on every onServiceLost. Each queued resolve is stamped with the
56+ // epoch that was current when it was enqueued; the resolver discards its result if the
57+ // epoch has advanced since. This makes loss ordering authoritative: a resolve queued
58+ // BEFORE a loss — a stale duplicate onServiceFound (stock NsdManager can emit these on
59+ // multi-homed devices), or a resolve still in flight when the service departs — is
60+ // dropped, while a resolve queued AFTER a loss (a genuine re-announcement of a restarted
61+ // server) still inserts. It fixes the phantom a plain "lost-pending" flag missed:
62+ // onServiceLost removing an already-resolved entry couldn't tell a second, still-queued
63+ // duplicate resolve to skip re-inserting the departed service — yet it also avoids that
64+ // flag's converse hazard of leaking a marker that suppresses a later legitimate re-appearance.
65+ val epoch = java.util.concurrent.ConcurrentHashMap<String, Int>()
66+ val toResolve = Channel<Pair<NsdServiceInfo, Int>>(Channel.UNLIMITED)
6267
6368 val resolver = launch {
64− for (info in toResolve) {
69+ for ((info, stampedEpoch) in toResolve) {
6570 // Key the map by the name from discovery: onServiceFound/onServiceLost both use
6671 // NsdServiceInfo.serviceName, whereas the resolved info's serviceName can differ —
6772 // keying by the resolved name would leave a departed server that onServiceLost
@@ -72,13 +77,9 @@ open class NsdDiscovery(context: Context?) {
7277 // so every later-discovered service queued behind it is never processed and the
7378 // emitted list silently stops updating. Abandon a stuck resolve and keep draining.
7479 val resolved = withTimeoutOrNull(RESOLVE_TIMEOUT_MS) { resolveService(nsd, info) }
75− // Consume any "lost while queued" marker for this name REGARDLESS of the resolve
76− // outcome, and skip resurrecting a service reported lost. If the resolve failed or
77− // timed out (e.g. the service really is gone), an early `?: continue` on the line
78− // above would skip this and leak the marker — which would then wrongly suppress the
79− // SAME name's next successful resolution when the server restarts and re-announces
80− // (onServiceLost won't fire again to clear it). Also drop a null resolve outright.
81− if (lostPending.remove(discoveredName) || resolved == null) continue
80+ // Drop the result if the service was reported lost since this resolve was queued
81+ // (its epoch advanced), or if the resolve failed/timed out (the service is gone).
82+ if ((epoch[discoveredName] ?: 0) != stampedEpoch || resolved == null) continue
8283 val name = resolved.serviceName.orEmpty()
8384 // Keep only opencode's own advertisements, not every _http._tcp service
8485 // (printers, routers, other web servers) on the network.
@@ -86,11 +87,11 @@ open class NsdDiscovery(context: Context?) {
8687 @Suppress("DEPRECATION")
8788 val host = resolved.host?.hostAddress ?: continue
8889 found[discoveredName] = DiscoveredServer(name = name, host = host, port = resolved.port)
89− // Close the check-then-insert race: an onServiceLost that fired in the non-suspending
90− // window since the marker check above couldn't remove this name from `found` (nothing
91− // was inserted yet), so it set a lostPending marker instead. Re-check and evict now,
92− // else the just-departed service lingers as a phantom onServiceLost won't clear.
93− if (lostPending.remove(discoveredName)) found.remove(discoveredName)
90+ // Close the check-then-insert race: an onServiceLost firing in the non-suspending
91+ // window since the check above bumped the epoch but couldn't remove this name from
92+ // `found` (nothing was inserted yet). Re-check and evict now — the epoch is
93+ // monotonic, so any loss that raced the insert is still visible here.
94+ if ((epoch[discoveredName] ?: 0) != stampedEpoch) found.remove(discoveredName)
9495 trySend(found.values.sortedBy { it.name })
9596 }
9697 }
@@ -98,20 +99,19 @@ open class NsdDiscovery(context: Context?) {
9899 val listener = object : NsdManager.DiscoveryListener {
99100 override fun onDiscoveryStarted(serviceType: String?) {}
100101 override fun onServiceFound(serviceInfo: NsdServiceInfo) {
101− toResolve.trySend(serviceInfo)
102+ // Stamp the resolve with the name's current epoch so a loss after this point (but
103+ // before the serialized resolver reaches it) invalidates the result.
104+ val name = serviceInfo.serviceName.orEmpty()
105+ toResolve.trySend(serviceInfo to (epoch[name] ?: 0))
102106 }
103107 override fun onServiceLost(serviceInfo: NsdServiceInfo) {
104108 val name = serviceInfo.serviceName ?: return
105− // If it was already resolved and in `found`, remove and emit now — and do NOT set a
106− // lostPending marker: the resolver already processed this name, so the marker would
107− // never be consumed and would instead suppress the service's NEXT re-appearance (a
108− // restarted server re-discovered later would hit `lostPending.remove` and be
109− // dropped). Only mark names lost *before* the serialized resolver reached them —
110− // those aren't in `found` yet, and the marker tells the resolver to skip the insert.
109+ // Advance the epoch so any resolve queued before now (including a duplicate
110+ // onServiceFound whose result hasn't landed yet) is discarded and can't resurrect
111+ // this service, then drop it from the emitted list if it was already resolved.
112+ epoch.merge(name, 1) { old, _ -> old + 1 }
111113 if (found.remove(name) != null) {
112114 trySend(found.values.sortedBy { it.name })
113− } else {
114− lostPending.add(name)
115115 }
116116 }
117117 override fun onDiscoveryStopped(serviceType: String?) {}