@devioarts/capacitor-mdns 0.1.0 → 0.2.0

package/android/src/main/java/com/devioarts/capacitor/mdns/AndroidNsdBackend.kt

@@ -0,0 +1,145 @@
+package com.devioarts.capacitor.mdns
+// English-only code and comments.
+
+import android.content.Context
+import android.net.nsd.NsdManager
+import android.net.nsd.NsdServiceInfo
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.ext.SdkExtensions
+import java.util.concurrent.Executor
+
+/** Production [MainThread] backed by the application's main looper. */
+internal class AndroidMainThread : MainThread {
+    private val handler = Handler(Looper.getMainLooper())
+    override fun isCurrent(): Boolean = Looper.myLooper() === Looper.getMainLooper()
+    override fun post(block: () -> Unit) {
+        handler.post { block() }
+    }
+}
+
+/**
+ * Production [NsdBackend] on top of Android's `NsdManager`.
+ *
+ * Callbacks of the legacy overloads are delivered on NsdManager's internal thread, so this class
+ * does not touch any shared state from them: it only translates and forwards.
+ */
+internal class AndroidNsdBackend(context: Context) : NsdBackend {
+
+    private val nsd: NsdManager = context.getSystemService(Context.NSD_SERVICE) as NsdManager
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val mainExecutor = Executor { command -> mainHandler.post(command) }
+    private val multicastLock by lazy {
+        (context.applicationContext.getSystemService(Context.WIFI_SERVICE) as? WifiManager)
+            ?.createMulticastLock("capacitor-mdns")
+    }
+    private val needsMulticastLock = Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
+        SdkExtensions.getExtensionVersion(Build.VERSION_CODES.TIRAMISU) < 7
+
+    override fun acquireMulticastLock() {
+        if (needsMulticastLock) multicastLock?.acquire()
+    }
+
+    override fun releaseMulticastLock() {
+        if (needsMulticastLock) multicastLock?.release()
+    }
+
+    override val supportsConcurrentResolve: Boolean
+        get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
+
+    override fun registerService(
+        type: String,
+        name: String,
+        port: Int,
+        txt: Map<String, String>,
+        listener: NsdBackend.RegistrationListener
+    ): Any {
+        val info = NsdServiceInfo().apply {
+            serviceType = type
+            serviceName = name
+            setPort(port)
+            txt.forEach { (key, value) -> setAttribute(key, value) }
+        }
+        val nsdListener = object : NsdManager.RegistrationListener {
+            override fun onServiceRegistered(nsi: NsdServiceInfo) = listener.onRegistered(nsi.serviceName)
+            override fun onRegistrationFailed(nsi: NsdServiceInfo, errorCode: Int) = listener.onFailed(errorCode)
+            override fun onServiceUnregistered(nsi: NsdServiceInfo) = listener.onUnregistered()
+            override fun onUnregistrationFailed(nsi: NsdServiceInfo, errorCode: Int) = listener.onUnregistrationFailed(errorCode)
+        }
+        nsd.registerService(info, NsdManager.PROTOCOL_DNS_SD, nsdListener)
+        return nsdListener
+    }
+
+    override fun unregisterService(token: Any) {
+        nsd.unregisterService(token as NsdManager.RegistrationListener)
+    }
+
+    override fun startDiscovery(type: String, listener: NsdBackend.DiscoveryListener): Any {
+        val nsdListener = object : NsdManager.DiscoveryListener {
+            override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) = listener.onStartFailed(errorCode)
+            override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) = listener.onStopFailed(errorCode)
+            override fun onDiscoveryStarted(serviceType: String) { /* no-op */ }
+            override fun onDiscoveryStopped(serviceType: String) = listener.onStopped()
+            override fun onServiceFound(si: NsdServiceInfo) =
+                listener.onFound(DiscoveredService(si.serviceName, si.serviceType, si))
+            override fun onServiceLost(si: NsdServiceInfo) =
+                listener.onLost(DiscoveredService(si.serviceName, si.serviceType, si))
+        }
+        nsd.discoverServices(type, NsdManager.PROTOCOL_DNS_SD, nsdListener)
+        return nsdListener
+    }
+
+    override fun stopDiscovery(token: Any) {
+        nsd.stopServiceDiscovery(token as NsdManager.DiscoveryListener)
+    }
+
+    @Suppress("DEPRECATION")
+    override fun resolve(service: DiscoveredService, listener: NsdBackend.ResolveListener): Any? {
+        val si = service.handle as NsdServiceInfo
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            val callback = object : NsdManager.ServiceInfoCallback {
+                override fun onServiceInfoCallbackRegistrationFailed(errorCode: Int) = listener.onFailed(errorCode)
+                override fun onServiceInfoCallbackUnregistered() { /* no-op */ }
+                override fun onServiceLost() { /* no-op */ }
+                override fun onServiceUpdated(serviceInfo: NsdServiceInfo) =
+                    listener.onResolved(toMdnsService(serviceInfo))
+            }
+            nsd.registerServiceInfoCallback(si, mainExecutor, callback)
+            return callback
+        }
+
+        nsd.resolveService(si, object : NsdManager.ResolveListener {
+            override fun onResolveFailed(s: NsdServiceInfo, errorCode: Int) = listener.onFailed(errorCode)
+            override fun onServiceResolved(s: NsdServiceInfo) = listener.onResolved(toMdnsService(s))
+        })
+        return null
+    }
+
+    override fun cancelResolve(token: Any) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE &&
+            token is NsdManager.ServiceInfoCallback
+        ) {
+            nsd.unregisterServiceInfoCallback(token)
+        }
+    }
+
+    private fun toMdnsService(s: NsdServiceInfo): mDNS.MdnsService =
+        mDNS.MdnsService(
+            name = s.serviceName,
+            type = s.serviceType,
+            hosts = hostAddresses(s),
+            port = s.port,
+            txt = s.attributes.mapValues { (_, value) -> value?.let { String(it, Charsets.UTF_8) } ?: "" }
+        )
+
+    private fun hostAddresses(s: NsdServiceInfo): List<String> =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            s.hostAddresses.mapNotNull { it.hostAddress }
+        } else {
+            @Suppress("DEPRECATION")
+            s.host?.hostAddress?.let { listOf(it) } ?: emptyList()
+        }
+}

