react-native-audio-browser 0.1.0 → 0.2.0-next.1

package/src/features/player/options.ts

@@ -1,5 +1,5 @@
-import type { RatingType } from '../metadata'
-import type { RepeatMode } from '../queue/repeatMode'
+import type { FavoriteConfig } from '../../types'
+import type { CarPlayNowPlayingButton } from '../../types/browser'
 import { nativeBrowser } from '../../native'
 import { NativeUpdatedValue } from '../../utils/NativeUpdatedValue'
 import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
@@ -8,7 +8,8 @@ import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
 
 /**
  * Player capabilities control which media controls are available to the user.
- * All capabilities are enabled by default - only specify ones you want to disable.
+ * Most capabilities are enabled by default - only specify the ones you want to change.
+ * Exceptions that default to off: `jumpForward`, `jumpBackward`, and `favorite`.
  *
  * @example
  * ```typescript
@@ -65,12 +66,38 @@ export interface PlayerCapabilities {
    */
   jumpBackward?: boolean
   /**
-   * Enable favorite/like control.
-   * On iOS: appears in Control Center.
-   * On Android: can be assigned to notification button slots.
-   * @default true
+   * Enable track favoriting.
+   *
+   * Turns on the favorite/like heart across all surfaces:
+   * - iOS: Control Center + CarPlay now-playing.
+   * - Android: notification button slot + Android Auto now-playing, and an
+   *   (empty or filled) heart on playable browse rows.
+   *
+   * `match` controls how the ids from `setFavorites` are
+   * compared against a track's `src` to decide its `favorited` state
+   * (see `FavoritesMatchMode`); `true` is shorthand for `'exact'`.
+   *
+   * - `false` / omitted: favoriting off everywhere.
+   * - `true`: on, with `'exact'` id matching.
+   * - `{ match }`: on, with the given match mode.
+   *
+   * @example
+   * ```ts
+   * // 'exact': a favorite id must equal the track's src.
+   * favorite: { match: 'exact' }
+   * setFavorites(['https://cdn.example.com/audio/track-42.mp3'])
+   * // → favorited when src === 'https://cdn.example.com/audio/track-42.mp3'
+   *
+   * // 'partial': a favorite id matches when it is a full path segment of src.
+   * favorite: { match: 'partial' }
+   * setFavorites(['track-42'])
+   * // → favorited when src is '/library/track-42' or '/stream/track-42?hq=1',
+   * //   but NOT '/library/track-420'
+   * ```
+   *
+   * @default false
    */
