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

package/src/features/gate.ts

@@ -0,0 +1,170 @@
+import type { SearchParams } from '../types/browser'
+import { nativeBrowser } from '../native'
+import { LazyNativeEmitter } from '../utils/LazyNativeEmitter'
+
+// MARK: - Wire types (cross the Nitro bridge; native↔JS)
+
+/** Discriminant for gate requests and events. */
+export type GateReason = 'browse' | 'search'
+
+/**
+ * Flat wire struct for a gate request (crosses the Nitro bridge).
+ * Use {@link GateRequest} in consumer-facing code; `gate.ts` converts between them.
+ * @internal
+ */
+export type NativeGateRequest = {
+  reason: GateReason
+  path?: string
+  search?: SearchParams
+}
+
+/**
+ * Wire form of a resolver result (native awaits this from JS).
+ * @internal
+ */
+export type GateDecision = { gated: boolean; gate?: Gate }
+
+/**
+ * Fired once per gated serve (each time the gate chrome is rendered for a
+ * request). This is **not** once per user action: on car surfaces a single
+ * action can serve the gate for several requests at once — e.g. building the
+ * tab bar resolves and serves each gated tab, firing one event per gated tab.
+ * There is no library-side dedup; debounce on the consumer side (e.g. record a
+ * gate-hit at most once per session).
+ */
+export type GateEvent = { reason: GateReason }
+
+// MARK: - Public types (consumer-facing)
+
+/**
+ * A gate's chrome (title and optional message).
+ *
+ * While the gate is active, every browse or search request on car surfaces
+ * (CarPlay, Android Auto) shows this page instead of the real content.
+ * Playback, the queue, and now-playing are unaffected.
+ *
+ * - **CarPlay**: plain centered message page.
+ * - **Android Auto**: one non-playable list tile (message not shown).
+ */
+export type Gate = {
+  /** Headline shown on the gate page. */
+  title: string
+  /**
+   * The explanatory copy under the title. On CarPlay this is the centered
+   * message body; newlines become spaces. Android Auto does not display it.
+   */
+  message?: string
+}
+
+/**
+ * The gate chrome crosses the bridge as-is; this alias marks the wire side.
+ * @internal
+ */
+export type NativeGate = Gate
+
+/**
+ * Describes the request being decided by a {@link GateResolver}.
+ * Discriminated by `kind`: `'browse'` for content navigation, `'search'` for
+ * voice/manual search queries.
+ */
+export type GateRequest =
+  | { kind: 'browse'; path: string }
+  | { kind: 'search'; params: SearchParams }
+
+/**
+ * Decides per request whether to gate.
+ * - Return a {@link Gate} to gate with specific chrome for this request.
+ * - Return `true` to gate using the default chrome (or the built-in fallback).
+ * - Return `false` to allow the request through.
+ */
+export type GateResolver = (request: GateRequest) => Gate | boolean
+
+// MARK: - Internal state
+
+let resolver: GateResolver | undefined
+
+function toPublicRequest(req: NativeGateRequest): GateRequest {
+  switch (req.reason) {
+    case 'browse':
+      return { kind: 'browse', path: req.path ?? '' }
+    case 'search':
+      // req.search is always present on a well-formed search request — the
+      // native wire contract guarantees it for reason:'search'. Assert the
+      // native contract with `!` so we never hand consumer code a SearchParams
+      // with its required `query` field missing.
+      return { kind: 'search', params: req.search! }
+    default: {
+      const _exhaustive: never = req.reason
+      throw new Error(`Unhandled GateReason: ${String(_exhaustive)}`)
+    }
+  }
+}
+
+// Native awaits this per request at a serve site.
+// No resolver → static gate → every request is gated (native applies stored default / built-in).
+nativeBrowser.resolveGate = async (
+  req: NativeGateRequest
+): Promise<GateDecision> => {
+  const result = resolver ? resolver(toPublicRequest(req)) : true
+  if (result === false) return { gated: false }
+  if (result === true) return { gated: true }
+  return { gated: true, gate: result }
+}
+
+// MARK: - Public API
+
+/**
+ * Raises the gate with default chrome, optionally with a per-request resolver.
+ * Calling it again while a gate is already up updates the chrome in place,
+ * keeping the current tab. Note this is **not** fully navigation-preserving: on
+ * some surfaces (CarPlay) any gate change pops pushed navigation back to root,
+ * so a page the user had drilled into is reset to the tab root. Set the gate
+ * before the car connects and it'll be there the moment it does.
+ *
+ * @platform ios android
+ * A no-op on web, which has no CarPlay or Android Auto surfaces for the gate to
+ * cover. Nothing is lost: the gate never covered in-app browse UI on any
+ * platform — that stays yours to gate.
+ */
+export function setGate(gate: Gate, resolve?: GateResolver): void
+/**
+ * Raises the gate with a resolver only (no default chrome).
+ * The resolver must return a {@link Gate} or `true` for gated requests;
+ * native uses the built-in fallback chrome when `true` and no default is set.
+ *
+ * @platform ios android
+ * A no-op on web — the resolver is never consulted there.
+ */
+export function setGate(resolve: GateResolver): void
+export function setGate(a: Gate | GateResolver, b?: GateResolver): void {
+  if (typeof a === 'function') {
+    resolver = a
+    nativeBrowser.setGate(undefined, true)
+  } else {
+    resolver = b
+    nativeBrowser.setGate(a, b != null)
+  }
+}
+
+/**
+ * Drops the gate — the real content comes back, and the current tab is kept.
+ *
+ * @platform ios android
+ * A no-op on web, where no gate was ever raised.
+ */
+export function clearGate(): void {
+  resolver = undefined
+  nativeBrowser.clearGate()
+}
+
+/**
+ * Subscribes to gate events (fired when a request is gated).
+ *
+ * @platform ios android
+ * Never fires on web — there are no gated serves to report.
+ *
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
+ */
+export const onGate = LazyNativeEmitter.emitterize<GateEvent>(
+  (cb) => (nativeBrowser.onGate = cb)
+)