package/android/src/main/java/com/devioarts/capacitor/mdns/MdnsOptions.kt

@@ -0,0 +1,32 @@
+package com.devioarts.capacitor.mdns
+
+import org.json.JSONObject
+
+/** Parses the raw values supplied by the Capacitor JSON bridge. */
+internal object MdnsOptions {
+    fun string(raw: Any?, key: String): String? {
+        require(raw == null || raw === JSONObject.NULL || raw is String) { "Invalid $key" }
+        return raw as? String
+    }
+
+    fun port(raw: Any?): Int {
+        require(raw is Number && raw.toDouble() in 1.0..65535.0 && raw.toDouble() % 1.0 == 0.0) { "Missing/invalid port" }
+        return raw.toInt()
+    }
+
+    fun txt(raw: Any?): Map<String, String> {
+        if (raw == null || raw === JSONObject.NULL) return emptyMap()
+        require(raw is JSONObject) { "TXT must be an object of strings" }
+        return raw.keys().asSequence().associateWith { key ->
+            val value = raw.get(key)
+            require(value is String) { "TXT values must be strings" }
+            value
+        }.also { MdnsValidation.txt(it) }
+    }
+
+    fun timeout(raw: Any?): Int {
+        if (raw == null || raw === JSONObject.NULL) return 3000
+        require(raw is Number && raw.toDouble().isFinite()) { "Invalid timeout" }
+        return raw.toDouble().coerceIn(0.0, Int.MAX_VALUE.toDouble()).toInt()
+    }
+}

package/android/src/main/java/com/devioarts/capacitor/mdns/MdnsValidation.kt