-  favorite?: boolean
+  favorite?: boolean | FavoriteConfig
   /**
    * Enable shuffle mode toggle.
    * @default true
@@ -166,10 +193,9 @@ export type AppKilledPlaybackBehavior =
  * @example
  * ```typescript
  * const options = getOptions();
- * console.log(options.repeatMode); // 'off'
+ * console.log(options.forwardJumpInterval); // 15
  * console.log(options.capabilities); // { shuffleMode: false } - only disabled caps shown
  * console.log(options.android?.skipSilence); // true (Android only)
- * console.log(options.ios?.likeOptions); // { isActive: false, title: 'Like' } (iOS only)
  * ```
  */
 export interface Options {
@@ -197,23 +223,37 @@ export interface Options {
 
   /**
    * The capabilities that the player has.
-   * All capabilities are enabled by default - this shows which ones are disabled.
+   * Most capabilities are enabled by default - this shows which ones are disabled.
    */
   capabilities: PlayerCapabilities
 
+  /** iOS-specific player options with resolved defaults (only present on iOS). */
+  ios?: IOSOptions
+}
+
+/**
+ * iOS-specific player options with resolved defaults (from {@link getOptions}).
+ * Only present on iOS.
+ */
+export interface IOSOptions {
   /**
-   * The current repeat mode of the player.
-   * @default RepeatMode.Off
+   * Supported playback rates for the playback-rate capability.
+   * Used by CarPlay and lock screen rate controls.
+   * @default [0.5, 1.0, 1.5, 2.0]
    */
-  repeatMode: RepeatMode
-}
+  playbackRates: number[]
 
-export interface FeedbackOptions {
-  /** Marks wether the option should be marked as active or "done" */
-  isActive: boolean
+  /**
+   * Whether the "Up Next" button is enabled on the CarPlay Now Playing screen.
+   * @default true
+   */
+  carPlayUpNextButton: boolean
 
-  /** The title to give the action (relevant for iOS) */
-  title: string
+  /**
+   * Buttons shown on the CarPlay Now Playing screen (left-to-right, up to 5).
+   * @default []
+   */
+  carPlayNowPlayingButtons: CarPlayNowPlayingButton[]
 }
 
 export interface AndroidOptions {
@@ -232,20 +272,6 @@ export interface AndroidOptions {
    */
   skipSilence: boolean
 
-  /**
-   * Whether shuffle mode is enabled for queue playback.
-   * When enabled, tracks will be played in random order.
-   *
-   * @default false
-   */
-  shuffle: boolean
-
-  /**
-   * The rating type to use for ratings.
-   * Determines how star ratings and thumbs up/down are handled.
-   */
-  ratingType: RatingType
-
   /**
    * Slot-based button layout for Android notifications.
    * Provides explicit control over which buttons appear in which positions.
@@ -273,20 +299,6 @@ export interface AndroidUpdateOptions {
    */
   skipSilence?: boolean
 
-  /**
-   * Whether shuffle mode is enabled for queue playback.
-   * When enabled, tracks will be played in random order.
-   *
-   * @default false
-   */
-  shuffle?: boolean
-
-  /**
-   * The rating type to use for ratings.
-   * Determines how star ratings and thumbs up/down are handled.
-   */
-  ratingType?: RatingType
-
   /**
    * Slot-based button layout for Android notifications.
    * Provides explicit control over which buttons appear in which positions.
@@ -298,14 +310,58 @@ export interface AndroidUpdateOptions {
   notificationButtons?: NotificationButtonLayout | null
 }
 
+/**
+ * Wire shape of {@link AndroidUpdateOptions} — what crosses the Nitro bridge.
+ * @internal
+ */
 export interface NitroAndroidUpdateOptions {
   appKilledPlaybackBehavior?: AppKilledPlaybackBehavior
   skipSilence?: boolean
-  shuffle?: boolean
-  ratingType?: RatingType
   notificationButtons?: NotificationButtonLayout | null
 }
 
+/**
+ * iOS-specific player options that can be changed at runtime via {@link updateOptions}.
+ * @platform ios
+ */
+export interface IOSUpdateOptions {
+  /**
+   * Supported playback rates for the playback-rate capability.
+   * Used by CarPlay and lock screen rate controls.
+   * @default [0.5, 1.0, 1.5, 2.0]
+   */
+  playbackRates?: number[]
+
+  /**
+   * Enable the "Up Next" button on the CarPlay Now Playing screen. The button is
+   * automatically hidden when the queue has only one track.
+   * @default true
+   */
+  carPlayUpNextButton?: boolean
+
+  /**
+   * Configure up to 5 buttons on the CarPlay Now Playing screen, arranged in
+   * array order (left to right).
+   *
+   * @example
+   * ```typescript
+   * updateOptions({ ios: { carPlayNowPlayingButtons: ['repeat'] } })
+   * ```
+   * @default []
+   */
+  carPlayNowPlayingButtons?: CarPlayNowPlayingButton[]
+}
+
+/**
+ * Wire shape of {@link IOSUpdateOptions} — what crosses the Nitro bridge.
+ * @internal
+ */
+export interface NitroIOSUpdateOptions {
+  playbackRates?: number[]
+  carPlayUpNextButton?: boolean
+  carPlayNowPlayingButtons?: CarPlayNowPlayingButton[]
+}
+
 /**
  * Partial options for updating player configuration.
  * Only specify the properties you want to change - all properties are optional.
@@ -313,9 +369,6 @@ export interface NitroAndroidUpdateOptions {
  *
  * @example
  * ```typescript
- * // Update only repeat mode
- * updateOptions({ repeatMode: 'track' });
- *
  * // Disable specific capabilities
  * updateOptions({
  *   capabilities: { shuffleMode: false, repeatMode: false }
@@ -328,8 +381,7 @@ export interface NitroAndroidUpdateOptions {
  *
  * // Platform-specific options
  * updateOptions({
- *   android: { skipSilence: true },
- *   ios: { likeOptions: { isActive: true, title: 'Love' } }
+ *   android: { skipSilence: true }
  * });
  * ```
  */
@@ -337,6 +389,9 @@ export interface UpdateOptions {
   /** Android-specific configuration options */
   android?: AndroidUpdateOptions
 
+  /** iOS-specific configuration options */
+  ios?: IOSUpdateOptions
+
   /**
    * Jump forward interval in seconds when using jump forward controls.
    * @default 15
@@ -372,20 +427,19 @@ export interface UpdateOptions {
    * ```
    */
   capabilities?: PlayerCapabilities
-
-  /**
-   * Supported playback rates for the playback-rate capability.
-   * Used by CarPlay and lock screen rate controls.
-   * @platform ios
-   * @default [0.5, 1.0, 1.5, 2.0]
-   */
-  iosPlaybackRates?: number[]
 }
 
+/**
+ * Wire shape of {@link UpdateOptions} — what crosses the Nitro bridge.
+ * @internal
+ */
 export interface NativeUpdateOptions {
   /** Android-specific configuration options */
   android?: NitroAndroidUpdateOptions
 
+  /** iOS-specific configuration options */
+  ios?: NitroIOSUpdateOptions
+
   /**
    * Jump forward interval in seconds when using jump forward controls.
    * @default 15
@@ -406,16 +460,29 @@ export interface NativeUpdateOptions {
   progressUpdateEventInterval?: number | null
 
   capabilities?: PlayerCapabilities
-
-  /**
-   * Supported playback rates for the playback-rate capability.
-   * @platform ios
-   */
-  iosPlaybackRates?: number[]
 }
 
 // MARK: - Functions
 
+const MAX_CARPLAY_NOW_PLAYING_BUTTONS = 5
+
+/**
+ * Warns when more CarPlay now-playing buttons are configured than CarPlay renders.
+ * Shared by {@link updateOptions} and `setupPlayer` (both can carry `ios` options).
+ *
+ * @internal Validation helper, not public API — `stripInternal` removes it from
+ * the published types and typedoc hides it from the docs.
+ */
+export function validateIOSUpdateOptions(ios?: IOSUpdateOptions): void {
+  const buttons = ios?.carPlayNowPlayingButtons
+  if (buttons && buttons.length > MAX_CARPLAY_NOW_PLAYING_BUTTONS) {
+    console.warn(
+      `[react-native-audio-browser] ${buttons.length} CarPlay now-playing ` +
+        `buttons configured; CarPlay shows at most ${MAX_CARPLAY_NOW_PLAYING_BUTTONS}.`
+    )
+  }
+}
+
 /**
  * Updates the configuration for the components.
  * Pass only the properties you want to change - all properties are optional.
@@ -424,9 +491,6 @@ export interface NativeUpdateOptions {
  * @see {@link getOptions} to get current options
  * @example
  * ```typescript
- * // Update single property
- * updateOptions({ repeatMode: 'track' });
- *
  * // Disable specific capabilities
  * updateOptions({
  *   capabilities: { shuffleMode: false },
@@ -435,6 +499,7 @@ export interface NativeUpdateOptions {
  * ```
  */
 export function updateOptions(options: UpdateOptions): void {
+  validateIOSUpdateOptions(options.ios)
   nativeBrowser.updateOptions(options)
 }
 
@@ -448,13 +513,13 @@ export function updateOptions(options: UpdateOptions): void {
  * @example
  * ```typescript
  * const options = getOptions();
- * if (options.repeatMode === 'track') {
- *   // Handle track repeat mode
+ * if (options.capabilities.shuffleMode === false) {
+ *   // Shuffle is disabled
  * }
  * ```
  */
 export function getOptions(): Options {
-  return nativeBrowser.getOptions() as Options
+  return nativeBrowser.getOptions()
 }
 
 // MARK: - Event Callbacks

package/src/features/player/setup.test.ts

@@ -0,0 +1,117 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('../../native', () => ({
+  nativeBrowser: {
+    setupPlayer: vi.fn().mockResolvedValue(undefined)
+  }
+}))
+
+import { nativeBrowser } from '../../native'
+import { setupPlayer } from './setup'
+
+const native = vi.mocked(nativeBrowser)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  native.setupPlayer.mockResolvedValue(undefined)
+})
+
+function payload() {
+  expect(native.setupPlayer).toHaveBeenCalledTimes(1)
+  return native.setupPlayer.mock.calls[0]![0]
+}
+
+describe('setupPlayer wire regrouping', () => {
+  it('sends the full launch description in a single native call', async () => {
+    await setupPlayer({
+      retry: true,
+      playWhenReady: true,
+      repeatMode: 'queue',
+      capabilities: { favorite: true }
+    })
+
+    expect(payload()).toEqual({
+      retry: true,
+      playWhenReady: true,
+      repeatMode: 'queue',
+      autoUpdateNowPlayingMetadata: true,
+      nowPlayingMetadataFormatter: undefined,
+      options: { capabilities: { favorite: true } }
+    })
+  })
+
+  it('omits the options bag when no runtime options are given', async () => {
+    await setupPlayer({ retry: true })
+
+    expect(payload()).not.toHaveProperty('options')
+  })
+
+  it('splits the merged android bag into construction and runtime fields', async () => {
+    await setupPlayer({
+      android: {
+        minBuffer: 50_000,
+        wakeMode: 'network',
+        skipSilence: true,
+        notificationButtons: { overflow: ['favorite'] }
+      }
+    })
+
+    const sent = payload()
+    expect(sent.android).toEqual({ minBuffer: 50_000, wakeMode: 'network' })
+    expect(sent.options).toEqual({
+      android: {
+        skipSilence: true,
+        notificationButtons: { overflow: ['favorite'] }
+      }
+    })
+  })
+
+  it('moves ios playbackRates into the runtime options', async () => {
+    await setupPlayer({
+      ios: { category: 'playback', playbackRates: [0.5, 1, 2] }
+    })
+
+    const sent = payload()
+    expect(sent.ios).toEqual({ category: 'playback' })
+    expect(sent.options).toEqual({ ios: { playbackRates: [0.5, 1, 2] } })
+  })
+
+  it('omits a platform bag that only carried runtime fields', async () => {
+    await setupPlayer({ android: { skipSilence: true } })
+
+    expect(payload()).not.toHaveProperty('android')
+  })
+
+  it('forwards meaningful nulls (progress disabled, empty button layout)', async () => {
+    await setupPlayer({
+      progressUpdateEventInterval: null,
+      android: { notificationButtons: null }
+    })
+
+    expect(payload().options).toEqual({
+      progressUpdateEventInterval: null,
+      android: { notificationButtons: null }
+    })
+  })
+
+  it('normalizes a formatter callback and coalesces its undefined to {}', async () => {
+    const formatter = vi.fn(() => undefined)
+    await setupPlayer({ nowPlaying: formatter })
+
+    const sent = payload()
+    expect(sent.autoUpdateNowPlayingMetadata).toBe(true)
+    // The wrapper never lets `undefined` cross the Nitro boundary.
+    expect(
+      sent.nowPlayingMetadataFormatter!({
+        track: { title: 'Station' },
+        playWhenReady: true
+      })
+    ).toEqual({})
+  })
+
+  it('maps nowPlaying: false to disabled metadata publishing', async () => {
+    await setupPlayer({ nowPlaying: false })
+
+    expect(payload().autoUpdateNowPlayingMetadata).toBe(false)
+  })
+})