react-native-nitro-player 1.4.4-alpha.0 → 1.5.0-alpha.1

package/ios/core/TrackPlayerCore.swift

@@ -103,6 +103,14 @@ class TrackPlayerCore: NSObject {
   internal let onProgressListeners            = ListenerRegistry<(Double, Double, Bool?) -> Void>()
   internal let onTracksNeedUpdateListeners    = ListenerRegistry<([TrackItem], Int) -> Void>()
   internal let onTemporaryQueueChangeListeners = ListenerRegistry<([TrackItem], [TrackItem]) -> Void>()
+  internal let onCastStateChangeListeners     = ListenerRegistry<(CastState, String?) -> Void>()
+
+  // MARK: - Google Cast
+  /// Owns the GoogleCast session; created on the main thread in init. Cast features
+  /// are inert no-ops if the GoogleCast SDK is not linked.
+  internal var castManager: CastSessionManager?
+  /// True while playback is routed to a Cast device (audio plays only on the device).
+  internal var isCasting = false
 
   // MARK: - Singleton
   static let shared = TrackPlayerCore()
@@ -116,8 +124,14 @@ class TrackPlayerCore: NSObject {
       self?.setupPlayer()
     }
     DispatchQueue.main.async { [weak self] in
-      self?.mediaSessionManager = MediaSessionManager()
-      self?.mediaSessionManager?.setTrackPlayerCore(self!)
+      guard let self else { return }
+      self.mediaSessionManager = MediaSessionManager()
+      self.mediaSessionManager?.setTrackPlayerCore(self)
+      // Initialize Cast with the Default Media Receiver. Apps can override the
+      // receiver ID early via Cast.configure(id). No-op without the GoogleCast SDK.
+      self.castManager = CastSessionManager()
+      self.castManager?.core = self
+      self.castManager?.configure(receiverApplicationId: nil)
     }
   }
 
@@ -195,6 +209,13 @@ class TrackPlayerCore: NSObject {
     onTemporaryQueueChangeListeners.remove(id: id)
   }
 
+  @discardableResult func addOnCastStateChangeListener(_ cb: @escaping (CastState, String?) -> Void) -> Int64 {
+    onCastStateChangeListeners.add(cb)
+  }
+  @discardableResult func removeOnCastStateChangeListener(id: Int64) -> Bool {
+    onCastStateChangeListeners.remove(id: id)
+  }
+
   // MARK: - Simple accessors
   func getCurrentPlaylistId() -> String? { currentPlaylistId }
   func getPlaylistManager() -> PlaylistManager { playlistManager }

package/ios/core/TrackPlayerPlayback.swift

