react-native-queue-player 1.1.2 → 2.0.0

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlay2MetadataSync.kt

@@ -1,189 +0,0 @@
-package com.margelo.nitro.queueplayer.cast.airplay
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.net.Uri
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
-import androidx.media3.common.MediaItem
-import androidx.media3.common.Player
-import kotlinx.coroutines.*
-import java.io.ByteArrayOutputStream
-import java.net.URL
-
-/**
- * Syncs ExoPlayer track metadata and playback progress to an [AirPlay2Session].
- * Identical logic to [AirPlayMetadataSync] but targets the AP2 session.
- */
-internal class AirPlay2MetadataSync(
-    private val context: Context,
-    private val session: AirPlay2Session,
-    private val player: Player,
-    private val scope: CoroutineScope,
-) {
-    companion object {
-        private const val TAG = "AP2MetadataSync"
-        private const val PROGRESS_INTERVAL_MS = 5000L
-        private const val MAX_ARTWORK_DIM = 600
-        private const val JPEG_QUALITY = 80
-    }
-
-    private var progressJob: Job? = null
-    private var artworkJob: Job? = null
-    private var lastArtworkUri: String? = null
-    private var started = false
-
-    // ExoPlayer rejects add/removeListener + state reads off its application
-    // looper. start()/stop() are driven by session activation/close, and
-    // close() runs on whichever thread disconnected (the JS thread for a
-    // user disconnect, the native drain thread on receiver death) — so the
-    // player touches are marshalled onto the player's looper, run inline when
-    // already on it.
-    private val playerHandler = Handler(player.applicationLooper)
-
-    private fun onPlayerLooper(block: () -> Unit) {
-        if (Looper.myLooper() == player.applicationLooper) block()
-        else playerHandler.post(block)
-    }
-
-    private val listener = object : Player.Listener {
-        override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
-            sendCurrentMetadata()
-        }
-
-        override fun onPositionDiscontinuity(
-            oldPosition: Player.PositionInfo,
-            newPosition: Player.PositionInfo,
-            reason: Int,
-        ) {
-            if (reason == Player.DISCONTINUITY_REASON_SEEK) {
-                sendProgress()
-            }
-        }
-
-        override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
-            if (playWhenReady) {
-                startProgressTimer()
-            } else {
-                progressJob?.cancel()
-                progressJob = null
-            }
-        }
-    }
-
-    fun start() {
-        if (started) return
-        started = true
-        onPlayerLooper {
-            player.addListener(listener)
-            sendCurrentMetadata()
-            if (player.playWhenReady) {
-                startProgressTimer()
-            }
-        }
-        Log.i(TAG, "Started metadata sync")
-    }
-
-    fun stop() {
-        if (!started) return
-        started = false
-        progressJob?.cancel()
-        progressJob = null
-        artworkJob?.cancel()
-        artworkJob = null
-        onPlayerLooper { player.removeListener(listener) }
-        Log.i(TAG, "Stopped metadata sync")
-    }
-
-    private fun sendCurrentMetadata() {
-        val meta = player.currentMediaItem?.mediaMetadata ?: return
-        val title = meta.title?.toString()
-        val artist = meta.artist?.toString()
-        val album = meta.albumTitle?.toString()
-
-        Log.i(TAG, "Sending metadata: title=$title, artist=$artist, album=$album")
-        session.setMetadata(title, artist, album)
-        sendProgress()
-
-        val artUri = meta.artworkUri?.toString()
-        if (artUri != null && artUri != lastArtworkUri) {
-            lastArtworkUri = artUri
-            fetchAndSendArtwork(artUri)
-        }
-    }
-
-    private fun sendProgress() {
-        val position = player.currentPosition.toInt()
-        val duration = player.duration.let { if (it > 0) it.toInt() else 0 }
-        if (duration > 0) {
-            session.setProgress(position, duration)
-        }
-    }
-
-    private fun startProgressTimer() {
-        progressJob?.cancel()
-        progressJob = scope.launch {
-            while (isActive) {
-                delay(PROGRESS_INTERVAL_MS)
-                if (player.isPlaying) {
-                    sendProgress()
-                }
-            }
-        }
-    }
-
-    private fun fetchAndSendArtwork(uriString: String) {
-        artworkJob?.cancel()
-        artworkJob = scope.launch(Dispatchers.IO) {
-            try {
-                val uri = Uri.parse(uriString)
-                val scheme = uri.scheme ?: return@launch
-
-                // Read raw bytes — use ContentResolver for content:// and
-                // android.resource://, URL for http(s), file for file://
-                val rawBytes: ByteArray = when (scheme) {
-                    "content", "android.resource" ->
-                        context.contentResolver.openInputStream(uri)
-                            ?.use { it.readBytes() } ?: return@launch
-                    "file" ->
-                        java.io.File(uri.path ?: return@launch).readBytes()
-                    "http", "https" ->
-                        URL(uriString).openStream().use { it.readBytes() }
-                    else -> {
-                        Log.w(TAG, "Unsupported artwork scheme: $scheme")
-                        return@launch
-                    }
-                }
-
-                val boundsOpts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-                BitmapFactory.decodeByteArray(rawBytes, 0, rawBytes.size, boundsOpts)
-
-                var sampleSize = 1
-                while (boundsOpts.outWidth / sampleSize > MAX_ARTWORK_DIM ||
-                       boundsOpts.outHeight / sampleSize > MAX_ARTWORK_DIM) {
-                    sampleSize *= 2
-                }
-
-                val decodeOpts = BitmapFactory.Options().apply { inSampleSize = sampleSize }
-                val bitmap = BitmapFactory.decodeByteArray(rawBytes, 0, rawBytes.size, decodeOpts)
-                    ?: return@launch
-
-                val baos = ByteArrayOutputStream()
-                bitmap.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, baos)
-                bitmap.recycle()
-
-                val bytes = baos.toByteArray()
-                if (isActive) {
-                    session.setArtwork(bytes, "image/jpeg")
-                    Log.i(TAG, "Sent artwork: ${bytes.size} bytes from $uriString")
-                }
-            } catch (e: Exception) {
-                if (e !is CancellationException) {
-                    Log.w(TAG, "Artwork fetch failed for $uriString", e)
-                }
-            }
-        }
-    }
-}