package/src/features/hook-wiring.test.ts

@@ -0,0 +1,254 @@
+/** @vitest-environment happy-dom */
+
+import { renderHook, act, cleanup } from '@testing-library/react'
+import { describe, it, expect, afterEach, vi } from 'vitest'
+
+/**
+ * The 22 hooks that are a single delegation to `useNativeUpdatedValue`. Their
+ * behaviour is covered once in `utils/useNativeUpdatedValue.test.ts`; what is
+ * per-hook and untestable there is the wiring — which native callback slot the
+ * emitter claims, and which `eventKey` is pulled out of the payload.
+ *
+ * Both are easy to get wrong and silent when wrong: the hook simply never
+ * updates, or yields the whole event where a field was meant. Five slots
+ * already differ in name from the emitter that claims them
+ * (`onPlaybackPlayWhenReadyChanged` behind `onPlayWhenReadyChanged`, and
+ * friends), so the names cannot be derived — they have to be pinned.
+ */
+const slots = vi.hoisted(() => new Map<string, (event: unknown) => void>())
+
+vi.mock('../native', () => ({
+  nativeBrowser: new Proxy({} as Record<string, unknown>, {
+    get(target, prop: string) {
+      // Getters are the pre-native fallback; undefined stands in for "native
+      // has not answered yet", which is what these tests start from.
+      target[prop] ??= vi.fn(() => undefined)
+      return target[prop]
+    },
+    set(target, prop: string, value) {
+      if (typeof value === 'function') slots.set(prop, value)
+      target[prop] = value
+      return true
+    }
+  })
+}))
+
+const { useBatteryOptimizationStatus, useBatteryWarningPending } =
+  await import('./battery')
+const { useContent, usePath, useTabs } = await import('./browser')
+const { useCarConnected } = await import('./carConnection')
+const { useEqualizerSettings } = await import('./equalizer')
+const { useFormattedNavigationError, useNavigationError, usePlaybackError } =
+  await import('./errors')
+const { useOnline } = await import('./network')
+const { useNowPlaying } = await import('./nowPlaying')
+const { useOutput } = await import('./output')
+const { useOptions } = await import('./player/options')
+const { usePlayingState } = await import('./playback/playing')
+const { usePlayWhenReady } = await import('./playback/playWhenReady')
+const { useProgress } = await import('./playback/progress')
+const { usePlayback } = await import('./playback/state')
+const { useSystemVolume } = await import('./playback/volume')
+const { useActiveTrack } = await import('./queue/activeTrack')
+const { useQueue } = await import('./queue/queue')
+const { useRepeatMode } = await import('./queue/repeatMode')
+const { useShuffle } = await import('./queue/shuffle')
+
+afterEach(cleanup)
+
+type Wiring = {
+  name: string
+  hook: () => unknown
+  /** The property on the Nitro object the emitter assigns its callback to. */
+  slot: string
+  event: unknown
+  /** What the hook returns — differs from `event` exactly when an eventKey applies. */
+  expected: unknown
+}
+
+const wirings: Wiring[] = [
+  // Payload passed through whole (no eventKey).
+  {
+    name: 'useOutput',
+    hook: useOutput,
+    slot: 'onOutputChanged',
+    event: { type: 'bluetooth' },
+    expected: { type: 'bluetooth' }
+  },
+  {
+    name: 'useNowPlaying',
+    hook: useNowPlaying,
+    slot: 'onNowPlayingChanged',
+    event: { title: 'Song' },
+    expected: { title: 'Song' }
+  },
+  {
+    name: 'useOnline',
+    hook: useOnline,
+    slot: 'onOnlineChanged',
+    event: true,
+    expected: true
+  },
+  {
+    name: 'useCarConnected',
+    hook: useCarConnected,
+    slot: 'onCarConnectedChanged',
+    event: true,
+    expected: true
+  },
+  {
+    name: 'useEqualizerSettings',
+    hook: useEqualizerSettings,
+    slot: 'onEqualizerChanged',
+    event: { enabled: true },
+    expected: { enabled: true }
+  },
+  {
+    name: 'usePath',
+    hook: usePath,
+    slot: 'onPathChanged',
+    event: '/artists/1',
+    expected: '/artists/1'
+  },
+  {
+    name: 'useContent',
+    hook: useContent,
+    slot: 'onContentChanged',
+    event: { src: 'a' },
+    expected: { src: 'a' }
+  },
+  {
+    name: 'useTabs',
+    hook: useTabs,
+    slot: 'onTabsChanged',
+    event: [{ src: 'a' }],
+    expected: [{ src: 'a' }]
+  },
+  {
+    name: 'usePlayback',
+    hook: usePlayback,
+    slot: 'onPlaybackChanged',
+    event: { state: 'playing' },
+    expected: { state: 'playing' }
+  },
+  {
+    name: 'useSystemVolume',
+    hook: useSystemVolume,
+    slot: 'onSystemVolumeChanged',
+    event: 0.4,
+    expected: 0.4
+  },
+  {
+    name: 'useProgress',
+    hook: useProgress,
+    slot: 'onPlaybackProgressUpdated',
+    event: { position: 1, duration: 2, buffered: 3 },
+    expected: { position: 1, duration: 2, buffered: 3 }
+  },
+  {
+    name: 'usePlayingState',
+    hook: usePlayingState,
+    slot: 'onPlaybackPlayingState',
+    event: { state: 'ready' },
+    expected: { state: 'ready' }
+  },
+  {
+    name: 'useShuffle',
+    hook: useShuffle,
+    slot: 'onPlaybackShuffleModeChanged',
+    event: true,
+    expected: true
+  },
+  {
+    name: 'useQueue',
+    hook: useQueue,
+    slot: 'onPlaybackQueueChanged',
+    event: [{ src: 'a' }],
+    expected: [{ src: 'a' }]
+  },
+  {
+    name: 'useFormattedNavigationError',
+    hook: useFormattedNavigationError,
+    slot: 'onFormattedNavigationError',
+    event: { title: 'Offline' },
+    expected: { title: 'Offline' }
+  },
+  {
+    name: 'useOptions',
+    hook: useOptions,
+    slot: 'onOptionsChanged',
+    event: { playbackSpeed: 1.5 },
+    expected: { playbackSpeed: 1.5 }
+  },
+
+  // A field lifted out of the payload — the eventKey cases.
+  {
+    name: 'usePlaybackError',
+    hook: usePlaybackError,
+    slot: 'onPlaybackError',
+    event: { error: { code: 'network' } },
+    expected: { code: 'network' }
+  },
+  {
+    name: 'useNavigationError',
+    hook: useNavigationError,
+    slot: 'onNavigationError',
+    event: { error: { code: 'notFound' } },
+    expected: { code: 'notFound' }
+  },
+  {
+    name: 'usePlayWhenReady',
+    hook: usePlayWhenReady,
+    slot: 'onPlaybackPlayWhenReadyChanged',
+    event: { playWhenReady: true },
+    expected: true
+  },
+  {
+    name: 'useRepeatMode',
+    hook: useRepeatMode,
+    slot: 'onPlaybackRepeatModeChanged',
+    event: { repeatMode: 'queue' },
+    expected: 'queue'
+  },
+  {
+    name: 'useActiveTrack',
+    hook: useActiveTrack,
+    slot: 'onPlaybackActiveTrackChanged',
+    event: { track: { src: 'a' } },
+    expected: { src: 'a' }
+  },
+  {
+    name: 'useBatteryWarningPending',
+    hook: useBatteryWarningPending,
+    slot: 'onBatteryWarningPendingChanged',
+    event: { pending: true },
+    expected: true
+  },
+  {
+    name: 'useBatteryOptimizationStatus',
+    hook: useBatteryOptimizationStatus,
+    slot: 'onBatteryOptimizationStatusChanged',
+    event: { status: 'unrestricted' },
+    expected: 'unrestricted'
+  }
+]
+
+describe.each(wirings)('$name', ({ hook, slot, event, expected }) => {
+  it(`reads $slot`, () => {
+    // A slot nothing claimed means the emitter assigns a different property
+    // than the one named here — the hook would never update in production.
+    expect(slots.has(slot)).toBe(true)
+
+    const { result } = renderHook(() => hook())
+    act(() => slots.get(slot)!(event))
+    expect(result.current).toEqual(expected)
+  })
+})
+
+describe('hook wiring table', () => {
+  it('covers every delegating hook exactly once', () => {
+    const names = wirings.map((w) => w.name)
+    expect(new Set(names).size).toBe(names.length)
+    expect(new Set(wirings.map((w) => w.slot)).size).toBe(wirings.length)
+  })
+})

