react-native-audio-browser 0.1.1 → 0.2.0-next.2

package/src/web/player/RemoteCommandController.ts

@@ -0,0 +1,166 @@
+import type { NowPlayingMetadata } from '../../features'
+import type { AudioBrowser as AudioBrowserSpec } from '../../specs/audio-browser.nitro'
+import { MediaSessionManager } from './MediaSessionManager'
+
+/**
+ * The slice of the player the remote-command bridge drives. Picked straight from
+ * the spec so the contract can never drift from the real surface.
+ */
+export type RemoteCommandHost = Pick<
+  AudioBrowserSpec,
+  // Default transport actions (run when the consumer provides no handler).
+  | 'play'
+  | 'pause'
+  | 'stop'
+  | 'skipToNext'
+  | 'skipToPrevious'
+  | 'seekTo'
+  | 'seekBy'
+  // Consumer-provided command overrides.
+  | 'handleRemotePlay'
+  | 'handleRemotePause'
+  | 'handleRemoteStop'
+  | 'handleRemoteNext'
+  | 'handleRemotePrevious'
+  | 'handleRemoteSeek'
+  | 'handleRemoteJumpForward'
+  | 'handleRemoteJumpBackward'
+  // Observation events (always emitted after a command).
+  | 'onRemotePlay'
+  | 'onRemotePause'
+  | 'onRemoteStop'
+  | 'onRemoteNext'
+  | 'onRemotePrevious'
+  | 'onRemoteSeek'
+  | 'onRemoteJumpForward'
+  | 'onRemoteJumpBackward'
+  // State mirrored out to the OS controls.
+  | 'getPlayback'
+  | 'getPlayingState'
+  | 'getProgress'
+>
+
+/**
+ * Bridges the OS media controls (lockscreen / notification / hardware media
+ * keys, via the browser Media Session API) to the player:
+ *
+ *  - mirrors now-playing metadata, playback state and scrubber position *out*, and
+ *  - routes incoming commands *in* — preferring a consumer-provided handler,
+ *    otherwise running the default transport action, then always emitting the
+ *    observation event. This matches the native HybridAudioBrowser/AudioBrowser
+ *    contract exactly.
+ *
+ * A no-op when the Media Session API is unavailable (handled by the underlying
+ * {@link MediaSessionManager}).
+ */
+export class RemoteCommandController {
+  private readonly mediaSession: MediaSessionManager
+
+  constructor(private readonly host: RemoteCommandHost) {
+    // Handlers are read live (inside each arrow) so consumers can assign them
+    // after construction and still be honoured.
+    this.mediaSession = new MediaSessionManager({
+      play: () =>
+        this.run(
+          host.handleRemotePlay,
+          undefined,
+          () => host.play(),
+          () => host.onRemotePlay()
+        ),
+      pause: () =>
+        this.run(
+          host.handleRemotePause,
+          undefined,
+          () => host.pause(),
+          () => host.onRemotePause()
+        ),
+      stop: () =>
+        this.run(
+          host.handleRemoteStop,
+          undefined,
+          () => host.stop(),
+          () => host.onRemoteStop()
+        ),
+      next: () =>
+        this.run(
+          host.handleRemoteNext,
+          undefined,
+          () => host.skipToNext(),
+          () => host.onRemoteNext()
+        ),
+      previous: () =>
+        this.run(
+          host.handleRemotePrevious,
+          undefined,
+          () => host.skipToPrevious(),
+          () => host.onRemotePrevious()
+        ),
+      seek: (position) =>
+        this.run(
+          host.handleRemoteSeek,
+          { position },
+          () => host.seekTo(position),
+          (event) => host.onRemoteSeek(event)
+        ),
+      jumpForward: (interval) =>
+        this.run(
+          host.handleRemoteJumpForward,
+          { interval },
+          () => host.seekBy(interval),
+          (event) => host.onRemoteJumpForward(event)
+        ),
+      jumpBackward: (interval) =>
+        this.run(
+          host.handleRemoteJumpBackward,
+          { interval },
+          () => host.seekBy(-interval),
+          (event) => host.onRemoteJumpBackward(event)
+        )
+    })
+  }
+
+  /** Publishes now-playing metadata to the OS media controls. */
+  setMetadata(metadata: NowPlayingMetadata): void {
+    this.mediaSession.setMetadata(metadata)
+  }
+
+  /** Reflects the current playing/paused/stopped state in the OS controls. */
+  syncPlaybackState(): void {
+    const playback = this.host.getPlayback()
+    if (playback.state === 'none') {
+      this.mediaSession.setPlaybackState('none')
+    } else if (this.host.getPlayingState().playing) {
+      this.mediaSession.setPlaybackState('playing')
+    } else {
+      this.mediaSession.setPlaybackState('paused')
+    }
+  }
+
+  /** Pushes the latest scrubber position to the OS controls. */
+  updateProgress(): void {
+    const { duration, position } = this.host.getProgress()
+    // The web player has no variable-rate playback, so the rate is always 1.
+    // (Live radio has no seekable timeline anyway — the position is cleared.)
+    this.mediaSession.setPositionState({ duration, position, playbackRate: 1 })
+  }
+
+  /** Removes handlers and clears metadata/state. Call on teardown. */
+  dispose(): void {
+    this.mediaSession.dispose()
+  }
+
+  /**
+   * The remote-command contract: run the consumer handler if present, otherwise
+   * the default transport action, then always emit the observation event.
+   */
+  private run<E = void>(
+    handler: ((event: E) => void) | undefined,
+    event: E,
+    fallback: () => void,
+    emit: (event: E) => void
+  ): void {
+    if (handler) handler(event)
+    else fallback()
+    emit(event)
+  }
+}

