react-native-queue-player 1.0.0

package/android/src/test/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlayDiscoveryFilterTest.kt

@@ -0,0 +1,86 @@
+package com.margelo.nitro.queueplayer.cast.airplay
+
+import com.margelo.nitro.queueplayer.cast.Receiver
+import com.margelo.nitro.queueplayer.cast.ReceiverCapabilities
+import com.margelo.nitro.queueplayer.cast.StreamingModel
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * [visibleReceivers] drops Mac-computer AirPlay receivers (classified
+ * `deviceClass == "computer"`) when hiding is on, and passes every other
+ * device class through untouched.
+ */
+class AirPlayDiscoveryFilterTest {
+
+  private fun receiver(id: String, deviceClass: String): Receiver =
+    Receiver(
+      id = id,
+      protocol = "airplay",
+      name = id,
+      iconHint = deviceClass,
+      capabilities = ReceiverCapabilities(
+        supportsRemoteVolume = true,
+        streamingModel = StreamingModel.PUSH_PCM,
+        requiresPairing = false,
+      ),
+      extras = mapOf("deviceClass" to deviceClass, "model" to id),
+    )
+
+  @Test
+  fun `hiding drops computer-class receivers and keeps everything else`() {
+    val all = listOf(
+      receiver("Mac17,4", "computer"),
+      receiver("AppleTV11,1", "tv"),
+      receiver("AudioAccessory5,1", "speaker"),
+      receiver("Shairport", "speaker"),
+    )
+
+    val visible = visibleReceivers(all, hideComputers = true)
+
+    assertEquals(listOf("AppleTV11,1", "AudioAccessory5,1", "Shairport"), visible.map { it.id })
+    assertTrue("no computer-class receiver survives", visible.none { it.extras["deviceClass"] == "computer" })
+  }
+
+  @Test
+  fun `not hiding passes computer-class receivers through`() {
+    val all = listOf(
+      receiver("Mac17,4", "computer"),
+      receiver("AppleTV11,1", "tv"),
+    )
+
+    val visible = visibleReceivers(all, hideComputers = false)
+
+    assertEquals(all.map { it.id }, visible.map { it.id })
+  }
+
+  @Test
+  fun `an all-computer list becomes empty when hiding`() {
+    val all = listOf(
+      receiver("Mac17,4", "computer"),
+      receiver("MacBookPro18,3", "computer"),
+      receiver("iMac21,1", "computer"),
+    )
+
+    assertTrue(visibleReceivers(all, hideComputers = true).isEmpty())
+  }
+
+  @Test
+  fun `a receiver missing deviceClass extras is never treated as a computer`() {
+    val noClass = Receiver(
+      id = "unknown-receiver",
+      protocol = "airplay",
+      name = "unknown-receiver",
+      iconHint = "unknown",
+      capabilities = ReceiverCapabilities(
+        supportsRemoteVolume = true,
+        streamingModel = StreamingModel.PUSH_PCM,
+        requiresPairing = false,
+      ),
+      extras = emptyMap(),
+    )
+
+    assertEquals(listOf("unknown-receiver"), visibleReceivers(listOf(noClass), hideComputers = true).map { it.id })
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/cast/airplay/AirPlayTxtParserClassificationTest.kt

@@ -0,0 +1,34 @@
+package com.margelo.nitro.queueplayer.cast.airplay
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * [AirPlayTxtParser] classifies AirPlay `am=`/`model=` identifiers into the
+ * `deviceClass` the discovery filter keys on. Mac models must land in
+ * `"computer"` (so `hideAirPlayComputers` can drop them) while Apple TV and
+ * HomePod must not.
+ */
+class AirPlayTxtParserClassificationTest {
+
+  private fun classOf(model: String): String =
+    AirPlayTxtParser.parse(mapOf("am" to model)).deviceClass
+
+  @Test
+  fun `Mac models classify as computer`() {
+    for (model in listOf("Mac17,4", "MacBookPro18,3", "MacBookAir10,1", "Macmini9,1", "MacPro7,1", "iMac21,1")) {
+      assertEquals("$model should be a computer", "computer", classOf(model))
+    }
+  }
+
+  @Test
+  fun `Apple TV and HomePod do not classify as computer`() {
+    assertEquals("tv", classOf("AppleTV11,1"))
+    assertEquals("speaker", classOf("AudioAccessory5,1"))
+  }
+
+  @Test
+  fun `the model key is a fallback when am is absent`() {
+    assertEquals("computer", AirPlayTxtParser.parse(mapOf("model" to "Mac17,4")).deviceClass)
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/cast/chromecast/CastMediaItemConverterTest.kt

@@ -0,0 +1,78 @@
+package com.margelo.nitro.queueplayer.cast.chromecast
+
+import android.net.Uri
+import androidx.media3.common.util.UnstableApi
+import com.google.android.gms.cast.MediaInfo
+import com.google.android.gms.cast.MediaMetadata
+import com.google.android.gms.cast.MediaQueueItem
+import com.google.android.gms.common.images.WebImage
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * [CastMediaItemConverter.toMediaItem] is the sole source of each cast
+ * queue item's metadata for the MediaSession notification (the queue is
+ * loaded via RemoteMediaClient.queueLoad, so CastPlayer's content-id map
+ * is empty). It must read back the Cast MediaMetadata keys MediaInfoBuilder
+ * writes.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class CastMediaItemConverterTest {
+
+  private val converter = CastMediaItemConverter()
+
+  private fun queueItem(
+    url: String,
+    title: String?,
+    artist: String?,
+    album: String?,
+    artworkUrl: String?,
+  ): MediaQueueItem {
+    val meta = MediaMetadata(MediaMetadata.MEDIA_TYPE_MUSIC_TRACK).apply {
+      title?.let { putString(MediaMetadata.KEY_TITLE, it) }
+      artist?.let { putString(MediaMetadata.KEY_ARTIST, it) }
+      album?.let { putString(MediaMetadata.KEY_ALBUM_TITLE, it) }
+      artworkUrl?.let { addImage(WebImage(Uri.parse(it))) }
+    }
+    val info = MediaInfo.Builder(url)
+      .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
+      .setContentType("audio/mpeg")
+      .setMetadata(meta)
+      .build()
+    return MediaQueueItem.Builder(info).build()
+  }
+
+  @Test
+  fun `toMediaItem maps title artist album artwork and contentId`() {
+    val mediaItem = converter.toMediaItem(
+      queueItem(
+        url = "http://h/a.mp3", title = "Song", artist = "Artist",
+        album = "Album", artworkUrl = "http://h/art.jpg",
+      )
+    )
+    assertEquals("Song", mediaItem.mediaMetadata.title?.toString())
+    assertEquals("Artist", mediaItem.mediaMetadata.artist?.toString())
+    assertEquals("Album", mediaItem.mediaMetadata.albumTitle?.toString())
+    assertEquals(Uri.parse("http://h/art.jpg"), mediaItem.mediaMetadata.artworkUri)
+    assertEquals("http://h/a.mp3", mediaItem.mediaId)
+  }
+
+  @Test
+  fun `toMediaItem tolerates missing metadata fields`() {
+    val mediaItem = converter.toMediaItem(
+      queueItem(
+        url = "http://h/b.mp3", title = null, artist = null,
+        album = null, artworkUrl = null,
+      )
+    )
+    assertEquals("http://h/b.mp3", mediaItem.mediaId)
+    assertNull(mediaItem.mediaMetadata.title)
+    assertNull(mediaItem.mediaMetadata.artworkUri)
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/cast/chromecast/CastVolumeForwardingPlayerTest.kt

@@ -0,0 +1,176 @@
+package com.margelo.nitro.queueplayer.cast.chromecast
+
+import android.os.Looper
+import androidx.media3.common.DeviceInfo
+import androidx.media3.common.Player
+import androidx.media3.common.SimpleBasePlayer
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.shadows.ShadowSystemClock
+import java.time.Duration
+
+/**
+ * [CastVolumeForwardingPlayer] maps the hardware volume rocker to the
+ * receiver's device volume through a finer step count and a compressive
+ * taper, so equal presses produce roughly even loudness changes and the
+ * quiet end of the scale gets the resolution the receiver's own curve needs.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class CastVolumeForwardingPlayerTest {
+
+  private class StubPlayer : SimpleBasePlayer(Looper.getMainLooper()) {
+    override fun getState(): State =
+      State.Builder().setAvailableCommands(Player.Commands.EMPTY).build()
+  }
+
+  private var sentVolume: Float = Float.NaN
+  private var receiver: Float = Float.NaN
+
+  private fun player() = CastVolumeForwardingPlayer(
+    player = StubPlayer(),
+    routingControllerId = "device-id",
+    setReceiverVolume = { sentVolume = it; receiver = it },
+    receiverVolume = { receiver },
+  )
+
+  // -- Curve math (the core logic) --
+
+  @Test
+  fun stepEndpointsMapToFullRange() {
+    assertEquals(0f, CastVolumeForwardingPlayer.stepToVolume(0), 1e-6f)
+    assertEquals(
+      1f,
+      CastVolumeForwardingPlayer.stepToVolume(CastVolumeForwardingPlayer.STEP_COUNT),
+      1e-6f,
+    )
+  }
+
+  @Test
+  fun stepToVolumeIsMonotonicIncreasing() {
+    var prev = -1f
+    for (s in 0..CastVolumeForwardingPlayer.STEP_COUNT) {
+      val v = CastVolumeForwardingPlayer.stepToVolume(s)
+      assertTrue("step $s should exceed previous", v > prev)
+      prev = v
+    }
+  }
+
+  @Test
+  fun stepRoundTripsThroughVolume() {
+    for (s in 0..CastVolumeForwardingPlayer.STEP_COUNT) {
+      val v = CastVolumeForwardingPlayer.stepToVolume(s)
+      assertEquals(s, CastVolumeForwardingPlayer.volumeToStep(v))
+    }
+  }
+
+  @Test
+  fun taperConcentratesResolutionAtQuietEnd() {
+    // The audible range on a curved receiver collapses into the bottom of the
+    // 0.0..1.0 device scale; the taper must spend most steps there. A linear
+    // 30-step control would give ~5 steps below 0.15.
+    val lowSteps = (0..CastVolumeForwardingPlayer.STEP_COUNT)
+      .count { CastVolumeForwardingPlayer.stepToVolume(it) <= 0.15f }
+    assertTrue("expected many fine steps below 0.15, got $lowSteps", lowSteps >= 12)
+  }
+
+  @Test
+  fun volumeToStepClampsAndHandlesNaN() {
+    assertEquals(0, CastVolumeForwardingPlayer.volumeToStep(Float.NaN))
+    assertEquals(0, CastVolumeForwardingPlayer.volumeToStep(-0.5f))
+    assertEquals(
+      CastVolumeForwardingPlayer.STEP_COUNT,
+      CastVolumeForwardingPlayer.volumeToStep(2f),
+    )
+  }
+
+  // -- Device-volume routing (the override surface) --
+
+  @Test
+  fun reportsRemoteDeviceInfoWithStepRange() {
+    val info = player().deviceInfo
+    assertEquals(DeviceInfo.PLAYBACK_TYPE_REMOTE, info.playbackType)
+    assertEquals(0, info.minVolume)
+    assertEquals(CastVolumeForwardingPlayer.STEP_COUNT, info.maxVolume)
+  }
+
+  @Test
+  fun advertisesDeviceVolumeCommands() {
+    val p = player()
+    assertTrue(p.isCommandAvailable(Player.COMMAND_GET_DEVICE_VOLUME))
+    assertTrue(p.isCommandAvailable(Player.COMMAND_SET_DEVICE_VOLUME_WITH_FLAGS))
+    assertTrue(p.isCommandAvailable(Player.COMMAND_ADJUST_DEVICE_VOLUME_WITH_FLAGS))
+    assertTrue(p.availableCommands.contains(Player.COMMAND_ADJUST_DEVICE_VOLUME_WITH_FLAGS))
+  }
+
+  @Test
+  fun setDeviceVolumeSendsCurvedReceiverVolume() {
+    val p = player()
+    p.setDeviceVolume(15, 0)
+    assertEquals(15, p.deviceVolume)
+    assertEquals(CastVolumeForwardingPlayer.stepToVolume(15), sentVolume, 1e-6f)
+  }
+
+  @Test
+  fun increaseAndDecreaseStepCleanlyRegardlessOfEcho() {
+    val p = player()
+    receiver = 0f
+    p.setDeviceVolume(10, 0)
+    p.increaseDeviceVolume(0)
+    p.increaseDeviceVolume(0)
+    // Tracked locally, so two presses advance two steps even before the
+    // receiver echo updates receiverVolume().
+    assertEquals(12, p.deviceVolume)
+    p.decreaseDeviceVolume(0)
+    assertEquals(11, p.deviceVolume)
+  }
+
+  @Test
+  fun stepClampsAtBounds() {
+    val p = player()
+    p.setDeviceVolume(CastVolumeForwardingPlayer.STEP_COUNT, 0)
+    p.increaseDeviceVolume(0)
+    assertEquals(CastVolumeForwardingPlayer.STEP_COUNT, p.deviceVolume)
+    p.setDeviceVolume(0, 0)
+    p.decreaseDeviceVolume(0)
+    assertEquals(0, p.deviceVolume)
+  }
+
+  @Test
+  fun initialDeviceVolumeDerivesFromReceiver() {
+    receiver = CastVolumeForwardingPlayer.stepToVolume(8)
+    assertEquals(8, player().deviceVolume)
+  }
+
+  @Test
+  fun deviceVolumeIsZeroWhenReceiverVolumeUnknown() {
+    receiver = Float.NaN
+    assertEquals(0, player().deviceVolume)
+  }
+
+  @Test
+  fun adoptsExternalReceiverChangeOnceRockerIsIdle() {
+    val p = player()
+    receiver = 0f
+    p.setDeviceVolume(20, 0)
+    // A change made on the receiver itself (its remote / Home app).
+    receiver = CastVolumeForwardingPlayer.stepToVolume(5)
+    // Within the active-use window the locally-tracked step still wins, so a
+    // rapid press doesn't snap backwards on the lagging echo.
+    assertEquals(20, p.deviceVolume)
+    ShadowSystemClock.advanceBy(Duration.ofMillis(2_000))
+    assertEquals(5, p.deviceVolume)
+  }
+
+  @Test
+  fun mutedReadsFalseByDefaultFromStub() {
+    assertFalse(player().isDeviceMuted)
+  }
+}