package/android/src/main/java/com/margelo/nitro/queueplayer/cast/http/LocalMediaServerLifecycle.kt

@@ -1,15 +0,0 @@
-package com.margelo.nitro.queueplayer.cast.http
-
-/**
- * Single-callback contract by which the host service learns whether
- * the local HTTP server has any live sessions. While `active` is true
- * the host must keep itself foregrounded so Android doesn't kill the
- * process out from under the server.
- *
- * Cast-core stays unaware of foreground-service mechanics; the
- * implementer translates this signal into `startForeground` /
- * `stopForeground` etc.
- */
-fun interface LocalMediaServerLifecycle {
-  fun onActiveStateChanged(active: Boolean)
-}

package/android/src/test/java/com/margelo/nitro/queueplayer/PendingIntentBufferTest.kt

@@ -1,192 +0,0 @@
-package com.margelo.nitro.queueplayer
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.Executors
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicLong
-
-/**
- * Coverage for the single-slot pending intent buffer.
- * Drives push / drain / peek / clear / isEmpty directly with a
- * synthetic payload so the generic shape is exercised without
- * dragging Nitrogen-bridged request types into the test target.
- */
-class PendingIntentBufferTest {
-
-  private data class Sample(val payload: String)
-
-  private class FakeClock(start: Long) {
-    private val now = AtomicLong(start)
-    fun nowMillis(): Long = now.get()
-    fun advance(byMillis: Long) {
-      now.addAndGet(byMillis)
-    }
-  }
-
-  private fun makeBuffer(
-    ttlMillis: Long = 20_000L,
-    clock: FakeClock,
-  ): PendingIntentBuffer<Sample> = PendingIntentBuffer(ttlMillis = ttlMillis, clock = clock::nowMillis)
-
-  @Test
-  fun `empty buffer drains null`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    assertNull(buffer.drain())
-    assertNull(buffer.peek())
-    assertTrue(buffer.isEmpty())
-  }
-
-  @Test
-  fun `push then drain returns the request`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    buffer.push(Sample("first"))
-    assertEquals(Sample("first"), buffer.drain())
-  }
-
-  @Test
-  fun `drain empties the buffer`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    buffer.push(Sample("first"))
-    buffer.drain()
-    assertNull(buffer.drain())
-    assertTrue(buffer.isEmpty())
-  }
-
-  @Test
-  fun `second push replaces the first`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    buffer.push(Sample("first"))
-    buffer.push(Sample("second"))
-    assertEquals(Sample("second"), buffer.drain())
-    assertNull(buffer.drain())
-  }
-
-  @Test
-  fun `peek does not empty the buffer`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    buffer.push(Sample("first"))
-    assertEquals(Sample("first"), buffer.peek())
-    assertEquals(Sample("first"), buffer.peek())
-    assertEquals(Sample("first"), buffer.drain())
-  }
-
-  @Test
-  fun `expired entry drains null`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 20_000L, clock = clock)
-    buffer.push(Sample("stale"))
-    clock.advance(byMillis = 21_000L)
-    assertNull(buffer.drain())
-  }
-
-  @Test
-  fun `expired entry peeks null and clears`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 20_000L, clock = clock)
-    buffer.push(Sample("stale"))
-    clock.advance(byMillis = 25_000L)
-    assertNull(buffer.peek())
-    assertTrue(buffer.isEmpty())
-    assertNull(buffer.drain())
-  }
-
-  @Test
-  fun `just before TTL boundary still drains`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 20_000L, clock = clock)
-    buffer.push(Sample("fresh"))
-    clock.advance(byMillis = 19_900L)
-    assertEquals(Sample("fresh"), buffer.drain())
-  }
-
-  @Test
-  fun `zero TTL same instant drains`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 0L, clock = clock)
-    buffer.push(Sample("now"))
-    assertEquals(Sample("now"), buffer.drain())
-  }
-
-  @Test
-  fun `zero TTL after advance drops entry`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 0L, clock = clock)
-    buffer.push(Sample("now"))
-    clock.advance(byMillis = 1L)
-    assertNull(buffer.drain())
-  }
-
-  @Test
-  fun `negative clock skew clamps to zero elapsed`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 20_000L, clock = clock)
-    buffer.push(Sample("fresh"))
-    clock.advance(byMillis = -10_000L)
-    assertEquals(Sample("fresh"), buffer.drain())
-  }
-
-  @Test
-  fun `push after peek cleared expired slot returns fresh entry`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 20_000L, clock = clock)
-    buffer.push(Sample("stale"))
-    clock.advance(byMillis = 25_000L)
-    assertNull(buffer.peek())
-    assertTrue(buffer.isEmpty())
-    buffer.push(Sample("fresh"))
-    assertEquals(Sample("fresh"), buffer.drain())
-  }
-
-  @Test
-  fun `clear empties without return`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    buffer.push(Sample("first"))
-    buffer.clear()
-    assertNull(buffer.drain())
-    assertTrue(buffer.isEmpty())
-  }
-
-  @Test
-  fun `interleaved push and drain serialise safely`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    val executor = Executors.newFixedThreadPool(4)
-    val latch = CountDownLatch(400)
-    try {
-      repeat(200) { i ->
-        executor.submit {
-          buffer.push(Sample("p-$i"))
-          latch.countDown()
-        }
-        executor.submit {
-          buffer.drain()
-          latch.countDown()
-        }
-      }
-      val finished = latch.await(2, TimeUnit.SECONDS)
-      assertTrue("interleaved push/drain did not finish within 2 s", finished)
-    } finally {
-      executor.shutdownNow()
-    }
-  }
-
-  @Test
-  fun `isEmpty reports true after expiry without explicit drain`() {
-    val clock = FakeClock(start = 1_000L)
-    val buffer = makeBuffer(ttlMillis = 20_000L, clock = clock)
-    buffer.push(Sample("stale"))
-    clock.advance(byMillis = 21_000L)
-    assertTrue(buffer.isEmpty())
-  }
-
-  @Test
-  fun `isEmpty reports false when a fresh entry exists`() {
-    val buffer = PendingIntentBuffer<Sample>()
-    buffer.push(Sample("fresh"))
-    assertFalse(buffer.isEmpty())
-  }
-}