package/android/src/main/java/com/audiobrowser/player/PlaybackProgressUpdateManager.kt

@@ -1,59 +0,0 @@
-package com.audiobrowser.player
-
-import com.margelo.nitro.audiobrowser.PlaybackState
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.MainScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-
-class PlaybackProgressUpdateManager(private val onProgressUpdate: () -> Unit) {
-  private val scope = MainScope()
-  private var job: Job? = null
-  private var updateInterval: Double? = null
-
-  fun setUpdateInterval(interval: Double?) {
-    if (interval == updateInterval) return
-    val wasRunning = job != null
-    updateInterval = if (interval != null && interval > 0) interval else null
-    stop()
-    if (updateInterval != null && wasRunning) {
-      start()
-    }
-  }
-
-  fun start() {
-    if (job != null) return
-    updateInterval?.let { interval ->
-      job =
-        scope.launch {
-          while (true) {
-            onProgressUpdate()
-            delay((interval * 1000).toLong())
-          }
-        }
-    }
-  }
-
-  fun stop() {
-    job?.cancel()
-    job = null
-  }
-
-  fun onPlaybackStateChanged(state: PlaybackState) {
-    when (state) {
-      // Start when playback is set to resume (loading, buffering) or playing
-      PlaybackState.LOADING,
-      PlaybackState.BUFFERING,
-      PlaybackState.PLAYING -> start()
-
-      // Stop when playback pauses, stops, or errors
-      PlaybackState.PAUSED,
-      PlaybackState.STOPPED,
-      PlaybackState.ENDED,
-      PlaybackState.ERROR -> stop()
-
-      // No action for READY, IDLE, NONE
-      else -> {}
-    }
-  }
-}

package/android/src/main/java/com/audiobrowser/util/RatingFactory.kt