@@ -12,22 +12,44 @@ import MediaPlayer
 extension TrackPlayerCore {
 
   func play() async {
+    if isCasting {
+      intendedToPlay = true
+      castManager?.play()
+      return
+    }
     await withPlayerQueueNoThrow { self.playInternal() }
   }
 
   func pause() async {
+    if isCasting {
+      intendedToPlay = false
+      castManager?.pause()
+      return
+    }
     await withPlayerQueueNoThrow { self.pauseInternal() }
   }
 
   func seek(position: Double) async {
+    if isCasting {
+      castManager?.seek(to: position)
+      return
+    }
     await withPlayerQueueNoThrow { self.seekInternal(position: position) }
   }
 
   func skipToNext() async {
+    if isCasting {
+      castManager?.skipToNext()
+      return
+    }
     await withPlayerQueueNoThrow { self.skipToNextInternal() }
   }
 
   func skipToPrevious() async {
+    if isCasting {
+      castManager?.skipToPrevious()
+      return
+    }
     await withPlayerQueueNoThrow { self.skipToPreviousInternal() }
   }
 
@@ -40,6 +62,11 @@ extension TrackPlayerCore {
   }
 
   func setVolume(volume: Double) async {
+    if isCasting {
+      let clamped = max(0.0, min(100.0, volume))
+      castManager?.setVolume(Float(clamped / 100.0))
+      return
+    }
     await withPlayerQueueNoThrow {
       let clamped = max(0.0, min(100.0, volume))
       let normalized = Float(clamped / 100.0)
@@ -65,6 +92,11 @@ extension TrackPlayerCore {
   }
 
   func setPlaybackSpeed(_ speed: Double) async {
+    if isCasting {
+      currentPlaybackSpeed = speed
+      castManager?.setPlaybackRate(Float(speed))
+      return
+    }
     await withPlayerQueueNoThrow {
       self.currentPlaybackSpeed = speed
       // Only update rate if currently playing; pause keeps rate at 0 until play() is called

package/ios/core/TrackPlayerQueue.swift

@@ -19,7 +19,14 @@ extension TrackPlayerCore {
   }
 
   func skipToIndex(index: Int) async -> Bool {
-    await withPlayerQueueNoThrow { self.skipToIndexInternal(index: index) }
+    if isCasting {
+      return await withPlayerQueueNoThrow {
+        guard index >= 0 && index < self.getActualQueueInternal().count else { return false }
+        self.castManager?.jump(toQueueIndex: index)
+        return true
+      }
+    }
+    return await withPlayerQueueNoThrow { self.skipToIndexInternal(index: index) }
   }
 
   func playFromIndex(index: Int) async {

package/ios/core/TrackPlayerQueueBuild.swift

@@ -12,6 +12,16 @@ import Foundation
 extension TrackPlayerCore {
 
   func updatePlayerQueue(tracks: [TrackItem]) {
+    // While casting, mirror the new queue to the Cast device instead of building
+    // the local AVQueuePlayer (which would start local audio).
+    if isCasting {
+      currentTracks = tracks
+      currentTrackIndex = 0
+      if let first = tracks.first { emitCastTrackChange(first) }
+      loadCastQueue(autoplay: intendedToPlay, position: 0)
+      return
+    }
+
     NitroPlayerLogger.log("TrackPlayerCore", "\n" + String(repeating: "=", count: Constants.separatorLineLength))
     NitroPlayerLogger.log("TrackPlayerCore", "📋 UPDATE PLAYER QUEUE - Received \(tracks.count) tracks")
     NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "=", count: Constants.separatorLineLength))
@@ -135,6 +145,17 @@ extension TrackPlayerCore {
     NitroPlayerLogger.log("TrackPlayerCore", "   Total tracks in playlist: \(self.currentTracks.count)")
     NitroPlayerLogger.log("TrackPlayerCore", "   Current index: \(self.currentTrackIndex), target index: \(index)")
 
+    // While casting, jump on the Cast device instead of rebuilding the local queue.
+    if isCasting {
+      self.playNextStack.removeAll()
+      self.upNextQueue.removeAll()
+      self.currentTemporaryType = .none
+      self.currentTrackIndex = index
+      if let track = self.getCurrentTrack() { self.emitCastTrackChange(track) }
+      self.loadCastQueue(autoplay: self.intendedToPlay, position: 0)
+      return true
+    }
+
     // Preserve playback state — only resume if already playing.
     let wasPlaying = self.player?.rate ?? 0 > 0
 

package/lib/components/CastButton.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import { type PressableProps, type StyleProp, type ViewStyle } from 'react-native';
+import type { CastState } from '../specs/Cast.nitro';
+export interface CastButtonProps extends Omit<PressableProps, 'children'> {
+    /** Icon size in points. Defaults to `24`. */
+    size?: number;
+    /** Glyph color when not connected. Defaults to `#000000`. */
+    color?: string;
+    /** Glyph color while connecting / connected. Defaults to `#1E88E5`. */
+    activeColor?: string;
+    /** Style applied to the pressable container. */
+    style?: StyleProp<ViewStyle>;
+    /**
+     * Hide the button entirely when no Cast devices are available on the network,
+     * matching standard platform Cast-button behaviour. Defaults to `true`.
+     */
+    hideWhenNoDevices?: boolean;
+    /**
+     * Render a custom icon instead of the built-in Cast glyph. Receives the live
+     * connection state so you can theme it yourself.
+     */
+    renderIcon?: (info: {
+        state: CastState;
+        isCasting: boolean;
+        size: number;
+        color: string;
+    }) => React.ReactNode;
+}
+/**
+ * A ready-to-use Google Cast button.
+ *
+ * Reflects the live connection state, hides itself when no devices are available
+ * (configurable), and presents the native Cast dialog on press. For full control
+ * over the icon, pass `renderIcon`; for custom press handling, pass `onPress`
+ * (the default opens the system Cast picker).
+ *
+ * @example
+ * ```tsx
+ * import { CastButton } from 'react-native-nitro-player'
+ *
+ * <CastButton size={28} activeColor="#1DB954" />
+ * ```
+ */
+export declare function CastButton({ size, color, activeColor, hideWhenNoDevices, renderIcon, onPress, style, ...rest }: CastButtonProps): React.ReactElement | null;

package/lib/components/CastButton.js

@@ -0,0 +1,125 @@
+import React from 'react';
+import { Pressable, View, } from 'react-native';
+import { Cast } from '../index';
+import { useCastState } from '../hooks/useCastState';
+/**
+ * A ready-to-use Google Cast button.
+ *
+ * Reflects the live connection state, hides itself when no devices are available
+ * (configurable), and presents the native Cast dialog on press. For full control
+ * over the icon, pass `renderIcon`; for custom press handling, pass `onPress`
+ * (the default opens the system Cast picker).
+ *
+ * @example
+ * ```tsx
+ * import { CastButton } from 'react-native-nitro-player'
+ *
+ * <CastButton size={28} activeColor="#1DB954" />
+ * ```
+ */
+export function CastButton({ size = 24, color = '#000000', activeColor = '#1E88E5', hideWhenNoDevices = true, renderIcon, onPress, style, ...rest }) {
+    const { state, isCasting } = useCastState();
+    if (hideWhenNoDevices && state === 'no_devices_available') {
+        return null;
+    }
+    const active = state === 'connected' || state === 'connecting';
+    const glyphColor = active ? activeColor : color;
+    const handlePress = (event) => {
+        if (onPress) {
+            onPress(event);
+            return;
+        }
+        try {
+            Cast.showCastPicker();
+        }
+        catch (error) {
+            console.error('[CastButton] Failed to present cast picker:', error);
+        }
+    };
+    return (React.createElement(Pressable, { accessibilityRole: "button", accessibilityLabel: isCasting ? 'Casting' : 'Cast', accessibilityState: { selected: isCasting }, hitSlop: 8, onPress: handlePress, style: style, ...rest }, renderIcon ? (renderIcon({ state, isCasting, size, color: glyphColor })) : (React.createElement(CastGlyph, { size: size, color: glyphColor }))));
+}
+/**
+ * Dependency-free rendition of the standard Cast glyph: a rounded "screen"
+ * rectangle (with its bottom-left corner open) and a broadcast signal — a dot
+ * and two concentric arcs — radiating from the bottom-left. Drawn purely with
+ * `View`s so the library stays dependency-free.
+ */
+function CastGlyph({ size, color, }) {
+    const stroke = Math.max(1.5, Math.round(size / 13));
+    const inset = Math.round(size * 0.14);
+    const dotSize = stroke * 1.5;
+    // Origin of the broadcast signal — the screen's bottom-left corner.
+    const cx = inset + stroke / 2;
+    const cy = size - inset - stroke / 2;
+    // Leave the screen's bottom-left corner open so the signal reads clearly.
+    const gap = size * 0.46;
+    return (React.createElement(View, { style: { width: size, height: size } },
+        React.createElement(View, { style: {
+                position: 'absolute',
+                left: inset,
+                top: inset,
+                right: inset,
+                height: stroke,
+                backgroundColor: color,
+                borderRadius: stroke,
+            } }),
+        React.createElement(View, { style: {
+                position: 'absolute',
+                top: inset,
+                bottom: inset,
+                right: inset,
+                width: stroke,
+                backgroundColor: color,
+                borderRadius: stroke,
+            } }),
+        React.createElement(View, { style: {
+                position: 'absolute',
+                left: inset + gap,
+                bottom: inset,
+                right: inset,
+                height: stroke,
+                backgroundColor: color,
+                borderRadius: stroke,
+            } }),
+        React.createElement(View, { style: {
+                position: 'absolute',
+                left: inset,
+                top: inset,
+                height: size - 2 * inset - gap,
+                width: stroke,
+                backgroundColor: color,
+                borderRadius: stroke,
+            } }),
+        React.createElement(RippleArc, { cx: cx, cy: cy, radius: size * 0.2, stroke: stroke, color: color }),
+        React.createElement(RippleArc, { cx: cx, cy: cy, radius: size * 0.34, stroke: stroke, color: color }),
+        React.createElement(View, { style: {
+                position: 'absolute',
+                left: cx - dotSize / 2,
+                top: cy - dotSize / 2,
+                width: dotSize,
+                height: dotSize,
+                borderRadius: dotSize / 2,
+                backgroundColor: color,
+            } })));
+}
+/**
+ * A quarter-circle arc (the up-right quadrant) centered at (cx, cy). Rendered as
+ * a circle with only its top border colored, rotated 45° so the visible cap
+ * faces up-and-to-the-right — i.e. radiating from the bottom-left dot.
+ */
+function RippleArc({ cx, cy, radius, stroke, color, }) {
+    return (React.createElement(View, { style: {
+            position: 'absolute',
+            left: cx - radius,
+            top: cy - radius,
+            width: radius * 2,
+            height: radius * 2,
+            borderRadius: radius,
+            borderWidth: stroke,
+            borderTopColor: color,
+            borderRightColor: 'transparent',
+            borderBottomColor: 'transparent',
+            borderLeftColor: 'transparent',
+            transform: [{ rotate: '45deg' }],
+        } }));
+}

package/lib/hooks/castCallbackManager.d.ts

@@ -0,0 +1,19 @@
+import type { CastState } from '../specs/Cast.nitro';
+type CastStateCallback = (state: CastState, deviceName: string | null) => void;
+/**
+ * Internal subscription manager that allows multiple hooks/components to
+ * subscribe to the single native `Cast.onCastStateChange` callback without
+ * overwriting each other. Mirrors {@link callbackManager}.
+ */
+declare class CastCallbackSubscriptionManager {
+    private castStateSubscribers;
+    private isCastStateRegistered;
+    /**
+     * Subscribe to Cast connection state changes.
+     * @returns Unsubscribe function
+     */
+    subscribeToCastState(callback: CastStateCallback): () => void;
+    private ensureCastStateRegistered;
+}
+export declare const castCallbackManager: CastCallbackSubscriptionManager;
+export {};

package/lib/hooks/castCallbackManager.js

@@ -0,0 +1,43 @@
+import { Cast } from '../index';
+/**
+ * Internal subscription manager that allows multiple hooks/components to
+ * subscribe to the single native `Cast.onCastStateChange` callback without
+ * overwriting each other. Mirrors {@link callbackManager}.
+ */
+class CastCallbackSubscriptionManager {
+    castStateSubscribers = new Set();
+    isCastStateRegistered = false;
+    /**
+     * Subscribe to Cast connection state changes.
+     * @returns Unsubscribe function
+     */
+    subscribeToCastState(callback) {
+        this.castStateSubscribers.add(callback);
+        this.ensureCastStateRegistered();
+        return () => {
+            this.castStateSubscribers.delete(callback);
+        };
+    }
+    ensureCastStateRegistered() {
+        if (this.isCastStateRegistered)
+            return;
+        try {
+            Cast.onCastStateChange((state, deviceName) => {
+                this.castStateSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(state, deviceName);
+                    }
+                    catch (error) {
+                        console.error('[CastCallbackManager] Error in cast state subscriber:', error);
+                    }
+                });
+            });
+            this.isCastStateRegistered = true;
+        }
+        catch (error) {
+            console.error('[CastCallbackManager] Failed to register cast state callback:', error);
+        }
+    }
+}
+// Export singleton instance
+export const castCallbackManager = new CastCallbackSubscriptionManager();

package/lib/hooks/index.d.ts

@@ -11,6 +11,9 @@ export { usePlaylist } from './usePlaylist';
 export type { UsePlaylistResult } from './usePlaylist';
 export { useActualQueue } from './useActualQueue';
 export type { UseActualQueueResult } from './useActualQueue';
+export { useIsCasting } from './useIsCasting';
+export { useCastState } from './useCastState';
+export type { UseCastStateResult } from './useCastState';
 export { useDownloadProgress } from './useDownloadProgress';
 export type { UseDownloadProgressOptions, UseDownloadProgressResult, } from './useDownloadProgress';
 export { useDownloadedTracks } from './useDownloadedTracks';

package/lib/hooks/index.js

@@ -7,6 +7,9 @@ export { useAudioDevices } from './useAudioDevices';
 export { useNowPlaying } from './useNowPlaying';
 export { usePlaylist } from './usePlaylist';
 export { useActualQueue } from './useActualQueue';
+// Cast hooks
+export { useIsCasting } from './useIsCasting';
+export { useCastState } from './useCastState';
 // Download hooks
 export { useDownloadProgress } from './useDownloadProgress';
 export { useDownloadedTracks } from './useDownloadedTracks';

package/lib/hooks/useCastState.d.ts

@@ -0,0 +1,27 @@
+import type { CastState } from '../specs/Cast.nitro';
+export interface UseCastStateResult {
+    /** The current Cast connection state. */
+    state: CastState;
+    /** Friendly name of the connected device, or `null` when not connected. */
+    deviceName: string | null;
+    /** Convenience flag, equivalent to `state === 'connected'`. */
+    isCasting: boolean;
+    /** Whether the initial state has been read from native. */
+    isReady: boolean;
+}
+/**
+ * Hook to subscribe to the full Google Cast connection state.
+ *
+ * Provides the connection {@link CastState}, the connected device name, and a
+ * convenience `isCasting` flag. For a simple boolean prefer {@link useIsCasting}.
+ *
+ * @example
+ * ```tsx
+ * function CastStatus() {
+ *   const { state, deviceName, isCasting } = useCastState()
+ *   if (!isCasting) return null
+ *   return <Text>Casting to {deviceName} ({state})</Text>
+ * }
+ * ```
+ */
+export declare function useCastState(): UseCastStateResult;

package/lib/hooks/useCastState.js

@@ -0,0 +1,49 @@
+import { useEffect, useRef, useState } from 'react';
+import { Cast } from '../index';
+import { castCallbackManager } from './castCallbackManager';
+/**
+ * Hook to subscribe to the full Google Cast connection state.
+ *
+ * Provides the connection {@link CastState}, the connected device name, and a
+ * convenience `isCasting` flag. For a simple boolean prefer {@link useIsCasting}.
+ *
+ * @example
+ * ```tsx
+ * function CastStatus() {
+ *   const { state, deviceName, isCasting } = useCastState()
+ *   if (!isCasting) return null
+ *   return <Text>Casting to {deviceName} ({state})</Text>
+ * }
+ * ```
+ */
+export function useCastState() {
+    const [state, setState] = useState('not_connected');
+    const [deviceName, setDeviceName] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    const isMounted = useRef(true);
+    useEffect(() => {
+        isMounted.current = true;
+        // Seed from current native state.
+        try {
+            setState(Cast.getCastState());
+            setDeviceName(Cast.getCastDeviceName());
+        }
+        catch (error) {
+            console.error('[useCastState] Failed to read initial cast state:', error);
+        }
+        finally {
+            setIsReady(true);
+        }
+        const unsubscribe = castCallbackManager.subscribeToCastState((newState, newDeviceName) => {
+            if (isMounted.current) {
+                setState(newState);
+                setDeviceName(newDeviceName);
+            }
+        });
+        return () => {
+            isMounted.current = false;
+            unsubscribe();
+        };
+    }, []);
+    return { state, deviceName, isCasting: state === 'connected', isReady };
+}

package/lib/hooks/useIsCasting.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hook that returns whether playback is currently routed to a Google Cast device.
+ *
+ * Updates in real time as Cast sessions start and end. Initializes synchronously
+ * from the native player's current state.
+ *
+ * @returns `true` while connected to a Cast device, otherwise `false`.
+ *
+ * @example
+ * ```tsx
+ * function NowPlaying() {
+ *   const isCasting = useIsCasting()
+ *   return <Text>{isCasting ? 'Casting' : 'Playing locally'}</Text>
+ * }
+ * ```
+ */
+export declare function useIsCasting(): boolean;

package/lib/hooks/useIsCasting.js

@@ -0,0 +1,43 @@
+import { useEffect, useRef, useState } from 'react';
+import { Cast } from '../index';
+import { castCallbackManager } from './castCallbackManager';
+/**
+ * Hook that returns whether playback is currently routed to a Google Cast device.
+ *
+ * Updates in real time as Cast sessions start and end. Initializes synchronously
+ * from the native player's current state.
+ *
+ * @returns `true` while connected to a Cast device, otherwise `false`.
+ *
+ * @example
+ * ```tsx
+ * function NowPlaying() {
+ *   const isCasting = useIsCasting()
+ *   return <Text>{isCasting ? 'Casting' : 'Playing locally'}</Text>
+ * }
+ * ```
+ */
+export function useIsCasting() {
+    const [isCasting, setIsCasting] = useState(() => {
+        try {
+            return Cast.isCasting();
+        }
+        catch {
+            return false;
+        }
+    });
+    const isMounted = useRef(true);
+    useEffect(() => {
+        isMounted.current = true;
+        const unsubscribe = castCallbackManager.subscribeToCastState((state) => {
+            if (isMounted.current) {
+                setIsCasting(state === 'connected');
+            }
+        });
+        return () => {
+            isMounted.current = false;
+            unsubscribe();
+        };
+    }, []);
+    return isCasting;
+}

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import type { PlayerQueue as PlayerQueueType, TrackPlayer as TrackPlayerType } f
 import type { AndroidAutoMediaLibrary as AndroidAutoMediaLibraryType } from './specs/AndroidAutoMediaLibrary.nitro';
 import type { AudioDevices as AudioDevicesType } from './specs/AudioDevices.nitro';
 import type { AudioRoutePicker as AudioRoutePickerType } from './specs/AudioRoutePicker.nitro';
+import type { Cast as CastType } from './specs/Cast.nitro';
 import type { DownloadManager as DownloadManagerType } from './specs/DownloadManager.nitro';
 import type { Equalizer as EqualizerType } from './specs/Equalizer.nitro';
 export declare const PlayerQueue: PlayerQueueType;
@@ -9,9 +10,13 @@ export declare const TrackPlayer: TrackPlayerType;
 export declare const AndroidAutoMediaLibrary: AndroidAutoMediaLibraryType | null;
 export declare const AudioDevices: AudioDevicesType | null;
 export declare const AudioRoutePicker: AudioRoutePickerType | null;
+export declare const Cast: CastType;
 export declare const DownloadManager: DownloadManagerType;
 export declare const Equalizer: EqualizerType;
 export * from './hooks';
+export { CastButton } from './components/CastButton';
+export type { CastButtonProps } from './components/CastButton';
+export type { CastState } from './specs/Cast.nitro';
 export * from './types/PlayerQueue';
 export * from './types/AndroidAutoMediaLibrary';
 export * from './types/DownloadTypes';

package/lib/index.js

@@ -15,13 +15,16 @@ export const AudioDevices = Platform.OS === 'android'
 export const AudioRoutePicker = Platform.OS === 'ios'
     ? NitroModules.createHybridObject('AudioRoutePicker')
     : null;
+// Google Cast (iOS + Android)
+export const Cast = NitroModules.createHybridObject('Cast');
 // Download Manager
 export const DownloadManager = NitroModules.createHybridObject('DownloadManager');
 // Equalizer
 export const Equalizer = NitroModules.createHybridObject('Equalizer');
 // Export hooks
 export * from './hooks';
-// Export types
+// Export components
+export { CastButton } from './components/CastButton';
 export * from './types/PlayerQueue';
 export * from './types/AndroidAutoMediaLibrary';
 export * from './types/DownloadTypes';

package/lib/specs/Cast.nitro.d.ts

@@ -0,0 +1,58 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * The current Google Cast connection state.
+ *
+ * - `no_devices_available`: No Cast devices are discoverable on the network.
+ *   The Cast button is typically hidden in this state.
+ * - `not_connected`: Cast devices are available but none is connected.
+ * - `connecting`: A session is being established with a device.
+ * - `connected`: A session is active and playback is routed to the device.
+ */
+export type CastState = 'no_devices_available' | 'not_connected' | 'connecting' | 'connected';
+/**
+ * Google Cast control surface.
+ *
+ * Casting is implemented as an internal playback backend swap inside the native
+ * player core: when a session is `connected`, every playback operation (play,
+ * pause, seek, skip, queue) is routed to the remote Cast device and local audio
+ * is suppressed automatically. The existing {@link TrackPlayer} API keeps
+ * working unchanged — this object only exposes the Cast-specific surface.
+ */
+export interface Cast extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    /**
+     * Initialize the Cast framework. Must be called once early in app startup
+     * (before the first Cast interaction). Safe to call multiple times.
+     *
+     * @param receiverApplicationId Optional Web Receiver application ID registered
+     *   in the Google Cast Developer Console. When omitted, the platform Default
+     *   Media Receiver (`CC1AD845`) is used, which supports audio playback,
+     *   metadata and queues out of the box.
+     */
+    configure(receiverApplicationId?: string): Promise<void>;
+    /**
+     * Whether playback is currently routed to a Cast device.
+     * Equivalent to `getCastState() === 'connected'`.
+     */
+    isCasting(): boolean;
+    /** The current Cast connection state. */
+    getCastState(): CastState;
+    /** The friendly name of the connected device, or `null` when not connected. */
+    getCastDeviceName(): string | null;
+    /**
+     * Present the native Cast dialog. Shows the device chooser when not connected,
+     * or the cast controls / disconnect dialog when already connected. Mirrors the
+     * behaviour of the standard platform Cast button.
+     */
+    showCastPicker(): void;
+    /** End the current Cast session and resume local playback. No-op when not connected. */
+    endCastSession(): Promise<void>;
+    /**
+     * Register a callback fired whenever the Cast connection state changes.
+     * The callback receives the new {@link CastState} and the connected device
+     * name (or `null`).
+     */
+    onCastStateChange(callback: (state: CastState, deviceName: string | null) => void): void;
+}

package/lib/specs/Cast.nitro.js

@@ -0,0 +1 @@
+export {};