@tamer4lynx/tamer-dev-client 0.0.1

package/README.md

@@ -0,0 +1,31 @@
+# tamer-dev-client
+
+Native dev client module for Tamer4Lynx — QR scan, discovery, URL persistence, reload bridge, embedded dev launcher UI.
+
+## Installation
+
+```bash
+npm install @tamer4lynx/tamer-dev-client
+```
+
+Add to your app's dependencies and run `t4l link`. Used by **tamer-dev-app** for the dev launcher experience.
+
+## Usage
+
+The dev client provides:
+
+- **Discovery** — Find dev servers on the local network
+- **Connect** — Enter URL or scan QR code to connect
+- **Recent** — List of recently used dev server URLs
+- **Reload** — Reload the Lynx bundle
+- **Compatibility check** — Validates native modules between app and project
+
+When building the dev app (`t4l build-dev-app`), the dev client UI is embedded and the Lynx bundle is loaded from the connected dev server.
+
+## Dependencies
+
+Requires: `tamer-app-shell`, `tamer-insets`, `tamer-system-ui`, `tamer-plugin`, `tamer-router`, `react-router`, `@lynx-js/react`.
+
+## Platform
+
+Uses **lynx.ext.json**. Run `t4l link` after adding to your app.

package/android/build.gradle.kts