@@ -1,72 +0,0 @@
-package com.audiobrowser.util
-
-import androidx.media3.common.HeartRating as Media3HeartRating
-import androidx.media3.common.PercentageRating as Media3PercentRating
-import androidx.media3.common.Rating
-import androidx.media3.common.StarRating as Media3StarRating
-import androidx.media3.common.ThumbRating as Media3ThumbRating
-import com.margelo.nitro.audiobrowser.HeartRating
-import com.margelo.nitro.audiobrowser.PercentageRating
-import com.margelo.nitro.audiobrowser.StarRating
-import com.margelo.nitro.audiobrowser.ThumbsRating
-import com.margelo.nitro.audiobrowser.Variant_HeartRating_ThumbsRating_StarRating_PercentageRating
-
-object RatingFactory {
-  fun media3ToBridge(
-    rating: Rating
-  ): Variant_HeartRating_ThumbsRating_StarRating_PercentageRating? {
-    return when (rating) {
-      is Media3HeartRating -> {
-        if (rating.isRated) {
-          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
-            HeartRating(rating.isHeart)
-          )
-        } else null
-      }
-
-      is Media3ThumbRating -> {
-        if (rating.isRated) {
-          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
-            ThumbsRating(rating.isThumbsUp)
-          )
-        } else null
-      }
-
-      is Media3StarRating -> {
-        if (rating.isRated) {
-          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
-            StarRating(rating.starRating.toDouble())
-          )
-        } else null
-      }
-
-      is Media3PercentRating -> {
-        if (rating.isRated) {
-          Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.create(
-            PercentageRating(rating.percent.toDouble())
-          )
-        } else null
-      }
-
-      else -> null
-    }
-  }
-
-  fun bridgeToMedia3(
-    rating: Variant_HeartRating_ThumbsRating_StarRating_PercentageRating
-  ): Rating? {
-    return when (rating) {
-      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.First ->
-        Media3HeartRating(rating.value.hasHeart)
-
-      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Second ->
-        Media3ThumbRating(rating.value.isThumbsUp)
-
-      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Third ->
-        Media3StarRating(5, rating.value.stars.toFloat())
-
-      is Variant_HeartRating_ThumbsRating_StarRating_PercentageRating.Fourth ->
-        Media3PercentRating(rating.value.percentage.toFloat())
-    }
-  }
-}

package/android/src/main/java/com/audiobrowser/util/ResolvedTrackFactory.kt

@@ -1,36 +0,0 @@
-package com.audiobrowser.util
-
-import androidx.core.net.toUri
-import androidx.media3.common.MediaItem
-import androidx.media3.common.MediaMetadata
-import com.margelo.nitro.audiobrowser.ResolvedTrack
-
-object ResolvedTrackFactory {
-
-  fun toMedia3(resolvedTrack: ResolvedTrack): MediaItem {
-    val extras = MediaExtrasBuilder.build(resolvedTrack)
-
-    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
-    val artworkUri = resolvedTrack.artworkSource?.uri ?: resolvedTrack.artwork
-
-    val mediaMetadata =
-      MediaMetadata.Builder()
-        .setTitle(resolvedTrack.title)
-        .setArtist(resolvedTrack.artist)
-        .setAlbumTitle(resolvedTrack.album)
-        .setDescription(resolvedTrack.description)
-        .setGenre(resolvedTrack.genre)
-        .setArtworkUri(artworkUri?.toUri())
-        .setIsBrowsable(resolvedTrack.src == null)
-        .setIsPlayable(resolvedTrack.src != null)
-        .setExtras(extras)
-        .build()
-
-    return MediaItem.Builder()
-      .setMediaId(resolvedTrack.url)
-      .setUri(resolvedTrack.src)
-      .setMediaMetadata(mediaMetadata)
-      .setTag(resolvedTrack)
-      .build()
-  }
-}

package/android/src/test/java/com/audiobrowser/player/PlaybackProgressUpdateManagerTest.kt

