react-native-queue-player 1.2.0 → 2.0.1

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
-  }
-}