@@ -0,0 +1,26 @@
+package com.devioarts.capacitor.mdns
+
+internal object MdnsValidation {
+    fun type(raw: String?): String {
+        val type = raw?.trim()?.takeIf { it.isNotEmpty() }?.removeSuffix(".")?.lowercase() ?: "_http._tcp"
+        val match = Regex("^_([a-z0-9](?:[a-z0-9-]{0,13}[a-z0-9])?)\\._(tcp|udp)$").matchEntire(type)
+        require(match != null && match.groupValues[1].any { it in 'a'..'z' } && !match.groupValues[1].contains("--")) { "Invalid service type: $raw" }
+        return "$type."
+    }
+    fun name(raw: String?): String {
+        val name = raw?.trim().orEmpty()
+        require(name.toByteArray(Charsets.UTF_8).size <= 63 && raw.orEmpty().none { it < ' ' || it == '\u007f' }) { "Invalid instance name (maximum 63 UTF-8 bytes, no control characters)" }
+        return name
+    }
+    fun txt(txt: Map<String, String>) {
+        val keys = mutableSetOf<String>()
+        var totalBytes = 0
+        txt.forEach { (key, value) ->
+            require(key.isNotEmpty() && key.all { it in ' '..'~' && it != '=' } && keys.add(key.lowercase())) { "Invalid or duplicate TXT key" }
+            val bytes = "$key=$value".toByteArray(Charsets.UTF_8).size
+            totalBytes += bytes + 1
+            require(totalBytes <= 1300) { "TXT record must fit in 1300 bytes including length prefixes" }
+            require(bytes <= 255) { "TXT entries must be at most 255 UTF-8 bytes including key=" }
+        }
+    }
+}

package/android/src/main/java/com/devioarts/capacitor/mdns/NsdBackend.kt

@@ -0,0 +1,59 @@
+package com.devioarts.capacitor.mdns
+// English-only code and comments.
+
+/**
+ * Thin seam over `NsdManager` so the discovery/registration logic can be unit-tested on the JVM.
+ *
+ * Contract:
+ * - Listener callbacks MAY be invoked from any thread (the real NSD service uses its own thread for
+ *   the legacy overloads). The consumer ([mDNS]) is responsible for hopping to its main thread.
+ * - Methods may throw; registration/stop failures must reach the caller.
+ * - Returned tokens are opaque and only meaningful when handed back to the same backend.
+ */
+internal interface NsdBackend {
+
+    /** True when several resolves can be in flight at once (API 34+ `ServiceInfoCallback`). */
+    val supportsConcurrentResolve: Boolean
+
+    fun acquireMulticastLock()
+    fun releaseMulticastLock()
+
+    fun registerService(type: String, name: String, port: Int, txt: Map<String, String>, listener: RegistrationListener): Any
+    fun unregisterService(token: Any)
+
+    fun startDiscovery(type: String, listener: DiscoveryListener): Any
+    fun stopDiscovery(token: Any)
+
+    /** Returns a token to hand to [cancelResolve], or null when there is nothing to cancel. */
+    fun resolve(service: DiscoveredService, listener: ResolveListener): Any?
+    fun cancelResolve(token: Any)
+
+    interface RegistrationListener {
+        fun onRegistered(publishedName: String)
+        fun onFailed(errorCode: Int)
+        fun onUnregistered()
+        fun onUnregistrationFailed(errorCode: Int)
+    }
+
+    interface DiscoveryListener {
+        fun onStartFailed(errorCode: Int)
+        fun onFound(service: DiscoveredService)
+        fun onLost(service: DiscoveredService) {}
+        fun onStopFailed(errorCode: Int) {}
+        fun onStopped() {}
+    }
+
+    interface ResolveListener {
+        fun onResolved(service: mDNS.MdnsService)
+        fun onFailed(errorCode: Int)
+    }
+}
+
+/** A service reported by discovery but not resolved yet. [handle] is backend-specific. */
+internal class DiscoveredService(val name: String, val type: String, val handle: Any? = null)
+
+/** Abstraction over "the main thread" so tests can substitute their own single thread. */
+internal interface MainThread {
+    fun isCurrent(): Boolean
+    fun post(block: () -> Unit)
+}