package/src/features/index.ts

@@ -12,7 +12,9 @@ export * from './playback'
 export * from './player'
 export * from './queue'
 export * from './battery'
+export * from './gate'
 export * from './browser'
+export * from './carConnection'
 export * from './equalizer'
 export * from './errors'
 export * from './favorites'

package/src/features/metadata.ts

@@ -1,18 +1,8 @@
-import type { Rating } from './rating'
 import { nativeBrowser } from '../native'
 import { NativeUpdatedValue } from '../utils/NativeUpdatedValue'
 
 // MARK: - Types
 
-export type RatingType =
-  | 'heart'
-  | 'thumbs-up-down'
-  | 'three-stars'
-  | 'four-stars'
-  | 'five-stars'
-  | 'percentage'
-  | 'none'
-
 export interface TrackMetadataBase {
   /** The track title */
   title?: string
@@ -30,8 +20,6 @@ export interface TrackMetadataBase {
   mediaId?: string
   /** The track genre */
   genre?: string
-  /** The track rating */
-  rating?: Rating
 }
 
 export interface NowPlayingMetadata extends TrackMetadataBase {
@@ -48,6 +36,12 @@ export type NowPlayingUpdate = {
   title?: string
   /** Artist shown in notification */
   artist?: string
+  /**
+   * Album line, on surfaces that render one (CarPlay's third line, some
+   * Bluetooth head units). Never shown on the iOS lock screen or the Android
+   * notification.
+   */
+  album?: string
 }
 
 /**
@@ -104,8 +98,13 @@ export interface ChapterMetadata {
 
 /**
  * Subscribes to chapter metadata events.
+ *
+ * @platform ios android
+ * Never fires on web — the web player does not read chapter markers. See
+ * {@link https://github.com/radio-garden/react-native-audio-browser/issues/118 | #118}.
+ *
  * @param callback - Called when chapter metadata is received
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onChapterMetadata = NativeUpdatedValue.emitterize<
   ChapterMetadata[]
@@ -113,8 +112,13 @@ export const onChapterMetadata = NativeUpdatedValue.emitterize<
 
 /**
  * Subscribes to track metadata events.
+ *
+ * @platform ios android
+ * Never fires on web — the web player does not read embedded file tags. See
+ * {@link https://github.com/radio-garden/react-native-audio-browser/issues/118 | #118}.
+ *
  * @param callback - Called when static track metadata is received
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onTrackMetadata = NativeUpdatedValue.emitterize<TrackMetadata>(
   (cb) => (nativeBrowser.onTrackMetadata = cb)
@@ -122,8 +126,15 @@ export const onTrackMetadata = NativeUpdatedValue.emitterize<TrackMetadata>(
 
 /**
  * Subscribes to timed metadata events (ICY/ID3 from live streams).
+ *
+ * @platform ios android
+ * Never fires on web. ICY metadata is stripped by the browser before the player
+ * can see it, and no browser API exposes it; in-band ID3 from HLS is reachable
+ * but not yet wired. See
+ * {@link https://github.com/radio-garden/react-native-audio-browser/issues/118 | #118}.
+ *
  * @param callback - Called when stream metadata is received (title, artist from ICY/ID3 tags)
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onTimedMetadata = NativeUpdatedValue.emitterize<TimedMetadata>(
   (cb) => (nativeBrowser.onTimedMetadata = cb)

package/src/features/network.ts

@@ -17,7 +17,7 @@ export function getOnline(): boolean {
 /**
  * Subscribes to network connectivity changes.
  * @param callback - Called when network state changes
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onOnlineChanged = NativeUpdatedValue.emitterize<boolean>(
   (cb) => (nativeBrowser.onOnlineChanged = cb)

package/src/features/nowPlaying.ts

@@ -32,13 +32,49 @@ export function getNowPlaying(): NowPlayingMetadata | undefined {
   return nativeBrowser.getNowPlaying() ?? undefined
 }
 
+/**
+ * Temporarily replaces now-playing fields for `durationMs`, then reverts to
+ * the live metadata. The flash outranks the now-playing formatter and the
+ * `updateNowPlaying` override while active (live metadata can't stomp it),
+ * and the revert runs on a native timer — JS timers pause in a backgrounded
+ * host (the lock screen case) — so it fires reliably. A track change clears
+ * the flash early; repeated calls restart the window.
+ *
+ * The feedback channel for refused remote commands: external surfaces have
+ * no toast primitive, so a transient metadata swap is the only way to talk
+ * to the user there.
+ *
+ * @example
+ * ```ts
+ * // A radio product with an hourly skip allowance:
+ * handleRemoteNext(() => {
+ *   if (skipsRemaining() > 0) skipToNext()
+ *   else flashNowPlaying({ artist: 'Skip limit reached' }, 3000)
+ * })
+ * ```
+ */
+export function flashNowPlaying(
+  update: NowPlayingUpdate,
+  durationMs: number
+): void {
+  nativeBrowser.flashNowPlaying(update, durationMs)
+}
+
+/**
+ * Clears an active flash immediately, reverting to the live metadata.
+ * No-op when no flash is active.
+ */
+export function clearNowPlayingFlash(): void {
+  nativeBrowser.clearNowPlayingFlash()
+}
+
 // MARK: - Event Callbacks
 
 /**
  * Subscribes to now playing metadata change events.
  * Fires when updateNowPlaying is called or when the track changes.
  * @param callback - Called when now playing metadata changes
- * @returns Cleanup function to unsubscribe
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
 export const onNowPlayingChanged =
   NativeUpdatedValue.emitterize<NowPlayingMetadata>(

package/src/features/output.ts

@@ -1,50 +1,63 @@
-import type { IosOutput, IosOutputType } from '../specs/audio-browser.nitro'
+import type { Output, OutputType } from '../specs/audio-browser.nitro'
 import { nativeBrowser } from '../native'
 import { NativeUpdatedValue } from '../utils/NativeUpdatedValue'
 import { useNativeUpdatedValue } from '../utils/useNativeUpdatedValue'
 
-export type { IosOutput, IosOutputType }
+export type { Output, OutputType }
 
 // MARK: - Actions
 
 /**
- * Opens the system output picker (iOS only).
- * Allows users to select output device (speaker, AirPlay, Bluetooth, etc.).
- * No-op on Android.
+ * Presents the system audio output switcher so the listener can move playback to
+ * another output. Cross-platform:
+ * - **iOS** — the system route picker (Bluetooth, AirPlay / Sonos-via-AirPlay,
+ *   speaker). Always available.
+ * - **Android** — the system Output Switcher (Bluetooth / speaker / Cast list) on
+ *   Android 11+. No-op on older Android — gate on {@link supportsOutputSwitcher}.
+ * - **Web** — no-op.
  */
-export function openIosOutputPicker(): void {
-  nativeBrowser.openIosOutputPicker()
+export function openOutputPicker(): void {
+  nativeBrowser.openOutputPicker()
+}
+
+/**
+ * Whether {@link openOutputPicker} can present a switcher on this device — use it
+ * to decide whether to surface the output control in your UI.
+ * `true` on iOS and Android 11+ (API 30); `false` on older Android and web.
+ */
+export function supportsOutputSwitcher(): boolean {
+  return nativeBrowser.supportsOutputSwitcher()
 }
 
 // MARK: - Getters
 
 /**
- * Gets the current audio output info.
- * Always returns a value on iOS, undefined on Android.
+ * The current audio output, or `undefined` when unknown. iOS reports one while a
+ * session is active; Android reports the active output route via AudioManager
+ * (the `type` is coarse — e.g. wired headphones may report as `speaker`). Guard
+ * for `undefined`.
  */
-export function getIosOutput(): IosOutput | undefined {
-  return nativeBrowser.getIosOutput()
+export function getOutput(): Output | undefined {
+  return nativeBrowser.getOutput()
 }
 
 // MARK: - Event Callbacks
 
 /**
- * Subscribes to output state changes (iOS only).
- * Never fires on Android.
- * @param callback - Called with output info when output changes
- * @returns Cleanup function to unsubscribe
+ * Subscribes to current-output changes (headphones unplugged, Bluetooth speaker
+ * connected, AirPlay/route selected). Fires on iOS and Android 11+; never below.
+ * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
  */
-export const onIosOutputChanged = NativeUpdatedValue.emitterize<IosOutput>(
-  (cb) => (nativeBrowser.onIosOutputChanged = cb)
+export const onOutputChanged = NativeUpdatedValue.emitterize<Output>(
+  (cb) => (nativeBrowser.onOutputChanged = cb)
 )
 
 // MARK: - Hooks
 
 /**
- * Hook that returns the current audio output info.
- * Updates when the output changes (e.g., AirPods connected/disconnected).
- * Always returns a value on iOS, undefined on Android.
+ * Reactive current audio output; re-renders when it changes (e.g. AirPods
+ * connect, a Bluetooth speaker is selected). `undefined` when unknown.
  */
-export function useIosOutput(): IosOutput | undefined {
-  return useNativeUpdatedValue(getIosOutput, onIosOutputChanged)
+export function useOutput(): Output | undefined {
+  return useNativeUpdatedValue(getOutput, onOutputChanged)
 }

package/src/features/playback/controls.ts

@@ -57,6 +57,14 @@ export function seekTo(position: number): void {
   nativeBrowser.seekTo(position)
 }
 
+/**
+ * Jump to the live edge of the current track. No-op for non-live tracks; for
+ * live, seeks to the window end (HLS) or reconnects (non-seekable streams).
+ */
+export function seekToLiveEdge(): void {
+  nativeBrowser.seekToLiveEdge()
+}
+
 /**
  * Seeks by a relative time offset in the current track.
  * @param offset - The time offset to seek by in seconds.

package/src/features/playback/index.ts

@@ -3,5 +3,6 @@ export * from './state'
 export * from './playing'
 export * from './playWhenReady'
 export * from './progress'
+export * from './trackPlaybackTime'
 export * from './rate'
 export * from './volume'