@@ -1,146 +0,0 @@
-package com.audiobrowser.player
-
-import com.margelo.nitro.audiobrowser.PlaybackState
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.test.UnconfinedTestDispatcher
-import kotlinx.coroutines.test.advanceTimeBy
-import kotlinx.coroutines.test.resetMain
-import kotlinx.coroutines.test.runTest
-import kotlinx.coroutines.test.setMain
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-
-@OptIn(ExperimentalCoroutinesApi::class)
-class PlaybackProgressUpdateManagerTest {
-
-  @Before
-  fun setup() {
-    Dispatchers.setMain(UnconfinedTestDispatcher())
-  }
-
-  @After
-  fun tearDown() {
-    Dispatchers.resetMain()
-  }
-
-  @Test
-  fun `setUpdateInterval before playback does not emit events`() = runTest {
-    var callCount = 0
-    val manager = PlaybackProgressUpdateManager { callCount++ }
-
-    manager.setUpdateInterval(0.1)
-
-    advanceTimeBy(500)
-    assertEquals(0, callCount)
-    manager.stop()
-  }
-
-  @Test
-  fun `setUpdateInterval while running restarts with new interval`() = runTest {
-    var callCount = 0
-    val manager = PlaybackProgressUpdateManager { callCount++ }
-
-    manager.setUpdateInterval(0.1)
-    manager.start()
-
-    advanceTimeBy(350)
-    assertTrue("Expected events while running, got $callCount", callCount > 0)
-
-    val countBefore = callCount
-    manager.setUpdateInterval(0.2) // different value — should restart
-    advanceTimeBy(500)
-    assertTrue("Expected more events after interval change", callCount > countBefore)
-
-    manager.stop()
-  }
-
-  @Test
-  fun `start begins emitting, stop ceases emitting`() = runTest {
-    var callCount = 0
-    val manager = PlaybackProgressUpdateManager { callCount++ }
-
-    manager.setUpdateInterval(0.1)
-    manager.start()
-
-    advanceTimeBy(350)
-    assertTrue("Expected events after start", callCount > 0)
-
-    manager.stop()
-    val countAfterStop = callCount
-
-    advanceTimeBy(500)
-    assertEquals(countAfterStop, callCount)
-  }
-
-  @Test
-  fun `start without interval does nothing`() = runTest {
-    var callCount = 0
-    val manager = PlaybackProgressUpdateManager { callCount++ }
-
-    manager.start()
-
-    advanceTimeBy(500)
-    assertEquals(0, callCount)
-  }
-
-  @Test
-  fun `playing state starts timer, paused stops it`() = runTest {
-    var callCount = 0
-    val manager = PlaybackProgressUpdateManager { callCount++ }
-
-    manager.setUpdateInterval(0.1)
-    manager.onPlaybackStateChanged(PlaybackState.PLAYING)
-
-    advanceTimeBy(350)
-    assertTrue("Expected events when playing", callCount > 0)
-
-    manager.onPlaybackStateChanged(PlaybackState.PAUSED)
-    val countAfterPause = callCount
-
-    advanceTimeBy(500)
-    assertEquals(countAfterPause, callCount)
-  }
-
-  @Test
-  fun `loading and buffering states also start timer`() = runTest {
-    var callCount = 0
-    val manager = PlaybackProgressUpdateManager { callCount++ }
-
-    manager.setUpdateInterval(0.1)
-
-    manager.onPlaybackStateChanged(PlaybackState.LOADING)
-    advanceTimeBy(350)
-    assertTrue("Expected events when loading", callCount > 0)
-
-    manager.onPlaybackStateChanged(PlaybackState.STOPPED)
-    val afterStop = callCount
-
-    manager.onPlaybackStateChanged(PlaybackState.BUFFERING)
-    advanceTimeBy(350)
-    assertTrue("Expected events when buffering", callCount > afterStop)
-
-    manager.stop()
-  }
-
-  @Test
-  fun `setting nil interval stops timer`() = runTest {
-    var callCount = 0
-    val manager = PlaybackProgressUpdateManager { callCount++ }
-
-    manager.setUpdateInterval(0.1)
-    manager.start()
-
-    advanceTimeBy(350)
-    assertTrue("Expected events before clearing", callCount > 0)
-
-    manager.setUpdateInterval(null)
-    val afterNil = callCount
-
-    advanceTimeBy(500)
-    assertEquals(afterNil, callCount)
-  }
-}

package/ios/CarPlay/Track+CarPlay.swift

