@adeeliore/p2p-lan-signaling 0.1.0

package/plugin/templates/android/OfflineSignalingPackage.kt

@@ -0,0 +1,609 @@
+package com.anonymous.DrawingApp.offline
+
+import android.net.Uri
+import android.content.Context
+import android.net.nsd.NsdManager
+import android.net.nsd.NsdServiceInfo
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.ViewManager
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.EOFException
+import java.io.InputStream
+import java.io.InputStreamReader
+import java.io.OutputStream
+import java.net.Inet4Address
+import java.net.NetworkInterface
+import java.net.ServerSocket
+import java.net.Socket
+import java.net.SocketException
+import java.nio.charset.StandardCharsets
+import java.security.MessageDigest
+import java.util.Base64
+import java.util.UUID
+import java.util.Collections
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+
+@Suppress("OVERRIDE_DEPRECATION")
+class OfflineSignalingPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(OfflineSignalingHostModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}
+
+class OfflineSignalingHostModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+  private val manager = OfflineSignalingHostManager(reactContext)
+
+  override fun getName(): String = OfflineSignalingContract.MODULE_NAME
+
+  @ReactMethod
+  fun startHost(port: Int, roomId: String?, displayName: String?, roomSecret: String?, promise: Promise) {
+    try {
+      promise.resolve(toWritableMap(manager.start(port, roomId, displayName, roomSecret)))
+    } catch (error: Exception) {
+      promise.reject("offline_host_start_failed", error.message, error)
+    }
+  }
+
+  @ReactMethod
+  fun stopHost(promise: Promise) {
+    manager.stop()
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  fun getStatus(promise: Promise) {
+    promise.resolve(toWritableMap(manager.getStatus()))
+  }
+
+  @ReactMethod
+  fun discoverHosts(timeoutMs: Int, promise: Promise) {
+    try {
+      promise.resolve(toWritableArray(manager.discoverHosts(timeoutMs)))
+    } catch (error: Exception) {
+      promise.reject("offline_host_discovery_failed", error.message, error)
+    }
+  }
+
+  private fun toWritableMap(status: OfflineHostStatus): WritableMap {
+    return Arguments.createMap().apply {
+      putBoolean("running", status.running)
+      putString("hostAddress", status.hostAddress)
+      if (status.port == null) putNull("port") else putInt("port", status.port)
+      putString("url", status.url)
+      putString("roomId", status.roomId)
+      putString("serviceName", status.serviceName)
+      putString("serviceType", status.serviceType)
+    }
+  }
+
+  private fun toWritableArray(hosts: List<OfflineDiscoveredHost>): WritableArray {
+    return Arguments.createArray().apply {
+      hosts.forEach { host ->
+        pushMap(Arguments.createMap().apply {
+          putString("serviceName", host.serviceName)
+          putString("serviceType", host.serviceType)
+          putString("hostAddress", host.hostAddress)
+          putInt("port", host.port)
+          putString("url", host.url)
+          putString("roomId", host.roomId)
+          putString("displayName", host.displayName)
+        })
+      }
+    }
+  }
+}
+
+data class OfflineHostStatus(
+  val running: Boolean,
+  val hostAddress: String?,
+  val port: Int?,
+  val url: String?,
+  val roomId: String? = null,
+  val serviceName: String? = null,
+  val serviceType: String? = null,
+)
+
+data class OfflineDiscoveredHost(
+  val serviceName: String,
+  val serviceType: String,
+  val hostAddress: String,
+  val port: Int,
+  val url: String,
+  val roomId: String?,
+  val displayName: String?,
+)
+
+object OfflineSecurityPolicy {
+  const val MAX_PARTICIPANTS = 10
+  const val MAX_TEXT_FRAME_BYTES = 65536
+  val sessionIdRegex = Regex("^[A-Za-z0-9_-]{8,64}$")
+  val clientIdRegex = Regex("^[A-Za-z0-9_-]{3,64}$")
+}
+
+object OfflineSignalingContract {
+  const val MODULE_NAME = "OfflineSignalingHost"
+  const val SERVICE_TYPE = "_drawin._tcp"
+  const val ANDROID_SERVICE_TYPE = "$SERVICE_TYPE."
+  const val WEBSOCKET_PATH = "/ws"
+  const val QUERY_SESSION_ID = "sessionId"
+  const val QUERY_CLIENT_ID = "clientId"
+  const val QUERY_ACCESS_TOKEN = "accessToken"
+  const val QUERY_ROOM_SECRET = "roomSecret"
+  const val TXT_ROOM_ID = "roomId"
+  const val TXT_DISPLAY_NAME = "displayName"
+  const val DISCOVERY_MIN_TIMEOUT_MS = 500
+  const val DISCOVERY_MAX_TIMEOUT_MS = 10000
+}
+
+class OfflineSignalingHostManager(context: Context) {
+  private val discovery = LanServiceDiscovery(context)
+  private var server: OfflineSignalingServer? = null
+
+  @Synchronized
+  fun start(port: Int, roomId: String?, displayName: String?, roomSecret: String?): OfflineHostStatus {
+    val existing = server
+    if (existing != null && existing.status.running) {
+      if (existing.matches(port, roomId, displayName, roomSecret)) {
+        return existing.status
+      }
+      existing.stop()
+      server = null
+    }
+
+    val next = OfflineSignalingServer(port, roomId, displayName, roomSecret, discovery)
+    server = next
+    return next.start()
+  }
+
+  @Synchronized
+  fun stop() {
+    server?.stop()
+    server = null
+  }
+
+  @Synchronized
+  fun getStatus(): OfflineHostStatus {
+    return server?.status ?: OfflineHostStatus(false, null, null, null, null, null, OfflineSignalingContract.SERVICE_TYPE)
+  }
+
+  fun discoverHosts(timeoutMs: Int): List<OfflineDiscoveredHost> {
+    return discovery.discover(timeoutMs)
+  }
+}
+
+class OfflineSignalingServer(
+  private val requestedPort: Int,
+  private val roomId: String?,
+  private val displayName: String?,
+  private val roomSecret: String?,
+  private val discovery: LanServiceDiscovery,
+) {
+  private val running = AtomicBoolean(false)
+  private val executor = Executors.newCachedThreadPool()
+  private val clients = CopyOnWriteArrayList<OfflineSignalingClient>()
+  private val router = OfflineSignalingRouter()
+  private var serverSocket: ServerSocket? = null
+  private var hostAddress: String? = null
+
+  val status: OfflineHostStatus
+    get() {
+      val actualPort = serverSocket?.localPort?.takeIf { it > 0 } ?: requestedPort
+      val address = hostAddress
+      return OfflineHostStatus(
+        running = running.get(),
+        hostAddress = address,
+        port = actualPort,
+        url = if (running.get() && address != null) "ws://$address:$actualPort" else null,
+        roomId = roomId,
+        serviceName = if (running.get()) serviceName() else null,
+        serviceType = OfflineSignalingContract.SERVICE_TYPE,
+      )
+    }
+
+  fun start(): OfflineHostStatus {
+    if (running.get()) return status
+    hostAddress = LocalNetworkAddressResolver.resolveIpv4Address()
+    val socket = ServerSocket(requestedPort)
+    serverSocket = socket
+    running.set(true)
+    discovery.register(serviceName(), socket.localPort, roomId, displayName)
+    executor.execute {
+      while (running.get()) {
+        try {
+          val clientSocket = socket.accept()
+          val client = OfflineSignalingClient(clientSocket, router, roomSecret)
+          clients.add(client)
+          executor.execute {
+            client.run()
+            clients.remove(client)
+          }
+        } catch (_: SocketException) {
+          break
+        } catch (_: Exception) {
+        }
+      }
+    }
+    return status
+  }
+
+  fun stop() {
+    if (!running.getAndSet(false)) return
+    clients.forEach { it.close() }
+    clients.clear()
+    try { serverSocket?.close() } catch (_: Exception) {}
+    discovery.unregister()
+    serverSocket = null
+  }
+
+  fun matches(port: Int, nextRoomId: String?, nextDisplayName: String?, nextRoomSecret: String?): Boolean {
+    val actualPort = serverSocket?.localPort?.takeIf { it > 0 } ?: requestedPort
+    return actualPort == port &&
+      roomId.orEmpty() == nextRoomId.orEmpty() &&
+      displayName.orEmpty() == nextDisplayName.orEmpty() &&
+      roomSecret.orEmpty() == nextRoomSecret.orEmpty()
+  }
+
+  private fun serviceName(): String {
+    val suffix = roomId?.takeIf { it.isNotBlank() } ?: requestedPort.toString()
+    return displayName?.takeIf { it.isNotBlank() } ?: "Drawin $suffix"
+  }
+}
+
+class OfflineSignalingClient(
+  private val socket: Socket,
+  private val router: OfflineSignalingRouter,
+  private val roomSecret: String?,
+) : Runnable {
+  private val running = AtomicBoolean(true)
+  private val output = socket.getOutputStream()
+  var sessionId: String? = null
+    private set
+  var clientId: String? = null
+    private set
+
+  fun attach(sessionId: String, clientId: String) {
+    this.sessionId = sessionId
+    this.clientId = clientId
+  }
+
+  override fun run() {
+    try {
+      val request = WebSocketHandshake.accept(socket.getInputStream(), output, roomSecret)
+      router.register(request.sessionId, request.clientId, this)
+      while (running.get() && !socket.isClosed) {
+        val message = WebSocketFrameCodec.readText(socket.getInputStream()) ?: break
+        router.handleClientMessage(this, message)
+      }
+    } catch (_: Exception) {
+    } finally {
+      close()
+      router.unregister(this)
+    }
+  }
+
+  fun send(message: String) {
+    if (!running.get() || socket.isClosed) return
+    try {
+      WebSocketFrameCodec.writeText(output, message)
+    } catch (_: Exception) {
+      close()
+    }
+  }
+
+  fun close() {
+    if (!running.getAndSet(false)) return
+    try { socket.close() } catch (_: Exception) {}
+  }
+}
+
+class OfflineSignalingRouter {
+  private val sessions = ConcurrentHashMap<String, LinkedHashMap<String, OfflineSignalingClient>>()
+
+  @Synchronized
+  fun register(sessionId: String, requestedClientId: String?, client: OfflineSignalingClient): String {
+    if (!OfflineSecurityPolicy.sessionIdRegex.matches(sessionId)) {
+      client.send(JSONObject().put("type", "error").put("code", "invalid_session_id").put("message", "Invalid session id").toString())
+      client.close()
+      return ""
+    }
+
+    val session = sessions.getOrPut(sessionId) { linkedMapOf() }
+    if (session.size >= OfflineSecurityPolicy.MAX_PARTICIPANTS) {
+      client.send(JSONObject().put("type", "error").put("code", "session_full").put("message", "Session is full").toString())
+      client.close()
+      return ""
+    }
+
+    val clientId = resolveClientId(session, requestedClientId)
+    if (!OfflineSecurityPolicy.clientIdRegex.matches(clientId)) {
+      client.send(JSONObject().put("type", "error").put("code", "invalid_client_id").put("message", "Invalid client id").toString())
+      client.close()
+      return ""
+    }
+
+    client.attach(sessionId, clientId)
+    val peers = session.keys.map { JSONObject().put("clientId", it) }
+    session[clientId] = client
+    client.send(JSONObject().put("type", "welcome").put("sessionId", sessionId).put("clientId", clientId).put("peers", JSONArray(peers)).toString())
+    broadcastExcept(sessionId, clientId, JSONObject().put("type", "peer-joined").put("sessionId", sessionId).put("clientId", clientId).toString())
+    return clientId
+  }
+
+  @Synchronized
+  fun unregister(client: OfflineSignalingClient) {
+    val sessionId = client.sessionId ?: return
+    val clientId = client.clientId ?: return
+    val session = sessions[sessionId] ?: return
+    session.remove(clientId)
+    if (session.isEmpty()) {
+      sessions.remove(sessionId)
+      return
+    }
+    broadcast(sessionId, JSONObject().put("type", "peer-left").put("sessionId", sessionId).put("clientId", clientId).toString())
+  }
+
+  fun handleClientMessage(client: OfflineSignalingClient, rawMessage: String) {
+    if (rawMessage.isBlank()) return
+    val json = JSONObject(rawMessage)
+    when (val type = json.optString("type")) {
+      "ping" -> client.send(JSONObject().put("type", "pong").toString())
+      "offer", "answer", "ice" -> relay(client, type, json)
+      else -> client.send(JSONObject().put("type", "error").put("code", "unsupported_message").put("message", "Unsupported signaling message type: $type").toString())
+    }
+  }
+
+  @Synchronized
+  private fun relay(client: OfflineSignalingClient, type: String, json: JSONObject) {
+    val sessionId = client.sessionId ?: return
+    val from = client.clientId ?: return
+    val to = json.optString("to").takeIf { it.isNotBlank() } ?: return
+    if (!OfflineSecurityPolicy.clientIdRegex.matches(to)) {
+      client.send(JSONObject().put("type", "error").put("code", "invalid_to").put("message", "Invalid relay target").toString())
+      return
+    }
+    val target = sessions[sessionId]?.get(to)
+    if (target == null) {
+      client.send(JSONObject().put("type", "error").put("code", "peer_not_found").put("message", "Peer not found: $to").toString())
+      return
+    }
+    val message = JSONObject().put("type", type).put("sessionId", sessionId).put("from", from).put("to", to)
+    if (json.has("payload")) message.put("payload", json.get("payload"))
+    target.send(message.toString())
+  }
+
+  @Synchronized
+  private fun broadcast(sessionId: String, message: String) {
+    sessions[sessionId]?.values?.forEach { it.send(message) }
+  }
+
+  @Synchronized
+  private fun broadcastExcept(sessionId: String, exceptClientId: String, message: String) {
+    sessions[sessionId]?.filterKeys { it != exceptClientId }?.values?.forEach { it.send(message) }
+  }
+
+  private fun resolveClientId(session: Map<String, OfflineSignalingClient>, requestedClientId: String?): String {
+    val base = requestedClientId?.takeIf { it.isNotBlank() } ?: "user-\${UUID.randomUUID().toString().take(4)}"
+    if (!OfflineSecurityPolicy.clientIdRegex.matches(base)) return "user-\${UUID.randomUUID().toString().take(4)}"
+    if (!session.containsKey(base)) return base
+    var suffix = 2
+    while (session.containsKey("$base-$suffix")) suffix += 1
+    return "$base-$suffix"
+  }
+}
+
+data class WebSocketHandshakeRequest(val sessionId: String, val clientId: String?)
+
+object WebSocketHandshake {
+  private const val WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+  fun accept(input: InputStream, output: OutputStream, roomSecret: String?): WebSocketHandshakeRequest {
+    val reader = BufferedReader(InputStreamReader(input))
+    val requestLine = reader.readLine() ?: throw IllegalArgumentException("Missing WebSocket request line")
+    val path = requestLine.split(" ").getOrNull(1) ?: throw IllegalArgumentException("Invalid WebSocket request line")
+    val headers = mutableMapOf<String, String>()
+    while (true) {
+      val line = reader.readLine() ?: break
+      if (line.isEmpty()) break
+      val separator = line.indexOf(':')
+      if (separator > 0) headers[line.substring(0, separator).trim().lowercase()] = line.substring(separator + 1).trim()
+    }
+    val key = headers["sec-websocket-key"] ?: throw IllegalArgumentException("Missing Sec-WebSocket-Key")
+    val acceptKey = Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-1").digest((key + WS_GUID).toByteArray()))
+    output.write(("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: $acceptKey\r\n\r\n").toByteArray())
+    output.flush()
+    val uri = Uri.parse("ws://localhost$path")
+    if (uri.path != OfflineSignalingContract.WEBSOCKET_PATH) throw IllegalArgumentException("Unsupported WebSocket path")
+    val sessionId = uri.getQueryParameter(OfflineSignalingContract.QUERY_SESSION_ID)?.trim().orEmpty()
+    if (!OfflineSecurityPolicy.sessionIdRegex.matches(sessionId)) throw IllegalArgumentException("Invalid sessionId")
+    val clientId = uri.getQueryParameter(OfflineSignalingContract.QUERY_CLIENT_ID)?.trim()?.takeIf { it.isNotEmpty() }
+    if (clientId != null && !OfflineSecurityPolicy.clientIdRegex.matches(clientId)) throw IllegalArgumentException("Invalid clientId")
+    if (!roomSecret.isNullOrBlank()) {
+      val providedSecret = uri.getQueryParameter(OfflineSignalingContract.QUERY_ACCESS_TOKEN)?.trim()
+        ?: uri.getQueryParameter(OfflineSignalingContract.QUERY_ROOM_SECRET)?.trim()
+      if (providedSecret != roomSecret) throw IllegalArgumentException("Invalid room secret")
+    }
+    return WebSocketHandshakeRequest(sessionId, clientId)
+  }
+}
+
+object WebSocketFrameCodec {
+  fun readText(input: InputStream): String? {
+    val first = input.read()
+    if (first == -1) throw EOFException("Socket closed")
+    val opcode = first and 0x0F
+    val second = readByte(input)
+    val masked = (second and 0x80) != 0
+    var length = (second and 0x7F).toLong()
+    if (length == 126L) length = ((readByte(input) shl 8) or readByte(input)).toLong()
+    if (length == 127L) {
+      length = 0
+      repeat(8) { length = (length shl 8) or readByte(input).toLong() }
+    }
+    if (length > OfflineSecurityPolicy.MAX_TEXT_FRAME_BYTES) throw IllegalArgumentException("WebSocket frame is too large")
+    val mask = if (masked) ByteArray(4).also { readFully(input, it) } else null
+    val payload = ByteArray(length.toInt())
+    readFully(input, payload)
+    if (mask != null) {
+      payload.indices.forEach { payload[it] = (payload[it].toInt() xor mask[it % 4].toInt()).toByte() }
+    }
+    if (opcode == 0x8) return null
+    if (opcode != 0x1) return ""
+    return String(payload, StandardCharsets.UTF_8)
+  }
+
+  @Synchronized
+  fun writeText(output: OutputStream, message: String) {
+    val payload = message.toByteArray(StandardCharsets.UTF_8)
+    output.write(0x81)
+    when {
+      payload.size < 126 -> output.write(payload.size)
+      payload.size <= 65535 -> {
+        output.write(126)
+        output.write((payload.size ushr 8) and 0xFF)
+        output.write(payload.size and 0xFF)
+      }
+      else -> {
+        output.write(127)
+        for (shift in 56 downTo 0 step 8) output.write(((payload.size.toLong() ushr shift) and 0xFF).toInt())
+      }
+    }
+    output.write(payload)
+    output.flush()
+  }
+
+  private fun readByte(input: InputStream): Int {
+    val value = input.read()
+    if (value == -1) throw EOFException("Socket closed")
+    return value
+  }
+
+  private fun readFully(input: InputStream, buffer: ByteArray) {
+    var offset = 0
+    while (offset < buffer.size) {
+      val read = input.read(buffer, offset, buffer.size - offset)
+      if (read == -1) throw EOFException("Socket closed")
+      offset += read
+    }
+  }
+}
+
+@Suppress("DEPRECATION")
+class LanServiceDiscovery(context: Context) {
+  private val nsdManager = context.getSystemService(Context.NSD_SERVICE) as NsdManager
+  private var registrationListener: NsdManager.RegistrationListener? = null
+
+  @Synchronized
+  fun register(serviceName: String, port: Int, roomId: String?, displayName: String?) {
+    unregister()
+    val serviceInfo = NsdServiceInfo().apply {
+      this.serviceName = serviceName
+      this.serviceType = OfflineSignalingContract.ANDROID_SERVICE_TYPE
+      this.port = port
+      roomId?.takeIf { it.isNotBlank() }?.let { setAttribute(OfflineSignalingContract.TXT_ROOM_ID, it) }
+      displayName?.takeIf { it.isNotBlank() }?.let { setAttribute(OfflineSignalingContract.TXT_DISPLAY_NAME, it) }
+    }
+
+    val listener = object : NsdManager.RegistrationListener {
+      override fun onServiceRegistered(info: NsdServiceInfo) {}
+      override fun onRegistrationFailed(info: NsdServiceInfo, errorCode: Int) {}
+      override fun onServiceUnregistered(info: NsdServiceInfo) {}
+      override fun onUnregistrationFailed(info: NsdServiceInfo, errorCode: Int) {}
+    }
+
+    registrationListener = listener
+    try {
+      nsdManager.registerService(serviceInfo, NsdManager.PROTOCOL_DNS_SD, listener)
+    } catch (_: Exception) {
+      registrationListener = null
+    }
+  }
+
+  @Synchronized
+  fun unregister() {
+    val listener = registrationListener ?: return
+    try { nsdManager.unregisterService(listener) } catch (_: Exception) {}
+    registrationListener = null
+  }
+
+  fun discover(timeoutMs: Int): List<OfflineDiscoveredHost> {
+    val results = Collections.synchronizedList(mutableListOf<OfflineDiscoveredHost>())
+    val listener = object : NsdManager.DiscoveryListener {
+      override fun onDiscoveryStarted(serviceType: String) {}
+      override fun onDiscoveryStopped(serviceType: String) {}
+      override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
+        try { nsdManager.stopServiceDiscovery(this) } catch (_: Exception) {}
+      }
+      override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {}
+      override fun onServiceLost(serviceInfo: NsdServiceInfo) {}
+      override fun onServiceFound(serviceInfo: NsdServiceInfo) {
+        if (!serviceInfo.serviceType.equals(OfflineSignalingContract.ANDROID_SERVICE_TYPE, ignoreCase = true)) return
+        try {
+          nsdManager.resolveService(serviceInfo, object : NsdManager.ResolveListener {
+            override fun onResolveFailed(info: NsdServiceInfo, errorCode: Int) {}
+            override fun onServiceResolved(info: NsdServiceInfo) {
+              val address = info.host?.hostAddress ?: return
+              val port = info.port.takeIf { it > 0 } ?: return
+              val roomId = info.attributes[OfflineSignalingContract.TXT_ROOM_ID]?.toString(StandardCharsets.UTF_8) ?: parseRoomId(info.serviceName)
+              val displayName = info.attributes[OfflineSignalingContract.TXT_DISPLAY_NAME]?.toString(StandardCharsets.UTF_8)
+              results.add(
+                OfflineDiscoveredHost(
+                  serviceName = info.serviceName,
+                  serviceType = info.serviceType,
+                  hostAddress = address,
+                  port = port,
+                  url = "ws://$address:$port",
+                  roomId = roomId,
+                  displayName = displayName,
+                )
+              )
+            }
+          })
+        } catch (_: Exception) {
+        }
+      }
+    }
+
+    try {
+      nsdManager.discoverServices(OfflineSignalingContract.ANDROID_SERVICE_TYPE, NsdManager.PROTOCOL_DNS_SD, listener)
+      Thread.sleep(timeoutMs.coerceIn(OfflineSignalingContract.DISCOVERY_MIN_TIMEOUT_MS, OfflineSignalingContract.DISCOVERY_MAX_TIMEOUT_MS).toLong())
+    } finally {
+      try { nsdManager.stopServiceDiscovery(listener) } catch (_: Exception) {}
+    }
+
+    return results.distinctBy { it.url + ":" + it.roomId.orEmpty() }
+  }
+
+  private fun parseRoomId(serviceName: String): String? {
+    val match = Regex("(ROOM-[A-Z0-9]+)").find(serviceName)
+    return match?.value
+  }
+}
+
+object LocalNetworkAddressResolver {
+  fun resolveIpv4Address(): String? {
+    val candidates = NetworkInterface.getNetworkInterfaces().toList()
+      .filter { it.isUp && !it.isLoopback && !it.isVirtual }
+      .flatMap { it.inetAddresses.toList() }
+      .filterIsInstance<Inet4Address>()
+      .filter { !it.isLoopbackAddress && !it.isLinkLocalAddress }
+      .mapNotNull { it.hostAddress }
+    return candidates.firstOrNull { it.startsWith("192.168.") || it.startsWith("10.") || it.startsWith("172.") } ?: candidates.firstOrNull()
+  }
+}