package/android/src/test/java/com/margelo/nitro/queueplayer/PlaybackEngineInterfaceTest.kt

@@ -1,135 +0,0 @@
-package com.margelo.nitro.queueplayer
-
-import androidx.media3.common.MediaItem
-import androidx.media3.common.PlaybackException
-import androidx.media3.common.util.UnstableApi
-import androidx.media3.exoplayer.ExoPlayer
-import androidx.media3.exoplayer.audio.TeeAudioProcessor
-import androidx.test.core.app.ApplicationProvider
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Test
-
-/**
- * Type-check coverage for [PlaybackEngine] + [PlaybackEngineDelegate].
- * The interface has no runtime; this suite exercises the type
- * surface so a regression that drops a method or rotates a parameter
- * shape surfaces immediately. Goes away once the real `GaplessEngine`
- * impl pins the type surface from a runtime perspective.
- */
-@RunWith(RobolectricTestRunner::class)
-@Config(sdk = [34])
-@UnstableApi
-class PlaybackEngineInterfaceTest {
-
-  @Test
-  fun `PlaybackEngine surface compiles with all method signatures reachable`() {
-    val stub = NoopPlaybackEngine()
-    assertNotNull(stub)
-    // Empty-queue sentinel: -1 (matches TrackPlayer.currentTrackIndex).
-    assertEquals(-1, stub.currentMediaItemIndex)
-    assertEquals(0L, stub.currentPositionMs)
-    assertEquals(0L, stub.currentDurationMs)
-    assertEquals(0L, stub.bufferedPositionMs)
-    assertEquals(false, stub.isPlaying)
-    assertEquals(null, stub.currentMediaItem)
-    assertEquals(0, stub.allMediaItems.size)
-    assertEquals(0, stub.currentAudioSessionIds().size)
-  }
-
-  @Test
-  fun `audio-session-id listener add returns a disposer`() {
-    val stub = NoopPlaybackEngine()
-    val dispose = stub.addAudioSessionIdListener { /* noop */ }
-    dispose()
-  }
-
-  @Test
-  fun `delegate surface compiles with all callbacks`() {
-    val delegate = NoopPlaybackEngineDelegate()
-    val stub = NoopPlaybackEngine()
-    stub.delegate = delegate
-    assertEquals(delegate, stub.delegate)
-  }
-
-  /**
-   * Minimal compile-only stub. Every method is a no-op; the goal is
-   * to surface a type-system change in [PlaybackEngine] as a Kotlin
-   * compile error here, not as a silent contract drift.
-   *
-   * `mediaSessionPlayer` requires a real ExoPlayer instance for
-   * type compatibility — the stub builds one against the
-   * Robolectric application context but never plays anything.
-   */
-  private class NoopPlaybackEngine : PlaybackEngine {
-    override val mediaSessionPlayer: ExoPlayer = ExoPlayer.Builder(
-      ApplicationProvider.getApplicationContext()
-    ).build()
-
-    override suspend fun prepare(
-      mediaItems: List<MediaItem>,
-      startIndex: Int,
-      startPositionMs: Long,
-    ) = Unit
-
-    override fun release() = Unit
-
-    override fun setMediaItems(
-      items: List<MediaItem>,
-      startIndex: Int,
-      startPositionMs: Long,
-    ) = Unit
-
-    override fun addMediaItems(items: List<MediaItem>, insertBefore: Int) = Unit
-    override fun removeMediaItems(indices: IntArray) = Unit
-    override fun moveMediaItem(fromIndex: Int, toIndex: Int) = Unit
-
-    override fun play() = Unit
-    override fun pause() = Unit
-    override fun stop() = Unit
-    override fun seekTo(index: Int, positionMs: Long) = Unit
-    override fun skipToNext() = Unit
-    override fun skipToPrevious() = Unit
-
-    override fun setVolume(volume: Float) = Unit
-    override fun setPlaybackSpeed(speed: Float) = Unit
-    override fun setRepeatMode(mode: RepeatMode) = Unit
-    override fun setPitchCorrectionMode(mode: PitchCorrectionMode) = Unit
-    override fun setWakeMode(mode: Int) = Unit
-
-    override val currentMediaItemIndex: Int = -1
-    override val currentPositionMs: Long = 0
-    override val currentDurationMs: Long = 0
-    override val bufferedPositionMs: Long = 0
-    override val isPlaying: Boolean = false
-    override val currentMediaItem: MediaItem? = null
-    override val isCrossfadeActive: Boolean = false
-    override val allMediaItems: List<MediaItem> = emptyList()
-
-    override fun currentAudioSessionIds(): IntArray = IntArray(0)
-
-    override fun addAudioSessionIdListener(listener: (IntArray) -> Unit): () -> Unit = { /* noop */ }
-
-    override fun attachAudioBufferSink(sink: TeeAudioProcessor.AudioBufferSink) = Unit
-    override fun detachAudioBufferSink(sink: TeeAudioProcessor.AudioBufferSink) = Unit
-
-    override suspend fun handoff(to: PlaybackEngine, atTrackBoundary: Boolean) = Unit
-
-    override var delegate: PlaybackEngineDelegate? = null
-  }
-
-  private class NoopPlaybackEngineDelegate : PlaybackEngineDelegate {
-    override fun onStateMaybeChanged(engine: PlaybackEngine, playWhenReadyReason: Int?) = Unit
-    override fun onIsPlayingChanged(engine: PlaybackEngine, isPlaying: Boolean) = Unit
-    override fun onTrackTransition(engine: PlaybackEngine, platformReason: Int) = Unit
-    override fun onActiveItemFormatChanged(engine: PlaybackEngine) = Unit
-    override fun onError(engine: PlaybackEngine, exception: PlaybackException) = Unit
-    override fun onPlaybackEnded(engine: PlaybackEngine) = Unit
-    override fun onAutoTransitionDiscontinuity(engine: PlaybackEngine) = Unit
-    override fun onCrossfadeBegin(engine: PlaybackEngine, incomingIndex: Int) = Unit
-    override fun onCrossfadeCancel(engine: PlaybackEngine, revertedIndex: Int) = Unit
-  }
-}