@@ -0,0 +1,34 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "com.nanofuxion.tamerdevclient"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 28
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+dependencies {
+    implementation("org.lynxsdk.lynx:lynx-service-log:3.3.1")
+    implementation("androidx.activity:activity-ktx:1.8.2")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
+    implementation("org.lynxsdk.lynx:lynx:3.3.1")
+    implementation("org.lynxsdk.lynx:lynx-jssdk:3.3.1")
+    implementation("org.lynxsdk.lynx:lynx-trace:3.3.1")
+    implementation("com.squareup.okhttp3:okhttp:4.9.0")
+    implementation("com.journeyapps:zxing-android-embedded:4.3.0")
+    implementation("androidx.appcompat:appcompat:1.6.1")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.CAMERA" />
+</manifest>

package/android/src/main/kotlin/com/nanofuxion/tamerdevclient/DevClientModule.kt

@@ -0,0 +1,311 @@
+package com.nanofuxion.tamerdevclient
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.google.zxing.integration.android.IntentIntegrator
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.jsbridge.LynxModule
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.JavaOnlyArray
+import com.lynx.react.bridge.JavaOnlyMap
+import com.lynx.tasm.LynxView
+import com.lynx.tasm.behavior.LynxContext
+import com.nanofuxion.tamerdevclient.nsd.DiscoveredServer
+import com.nanofuxion.tamerdevclient.nsd.NsdDiscovery
+import org.json.JSONObject
+
+class DevClientModule(context: Context) : LynxModule(context) {
+
+    companion object {
+        private const val TAG = "DevClientModule"
+        const val ACTION_RELOAD_PROJECT = "com.tamer4lynx.RELOAD_PROJECT"
+        private const val PREFS = "tamer_dev_server"
+        private const val KEY_URL = "dev_server_url"
+        private const val KEY_RECENT = "dev_server_recent"
+
+        @Volatile
+        var instance: DevClientModule? = null
+
+        @Volatile
+        private var hostActivity: Activity? = null
+
+        @Volatile
+        private var lynxViewRef: LynxView? = null
+
+        private var requestCameraPermission: ((Runnable) -> Unit)? = null
+        private var launchScan: Runnable? = null
+        private var reloadProjectLauncher: Runnable? = null
+
+        fun attachHostActivity(activity: Activity?) {
+            hostActivity = activity
+        }
+
+        fun attachLynxView(view: LynxView?) {
+            lynxViewRef = view
+        }
+
+        fun attachCameraPermissionRequester(requester: (Runnable) -> Unit) {
+            requestCameraPermission = requester
+        }
+
+        fun attachScanLauncher(launcher: Runnable) {
+            launchScan = launcher
+        }
+
+        fun attachReloadProjectLauncher(launcher: Runnable?) {
+            reloadProjectLauncher = launcher
+        }
+
+        @Volatile
+        private var supportedModuleClassNames: Set<String> = emptySet()
+
+        fun attachSupportedModuleClassNames(names: List<String>) {
+            supportedModuleClassNames = names.filter { it.isNotBlank() }.toSet()
+        }
+
+        fun getSupportedModuleClassNames(): Set<String> = supportedModuleClassNames
+    }
+
+    private var nsdDiscovery: NsdDiscovery? = null
+    private var lastDiscovered: List<DiscoveredServer> = emptyList()
+
+    data class CompatibilityResult(val compatible: Boolean, val requiredModules: List<Pair<String, String>>)
+
+    private fun fetchMetaAndCheckCompatibility(baseUrl: String): CompatibilityResult? {
+        val supported = DevClientModule.getSupportedModuleClassNames()
+        if (supported.isEmpty()) return CompatibilityResult(true, emptyList())
+        return try {
+            val metaUrl = baseUrl.trimEnd('/') + "/meta.json"
+            val request = okhttp3.Request.Builder().url(metaUrl).build()
+            val client = okhttp3.OkHttpClient.Builder()
+                .connectTimeout(5, java.util.concurrent.TimeUnit.SECONDS)
+                .readTimeout(5, java.util.concurrent.TimeUnit.SECONDS)
+                .build()
+            val response = client.newCall(request).execute()
+            if (!response.isSuccessful || response.body == null) return null
+            val body = response.body!!.string()
+            val json = org.json.JSONObject(body)
+            val arr = json.optJSONArray("nativeModules") ?: return CompatibilityResult(true, emptyList())
+            val required = mutableListOf<Pair<String, String>>()
+            for (i in 0 until arr.length()) {
+                val obj = arr.getJSONObject(i)
+                val pkg = obj.optString("packageName", "")
+                val cls = obj.optString("moduleClassName", "")
+                if (cls.isNotBlank() && cls !in supported) {
+                    required.add(pkg to cls)
+                }
+            }
+            CompatibilityResult(required.isEmpty(), required)
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    init {
+        instance = this
+    }
+
+    fun setActivity(activity: Activity?) {
+        attachHostActivity(activity)
+    }
+
+    fun setCameraPermissionRequester(requester: (Runnable) -> Unit) {
+        attachCameraPermissionRequester(requester)
+    }
+
+    private fun getLynxContext(): LynxContext? = mContext as? LynxContext
+
+    private fun emitDiscoveredServers(servers: List<DiscoveredServer>) {
+        lastDiscovered = servers
+        val arr = org.json.JSONArray()
+        for (s in servers) {
+            val obj = org.json.JSONObject()
+            obj.put("url", s.url)
+            obj.put("name", s.name)
+            arr.put(obj)
+        }
+        val payload = org.json.JSONObject().put("servers", arr).toString()
+        val eventDetails = JavaOnlyMap()
+        eventDetails.putString("payload", payload)
+        val params = JavaOnlyArray()
+        params.pushMap(eventDetails)
+        val lynxContext = getLynxContext()
+        if (lynxContext != null) {
+            lynxContext.sendGlobalEvent("devclient:discoveredServers", params)
+        } else {
+            lynxViewRef?.sendGlobalEvent("devclient:discoveredServers", params)
+        }
+    }
+
+    private fun prefs() = mContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+
+    @LynxMethod
+    fun getDevServerUrl(callback: Callback) {
+        callback.invoke(prefs().getString(KEY_URL, null) ?: "")
+    }
+
+    @LynxMethod
+    fun setDevServerUrl(url: String) {
+        val normalized = url.trim().removeSuffix("/").let { u ->
+            when {
+                u.endsWith("/main.lynx.bundle") -> u.removeSuffix("/main.lynx.bundle")
+                u.endsWith("main.lynx.bundle") -> u.removeSuffix("main.lynx.bundle").trimEnd('/')
+                else -> u
+            }
+        }
+        prefs().edit().putString(KEY_URL, normalized).commit()
+        addRecent(normalized)
+    }
+
+    private fun addRecent(url: String) {
+        val current = parseRecentJson().filter { it != url }
+        val updated = listOf(url) + current
+        prefs().edit()
+            .putString(KEY_RECENT, org.json.JSONArray(updated.take(10)).toString())
+            .apply()
+    }
+
+    private fun parseRecentJson(): List<String> {
+        val json = prefs().getString(KEY_RECENT, "[]") ?: "[]"
+        return try {
+            val ja = org.json.JSONArray(json)
+            (0 until ja.length()).map { ja.getString(it) }
+        } catch (_: Exception) { emptyList() }
+    }
+
+    @LynxMethod
+    fun getRecentUrls(callback: Callback) {
+        val arr = JavaOnlyArray()
+        for (s in parseRecentJson()) arr.pushString(s)
+        callback.invoke(arr)
+    }
+
+    @LynxMethod
+    fun clearDevServerUrl() {
+        prefs().edit().clear().apply()
+    }
+
+    @LynxMethod
+    fun scanQR() {
+        val activity = hostActivity ?: (mContext as? LynxContext)?.activity as? Activity
+        if (activity == null) {
+            Log.e(TAG, "No activity for QR scan")
+            emitScanResult(null)
+            return
+        }
+        activity.runOnUiThread {
+            if (ContextCompat.checkSelfPermission(mContext, android.Manifest.permission.CAMERA) == android.content.pm.PackageManager.PERMISSION_GRANTED) {
+                launchScanner()
+                return@runOnUiThread
+            }
+            val requester = requestCameraPermission
+            if (requester != null) {
+                requester(Runnable { launchScanner() })
+            } else {
+                Log.e(TAG, "No camera permission requester set; call setCameraPermissionRequester from Activity")
+                emitScanResult(null)
+            }
+        }
+    }
+
+    private fun launchScanner() {
+        launchScan?.run() ?: run {
+            val activity = hostActivity
+            if (activity != null) {
+                IntentIntegrator(activity).setPrompt("Scan dev server QR").initiateScan()
+            } else {
+                Log.e(TAG, "No scan launcher or activity for QR scan")
+                emitScanResult(null)
+            }
+        }
+    }
+
+    fun deliverScanResult(contents: String?) {
+        emitScanResult(contents)
+    }
+
+    private fun emitScanResult(url: String?) {
+        val json = JSONObject().apply { put("url", url ?: "") }.toString()
+        val eventDetails = JavaOnlyMap()
+        eventDetails.putString("payload", json)
+        val params = JavaOnlyArray()
+        params.pushMap(eventDetails)
+        val lynxContext = getLynxContext()
+        if (lynxContext != null) {
+            lynxContext.sendGlobalEvent("devclient:scanResult", params)
+        } else {
+            lynxViewRef?.sendGlobalEvent("devclient:scanResult", params)
+        }
+    }
+
+    @LynxMethod
+    fun reloadWithProjectBundle() {
+        val launcher = reloadProjectLauncher
+        val activity = hostActivity
+        if (launcher != null && activity != null) {
+            activity.runOnUiThread { launcher.run() }
+        } else {
+            mContext.sendBroadcast(Intent(ACTION_RELOAD_PROJECT).setPackage(mContext.packageName))
+        }
+    }
+
+    @LynxMethod
+    fun startDiscovery() {
+        val app = mContext.applicationContext
+        if (nsdDiscovery != null) return
+        nsdDiscovery = NsdDiscovery(
+            app as android.app.Application,
+            { url -> fetchMetaAndCheckCompatibility(url)?.let { it.compatible } ?: true }
+        ) { servers ->
+            emitDiscoveredServers(servers)
+        }
+        nsdDiscovery?.start()
+    }
+
+    @LynxMethod
+    fun stopDiscovery() {
+        nsdDiscovery?.stop()
+        nsdDiscovery = null
+    }
+
+    @LynxMethod
+    fun getDiscoveredServers(callback: Callback) {
+        val arr = JavaOnlyArray()
+        for (s in lastDiscovered) {
+            val map = JavaOnlyMap()
+            map.putString("url", s.url)
+            map.putString("name", s.name)
+            arr.pushMap(map)
+        }
+        callback.invoke(arr)
+    }
+
+    @LynxMethod
+    fun checkServerCompatibility(baseUrl: String, callback: Callback) {
+        Thread {
+            val result = fetchMetaAndCheckCompatibility(baseUrl)
+            val activity = hostActivity
+            if (activity != null) {
+                activity.runOnUiThread {
+                    if (result == null) {
+                        callback.invoke(true, JavaOnlyArray())
+                    } else {
+                        val requiredArr = JavaOnlyArray()
+                        for ((pkg, cls) in result.requiredModules) {
+                            val map = JavaOnlyMap()
+                            map.putString("packageName", pkg)
+                            map.putString("moduleClassName", cls)
+                            requiredArr.pushMap(map)
+                        }
+                        callback.invoke(result.compatible, requiredArr)
+                    }
+                }
+            } else {
+                callback.invoke(true, JavaOnlyArray())
+            }
+        }.start()
+    }
+}

package/android/src/main/kotlin/com/nanofuxion/tamerdevclient/TamerRelogLogService.kt

@@ -0,0 +1,141 @@
+package com.nanofuxion.tamerdevclient
+
+import android.content.Context
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import androidx.annotation.Keep
+import com.lynx.service.log.LynxLogService
+import com.lynx.tasm.service.ILynxLogService
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.TimeUnit
+import java.util.regex.Pattern
+
+@Keep
+object TamerRelogLogService : ILynxLogService {
+    private const val PREFS = "tamer_dev_server"
+    private const val KEY_URL = "dev_server_url"
+    private const val MAX_QUEUE = 100
+    private const val RECONNECT_DELAY_MS = 3000L
+
+    @Volatile private var appContext: Context? = null
+    @Volatile private var ws: WebSocket? = null
+    @Volatile private var connecting = false
+    @Volatile private var shouldReconnect = false
+    private val pendingQueue = ArrayDeque<String>()
+    private val handler = Handler(Looper.getMainLooper())
+
+    private val client = OkHttpClient.Builder()
+        .connectTimeout(5, TimeUnit.SECONDS)
+        .readTimeout(0, TimeUnit.SECONDS)
+        .build()
+
+    private val consoleLogPattern = Pattern.compile(
+        """\[.*?:(?:INFO|ERROR|WARN(?:ING)?|DEBUG|VERBOSE|FATAL):lynx_console\.cc\(\d+\)] (.+)""",
+        Pattern.DOTALL
+    )
+
+    fun init(context: Context) {
+        appContext = context.applicationContext
+    }
+
+    fun connect() {
+        shouldReconnect = true
+        if (connecting || ws != null) return
+        val ctx = appContext ?: return
+        val devUrl = ctx.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+            .getString(KEY_URL, null) ?: return
+        val wsUrl = buildWsUrl(devUrl) ?: return
+        connecting = true
+        val request = Request.Builder().url(wsUrl).build()
+        client.newWebSocket(request, object : WebSocketListener() {
+            override fun onOpen(socket: WebSocket, response: okhttp3.Response) {
+                ws = socket
+                connecting = false
+                val ping = JSONObject().apply {
+                    put("type", "console_log")
+                    put("tag", "lynx-console")
+                    put("message", JSONArray().put("[TamerRelog] connected"))
+                }.toString()
+                socket.send(ping)
+                synchronized(pendingQueue) {
+                    while (pendingQueue.isNotEmpty()) {
+                        socket.send(pendingQueue.removeFirst())
+                    }
+                }
+            }
+            override fun onFailure(socket: WebSocket, t: Throwable, response: okhttp3.Response?) {
+                ws = null
+                connecting = false
+                synchronized(pendingQueue) { pendingQueue.clear() }
+                scheduleReconnect()
+            }
+            override fun onClosed(socket: WebSocket, code: Int, reason: String) {
+                ws = null
+                connecting = false
+                scheduleReconnect()
+            }
+        })
+    }
+
+    private fun scheduleReconnect() {
+        if (!shouldReconnect) return
+        handler.postDelayed({ connect() }, RECONNECT_DELAY_MS)
+    }
+
+    fun disconnect() {
+        shouldReconnect = false
+        handler.removeCallbacksAndMessages(null)
+        ws?.close(1000, null)
+        ws = null
+        connecting = false
+        synchronized(pendingQueue) { pendingQueue.clear() }
+    }
+
+    override fun logByPlatform(level: Int, tag: String, msg: String) {
+        LynxLogService.logByPlatform(level, tag, msg)
+
+        val (forwardTag, forwardMsg) = if (tag == "lynx") {
+            val m = consoleLogPattern.matcher(msg)
+            if (m.find()) "lynx-console" to m.group(1)!! else tag to msg
+        } else {
+            tag to msg
+        }
+
+        val payload = try {
+            JSONObject().apply {
+                put("type", "console_log")
+                put("tag", forwardTag)
+                put("message", JSONArray().put(forwardMsg))
+            }.toString()
+        } catch (_: Exception) { return }
+
+        val socket = ws
+        if (socket != null) {
+            socket.send(payload)
+        } else if (connecting) {
+            synchronized(pendingQueue) {
+                if (pendingQueue.size < MAX_QUEUE) pendingQueue.addLast(payload)
+            }
+        }
+    }
+
+    private fun buildWsUrl(devUrl: String): String? {
+        val uri = Uri.parse(devUrl)
+        val scheme = if (uri.scheme == "https") "wss" else "ws"
+        val host = uri.host ?: return null
+        val port = if (uri.port > 0) ":${uri.port}" else ""
+        val path = (uri.path ?: "").let { p -> (if (p.endsWith("/")) p else p + "/") + "__hmr" }
+        return "$scheme://$host$port$path"
+    }
+
+    override fun isLogOutputByPlatform(): Boolean = true
+    override fun getDefaultWriteFunction(): Long = 0
+    override fun switchLogToSystem(enableSystemLog: Boolean) {}
+    override fun getLogToSystemStatus(): Boolean = false
+}

package/android/src/main/kotlin/com/nanofuxion/tamerdevclient/nsd/NsdDiscovery.kt

@@ -0,0 +1,138 @@
+package com.nanofuxion.tamerdevclient.nsd
+
+import android.app.Application
+import android.content.Context
+import android.net.nsd.NsdManager
+import android.net.nsd.NsdServiceInfo
+import android.util.Log
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.util.concurrent.TimeUnit
+
+private const val SERVICE_TYPE = "_tamer._tcp."
+private const val TAG = "NsdDiscovery"
+
+data class DiscoveredServer(val url: String, val name: String)
+
+class NsdDiscovery(
+    application: Application,
+    private val isCompatible: (String) -> Boolean = { true },
+    private val onServersChanged: (List<DiscoveredServer>) -> Unit
+) {
+    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
+    private val nsdManager = application.getSystemService(Context.NSD_SERVICE) as? NsdManager
+    private val httpClient = OkHttpClient.Builder()
+        .connectTimeout(5, TimeUnit.SECONDS)
+        .readTimeout(5, TimeUnit.SECONDS)
+        .build()
+
+    private var isDiscovering = false
+    private var healthCheckJob: Job? = null
+    private val potentialServers = mutableSetOf<PotentialServer>()
+
+    private data class PotentialServer(val serviceName: String, val url: String, val name: String)
+
+    private val discoveryListener = object : NsdManager.DiscoveryListener {
+        override fun onDiscoveryStarted(serviceType: String) {}
+        override fun onServiceFound(service: NsdServiceInfo) {
+            scope.launch { resolveAndAdd(service) }
+        }
+
+        override fun onServiceLost(service: NsdServiceInfo) {
+            val name = service.serviceName ?: return
+            synchronized(potentialServers) {
+                potentialServers.removeAll { it.serviceName == name }
+            }
+        }
+
+        override fun onDiscoveryStopped(serviceType: String) {
+            synchronized(potentialServers) { potentialServers.clear() }
+            onServersChanged(emptyList())
+        }
+
+        override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
+            Log.e(TAG, "Discovery start failed: $errorCode")
+            isDiscovering = false
+        }
+
+        override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {
+            Log.e(TAG, "Discovery stop failed: $errorCode")
+        }
+    }
+
+    fun start() {
+        if (nsdManager == null) {
+            Log.e(TAG, "NsdManager not available")
+            return
+        }
+        if (isDiscovering) return
+        nsdManager.discoverServices(SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, discoveryListener)
+        isDiscovering = true
+        startHealthCheck()
+    }
+
+    fun stop() {
+        if (!isDiscovering) return
+        nsdManager?.stopServiceDiscovery(discoveryListener)
+        isDiscovering = false
+        healthCheckJob?.cancel()
+        healthCheckJob = null
+        synchronized(potentialServers) { potentialServers.clear() }
+        onServersChanged(emptyList())
+    }
+
+    private suspend fun resolveAndAdd(serviceInfo: NsdServiceInfo) {
+        if (nsdManager == null) return
+        try {
+            val resolved = nsdManager.resolveServiceCoroutine(serviceInfo)
+            scope.ensureActive()
+            val baseUrl = resolved.getUrl() ?: return
+            val path = resolved.getAttribute("path") ?: ""
+            val url = baseUrl.trimEnd('/') + path
+            val name = resolved.getAttribute("name") ?: resolved.serviceName ?: url
+            synchronized(potentialServers) {
+                potentialServers.add(PotentialServer(resolved.serviceName ?: "", url, name))
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Resolve failed: ${e.message}")
+        }
+    }
+
+    private fun startHealthCheck() {
+        healthCheckJob?.cancel()
+        healthCheckJob = scope.launch {
+            while (isActive && isDiscovering) {
+                val current = synchronized(potentialServers) { potentialServers.toList() }
+                val alive = current
+                    .map { s -> async { s to (checkStatus(s.url) && isCompatible(s.url)) } }
+                    .awaitAll()
+                    .filter { (_, ok) -> ok }
+                    .map { (s, _) -> DiscoveredServer(s.url, s.name) }
+                ensureActive()
+                onServersChanged(alive)
+                delay(3000)
+            }
+        }
+    }
+
+    private fun checkStatus(url: String): Boolean {
+        return try {
+            val statusUrl = url.trimEnd('/') + "/status"
+            val request = Request.Builder().url(statusUrl).build()
+            val response = httpClient.newCall(request).execute()
+            response.isSuccessful && (response.body?.string()?.contains("packager-status:running") == true)
+        } catch (_: Exception) {
+            false
+        }
+    }
+}

package/android/src/main/kotlin/com/nanofuxion/tamerdevclient/nsd/NsdServiceInfoExtensions.kt

@@ -0,0 +1,26 @@
+package com.nanofuxion.tamerdevclient.nsd
+
+import android.net.nsd.NsdServiceInfo
+import android.os.Build
+import java.net.Inet4Address
+
+private fun NsdServiceInfo.getHostIpv4(): Inet4Address? {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        hostAddresses.filterIsInstance<Inet4Address>().firstOrNull()
+    } else {
+        @Suppress("DEPRECATION")
+        host as? Inet4Address
+    }
+}
+
+fun NsdServiceInfo.getUrl(): String? {
+    val hostIp = getHostIpv4() ?: return null
+    val port = port
+    return "http://${hostIp.hostAddress}:$port"
+}
+
+fun NsdServiceInfo.getAttribute(attributeName: String): String? {
+    val attributes = attributes ?: return null
+    val attributeValue = attributes[attributeName] ?: return null
+    return String(attributeValue, Charsets.UTF_8)
+}