@@ -1,63 +0,0 @@
-import CarPlay
-import Foundation
-import NitroModules
-
-// MARK: - Track CarPlay Extensions
-
-extension Track {
-  /// Returns the best artwork URL for CarPlay display.
-  var carPlayArtworkUrl: URL? {
-    if let artworkSource {
-      let uri = artworkSource.uri
-      return URL(string: uri)
-    }
-    if let artwork {
-      return URL(string: artwork)
-    }
-    return nil
-  }
-
-  /// Returns whether this track is playable (has a media source).
-  var isPlayable: Bool {
-    src != nil
-  }
-
-  /// Returns whether this track is browsable (has a navigation URL).
-  var isBrowsable: Bool {
-    url != nil && src == nil
-  }
-
-  /// Returns the display subtitle for CarPlay.
-  /// Uses subtitle if available, falls back to artist.
-  var carPlaySubtitle: String? {
-    subtitle ?? artist
-  }
-}
-
-// MARK: - ImageRowItem → Track Conversion
-
-extension ImageRowItem {
-  /// Creates a minimal Track from an ImageRowItem for reuse with item selection and artwork loading.
-  func toTrack() -> Track {
-    Track(
-      url: url, src: nil, artwork: artwork, artworkSource: artworkSource,
-      artworkCarPlayTinted: nil, title: title, subtitle: nil, artist: nil,
-      album: nil, description: nil, genre: nil, duration: nil, style: nil,
-      childrenStyle: nil, favorited: nil, groupTitle: nil, live: nil, imageRow: nil
-    )
-  }
-}
-
-// MARK: - ResolvedTrack CarPlay Extensions
-
-extension ResolvedTrack {
-  /// Returns playable children only (tracks with src).
-  var playableChildren: [Track] {
-    children?.filter { $0.src != nil } ?? []
-  }
-
-  /// Returns browsable children only (tracks with url but no src).
-  var browsableChildren: [Track] {
-    children?.filter { $0.url != nil && $0.src == nil } ?? []
-  }
-}

package/ios/NowPlayingInfo/NowPlayingInfoCenter.swift

@@ -1,9 +0,0 @@
-import Foundation
-import MediaPlayer
-
-protocol NowPlayingInfoCenter {
-  var nowPlayingInfo: [String: Any]? { get set }
-  var playbackState: MPNowPlayingPlaybackState { get set }
-}
-
-extension MPNowPlayingInfoCenter: NowPlayingInfoCenter {}

package/ios/Player/PlaybackProgressUpdateManager.swift

@@ -1,68 +0,0 @@
-import Foundation
-#if canImport(NitroModules)
-import NitroModules
-#endif
-
-/**
- Manages periodic progress updates during playback.
- Emits progress events at configurable intervals based on playback state.
- */
-@MainActor
-class PlaybackProgressUpdateManager {
-  // nonisolated(unsafe) for deinit cleanup — Timer must be invalidated to
-  // break RunLoop retain, and deinit is always nonisolated in Swift 6.
-  nonisolated(unsafe) private var timer: Timer?
-  private var updateInterval: TimeInterval?
-  private let onProgressUpdate: () -> Void
-
-  init(onProgressUpdate: @escaping () -> Void) {
-    self.onProgressUpdate = onProgressUpdate
-  }
-
-  deinit {
-    timer?.invalidate()
-  }
-
-  func setUpdateInterval(_ interval: TimeInterval?) {
-    if interval == updateInterval { return }
-    let wasRunning = timer != nil
-    updateInterval = (interval != nil && interval! > 0) ? interval : nil
-    stop()
-    if updateInterval != nil, wasRunning {
-      start()
-    }
-  }
-
-  func start() {
-    guard timer == nil, let interval = updateInterval else { return }
-    timer = Timer.scheduledTimer(
-      withTimeInterval: interval,
-      repeats: true,
-    ) { [weak self] _ in
-      MainActor.assumeIsolated {
-        self?.onProgressUpdate()
-      }
-    }
-  }
-
-  func stop() {
-    timer?.invalidate()
-    timer = nil
-  }
-
-  func onPlaybackStateChanged(_ state: PlaybackState) {
-    switch state {
-    // Start when playback is set to resume (loading, buffering) or playing
-    case .loading, .buffering, .playing:
-      start()
-
-    // Stop when playback pauses, stops, or errors
-    case .paused, .stopped, .ended, .error:
-      stop()
-
-    // No action for ready, none
-    default:
-      break
-    }
-  }
-}