package/android/src/test/java/com/margelo/nitro/queueplayer/SmokeTest.kt

@@ -1,27 +0,0 @@
-package com.margelo.nitro.queueplayer
-
-import org.junit.Assert.assertTrue
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.annotation.Config
-
-/**
- * Proves the JUnit + Robolectric test target is
- * wired + `./gradlew :react-native-queue-player:testDebugUnitTest`
- * executes. Real test suites for the Kotlin audio wrappers
- * (MediaItemBuilder, AudioFocus, PlaybackService, LookaheadCache,
- * etc.) live alongside their wrapper sources.
- *
- * @Config sdk=34 because Robolectric 4.11.1 supports up to API 34,
- * while our library's compileSdkVersion is 36. When Robolectric bumps
- * its max-supported SDK to 36 we drop the annotation.
- */
-@RunWith(RobolectricTestRunner::class)
-@Config(sdk = [34])
-class SmokeTest {
-  @Test
-  fun smoke_sanity() {
-    assertTrue("smoke", true)
-  }
-}

package/ios/Cast/Core/LocalAddressMonitor.swift

@@ -1,110 +0,0 @@
-import Foundation
-import Network
-
-/// Wraps `NWPathMonitor` to publish the local IPv4 address over the
-/// `.wifi` interface. Cellular addresses can't reach a LAN receiver,
-/// so they are intentionally ignored — Chromecast / DLNA / AirPlay
-/// targets are all wifi-local by design.
-final class LocalAddressMonitor {
-
-  typealias Listener = (String?) -> Void
-
-  final class Subscription {
-    fileprivate let id: UUID
-    fileprivate weak var owner: LocalAddressMonitor?
-    fileprivate init(id: UUID, owner: LocalAddressMonitor) {
-      self.id = id
-      self.owner = owner
-    }
-    func remove() { owner?.removeListener(id: id) }
-  }
-
-  private let monitor = NWPathMonitor(requiredInterfaceType: .wifi)
-  private let queue = DispatchQueue(label: "LocalAddressMonitor")
-  private let lock = NSLock()
-  private var listeners: [UUID: Listener] = [:]
-  private var running = false
-
-  private let addressLock = NSLock()
-  private var _currentAddress: String?
-  var currentAddress: String? {
-    addressLock.lock(); defer { addressLock.unlock() }
-    return _currentAddress
-  }
-
-  func start() {
-    lock.lock()
-    if running { lock.unlock(); return }
-    running = true
-    lock.unlock()
-    monitor.pathUpdateHandler = { [weak self] path in
-      guard let self = self else { return }
-      let addr: String? = (path.status == .satisfied) ? Self.firstWifiIPv4() : nil
-      self.addressLock.lock()
-      let changed: Bool = (addr != self._currentAddress)
-      self._currentAddress = addr
-      self.addressLock.unlock()
-      if changed {
-        self.dispatch(addr)
-      }
-    }
-    monitor.start(queue: queue)
-  }
-
-  func stop() {
-    lock.lock()
-    if !running { lock.unlock(); return }
-    running = false
-    lock.unlock()
-    monitor.cancel()
-  }
-
-  func addListener(_ listener: @escaping Listener) -> Subscription {
-    let id = UUID()
-    lock.lock()
-    listeners[id] = listener
-    lock.unlock()
-    return Subscription(id: id, owner: self)
-  }
-
-  fileprivate func removeListener(id: UUID) {
-    lock.lock()
-    listeners.removeValue(forKey: id)
-    lock.unlock()
-  }
-
-  private func dispatch(_ addr: String?) {
-    lock.lock()
-    let snapshot = Array(listeners.values)
-    lock.unlock()
-    for l in snapshot { l(addr) }
-  }
-
-  /// Enumerate BSD interfaces and return the first IPv4 address on an
-  /// `en*` interface (Wi-Fi). Synchronous so callers can probe without
-  /// waiting for the `NWPathMonitor` first-update callback.
-  static func firstWifiIPv4() -> String? {
-    var ifaddrPtr: UnsafeMutablePointer<ifaddrs>?
-    guard getifaddrs(&ifaddrPtr) == 0, let first = ifaddrPtr else { return nil }
-    defer { freeifaddrs(ifaddrPtr) }
-    var ptr: UnsafeMutablePointer<ifaddrs>? = first
-    while let current = ptr {
-      defer { ptr = current.pointee.ifa_next }
-      let name = String(cString: current.pointee.ifa_name)
-      guard name.hasPrefix("en") else { continue }
-      guard let sa = current.pointee.ifa_addr else { continue }
-      guard sa.pointee.sa_family == UInt8(AF_INET) else { continue }
-      var hostBuf = [CChar](repeating: 0, count: Int(NI_MAXHOST))
-      let result = getnameinfo(
-        sa, socklen_t(sa.pointee.sa_len),
-        &hostBuf, socklen_t(hostBuf.count),
-        nil, 0, NI_NUMERICHOST
-      )
-      if result == 0 {
-        let host = String(cString: hostBuf)
-        if !host.isEmpty && host != "0.0.0.0" { return host }
-      }
-    }
-    return nil
-  }
-}