react-native-nitro-player 1.4.3 → 1.5.0-alpha.0

package/ios/core/TrackPlayerCore.swift

@@ -57,6 +57,10 @@ class TrackPlayerCore: NSObject {
   internal let preloadQueue = DispatchQueue(label: "com.nitroplayer.preload", qos: .utility)
   internal var didRequestUrlsForCurrentItem = false
 
+  // Follows http→https redirects that AVURLAsset otherwise silently drops (issue #111).
+  // Attached as the resource-loader delegate for cleartext-http assets only.
+  internal let redirectResolver = TrackPlayerRedirectResolver()
+
   // MARK: - Stall & network recovery
   // Whether the user/app wants playback ongoing (true after play(), false after pause()).
   internal var intendedToPlay = false
@@ -99,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()
@@ -112,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)
     }
   }
 
@@ -191,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 }
@@ -216,6 +241,7 @@ class TrackPlayerCore: NSObject {
       self.pathMonitor = nil
       self.preloadedAssets.removeAll()
       self.failedItemRetryCounts.removeAll()
+      self.redirectResolver.clear()
     }
   }
 

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
 
@@ -389,6 +410,20 @@ extension TrackPlayerCore {
     return options
   }
 
+  /// Builds the AVURLAsset for a track URL. Cleartext-`http` remote URLs are routed through
+  /// `redirectResolver` so AVFoundation follows http→https redirects it would otherwise drop
+  /// (issue #111). HTTPS and local URLs load natively, unchanged.
+  func makeAsset(for track: TrackItem, url: URL, isLocal: Bool) -> AVURLAsset {
+    let options = assetOptions(for: track, isLocal: isLocal)
+    guard !isLocal, let wrappedURL = TrackPlayerRedirectResolver.wrap(url) else {
+      return AVURLAsset(url: url, options: options)
+    }
+    redirectResolver.registerHeaders(httpHeaders(for: track), for: wrappedURL)
+    let asset = AVURLAsset(url: wrappedURL, options: options)
+    asset.resourceLoader.setDelegate(redirectResolver, queue: redirectResolver.queue)
+    return asset
+  }
+
   /// Creates a gapless-optimized AVPlayerItem with proper buffering configuration
   func createGaplessPlayerItem(for track: TrackItem, isPreload: Bool = false) -> AVPlayerItem? {
     let effectiveUrlString = DownloadManagerCore.shared.getEffectiveUrl(track: track)
@@ -427,7 +462,7 @@ extension TrackPlayerCore {
       asset = preloadedAsset
       NitroPlayerLogger.log("TrackPlayerCore", "🚀 Using preloaded asset for \(track.title)")
     } else {
-      asset = AVURLAsset(url: url, options: assetOptions(for: track, isLocal: isLocal))
+      asset = makeAsset(for: track, url: url, isLocal: isLocal)
     }
 
     let item = AVPlayerItem(asset: asset)
@@ -492,7 +527,7 @@ extension TrackPlayerCore {
           url = remoteUrl
         }
 
-        let asset = AVURLAsset(url: url, options: self.assetOptions(for: track, isLocal: isLocal))
+        let asset = self.makeAsset(for: track, url: url, isLocal: isLocal)
 
         asset.loadValuesAsynchronously(forKeys: Constants.preloadAssetKeys) { [weak self] in
           var allKeysLoaded = true

package/ios/core/TrackPlayerRedirectResolver.swift

@@ -0,0 +1,150 @@
+//
+//  TrackPlayerRedirectResolver.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla.
+//
+//  AVURLAsset does not reliably follow HTTP→HTTPS redirects: when a cleartext `http://`
+//  track URL answers with a 30x (e.g. a universal `308 → https://...` upgrade), AVFoundation
+//  silently drops the redirect and the item fails to load (issue #111). Unlike ExoPlayer's
+//  `setAllowCrossProtocolRedirects(true)`, AVFoundation exposes no such flag.
+//
+//  We work around it by giving such assets a sentinel URL scheme so AVFoundation has to ask
+//  this resource-loader delegate to load them. We then resolve the redirect chain ourselves
+//  with URLSession (which follows redirects) and hand AVFoundation a redirect to the final
+//  URL — after which it loads the media natively from the resolved location.
+//
+//  Only cleartext-`http` URLs are routed here. HTTPS assets are left untouched: AVFoundation
+//  follows same-scheme redirects on its own, so only the failing http path pays the extra
+//  resolution request. The app must still permit the initial cleartext connection via ATS
+//  (`NSAppTransportSecurity`); this delegate only fixes the redirect-following, not ATS.
+//
+
+import AVFoundation
+import Foundation
+
+final class TrackPlayerRedirectResolver: NSObject, AVAssetResourceLoaderDelegate {
+
+  /// Sentinel scheme prefix. A wrapped URL looks like `nitroredirect+http://host/path`.
+  private static let schemePrefix = "nitroredirect+"
+
+  /// Serial queue the resource-loader delegate methods (and our task bookkeeping) run on.
+  let queue = DispatchQueue(label: "com.nitroplayer.redirect", qos: .userInitiated)
+
+  private let session: URLSession
+
+  // In-flight resolution tasks, keyed by loading request, so a cancelled request cancels its
+  // task. Touched only on `queue` (delegate callbacks + the task completion is hopped onto it).
+  private var tasksByRequest: [ObjectIdentifier: URLSessionDataTask] = [:]
+
+  // Custom request headers (e.g. `Authorization`) per wrapped-URL, so the resolution request can
+  // authenticate when a server requires auth even to return the redirect. Written on the player
+  // queue (registerHeaders), read on `queue`; guarded by `headersLock`.
+  private var headersByURL: [String: [String: String]] = [:]
+  private let headersLock = NSLock()
+
+  override init() {
+    let config = URLSessionConfiguration.ephemeral
+    config.requestCachePolicy = .reloadIgnoringLocalCacheData
+    session = URLSession(configuration: config)
+    super.init()
+  }
+
+  // MARK: - URL wrapping
+
+  /// Wraps a cleartext-`http` URL in the sentinel scheme so AVFoundation routes it here.
+  /// Returns nil for anything else (https, file, custom schemes) — those load natively.
+  static func wrap(_ url: URL) -> URL? {
+    guard url.scheme?.lowercased() == "http",
+      var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+    else { return nil }
+    components.scheme = schemePrefix + "http"
+    return components.url
+  }
+
+  /// Restores the real URL from a sentinel-wrapped URL.
+  private static func unwrap(_ url: URL) -> URL? {
+    guard let scheme = url.scheme?.lowercased(), scheme.hasPrefix(schemePrefix),
+      var components = URLComponents(url: url, resolvingAgainstBaseURL: false)
+    else { return nil }
+    components.scheme = String(scheme.dropFirst(schemePrefix.count))
+    return components.url
+  }
+
+  // MARK: - Header registry
+
+  func registerHeaders(_ headers: [String: String]?, for wrappedURL: URL) {
+    guard let headers, !headers.isEmpty else { return }
+    headersLock.lock()
+    defer { headersLock.unlock() }
+    headersByURL[wrappedURL.absoluteString] = headers
+  }
+
+  /// Releases all registered headers. Call when the player is torn down.
+  func clear() {
+    headersLock.lock()
+    defer { headersLock.unlock() }
+    headersByURL.removeAll()
+  }
+
+  private func headers(for wrappedURL: URL) -> [String: String]? {
+    headersLock.lock()
+    defer { headersLock.unlock() }
+    return headersByURL[wrappedURL.absoluteString]
+  }
+
+  // MARK: - AVAssetResourceLoaderDelegate
+
+  func resourceLoader(
+    _ resourceLoader: AVAssetResourceLoader,
+    shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest
+  ) -> Bool {
+    guard let wrappedURL = loadingRequest.request.url,
+      let realURL = Self.unwrap(wrappedURL)
+    else { return false }
+
+    var request = URLRequest(url: realURL)
+    // HEAD is enough: we only need `response.url` after URLSession follows the redirect chain.
+    // Even if the resolved endpoint rejects HEAD (405), the post-redirect URL is still reported.
+    request.httpMethod = "HEAD"
+    headers(for: wrappedURL)?.forEach { request.setValue($1, forHTTPHeaderField: $0) }
+    loadingRequest.request.allHTTPHeaderFields?.forEach { request.setValue($1, forHTTPHeaderField: $0) }
+
+    let key = ObjectIdentifier(loadingRequest)
+    let task = session.dataTask(with: request) { [weak self] _, response, error in
+      self?.queue.async {
+        guard let self else { return }
+        self.tasksByRequest.removeValue(forKey: key)
+        guard !loadingRequest.isCancelled, !loadingRequest.isFinished else { return }
+
+        if let error {
+          NitroPlayerLogger.log("TrackPlayerCore", "❌ Redirect resolution failed for \(realURL): \(error.localizedDescription)")
+          loadingRequest.finishLoading(with: error)
+          return
+        }
+
+        // `response.url` is the final URL after URLSession followed all redirects.
+        let finalURL = response?.url ?? realURL
+        if finalURL != realURL {
+          NitroPlayerLogger.log("TrackPlayerCore", "↪️ Resolved redirect \(realURL) → \(finalURL)")
+        }
+        var redirect = URLRequest(url: finalURL)
+        self.headers(for: wrappedURL)?.forEach { redirect.setValue($1, forHTTPHeaderField: $0) }
+        loadingRequest.redirect = redirect
+        loadingRequest.response = HTTPURLResponse(
+          url: finalURL, statusCode: 302, httpVersion: "HTTP/1.1", headerFields: nil)
+        loadingRequest.finishLoading()
+      }
+    }
+    tasksByRequest[key] = task
+    task.resume()
+    return true
+  }
+
+  func resourceLoader(
+    _ resourceLoader: AVAssetResourceLoader,
+    didCancel loadingRequest: AVAssetResourceLoadingRequest
+  ) {
+    tasksByRequest.removeValue(forKey: ObjectIdentifier(loadingRequest))?.cancel()
+  }
+}

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,100 @@
+import React from 'react';
+import { Pressable, StyleSheet, 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 a broadcast signal (dot + two arcs) in the bottom-left corner.
+ * Drawn purely with `View`s so the library stays dependency-free.
+ */
+function CastGlyph({ size, color, }) {
+    const stroke = Math.max(1.5, Math.round(size * 0.083));
+    const inset = stroke;
+    const dotSize = stroke * 1.7;
+    const r1 = size * 0.28; // inner arc radius
+    const r2 = size * 0.46; // outer arc radius
+    return (React.createElement(View, { style: { width: size, height: size } },
+        React.createElement(View, { style: [
+                StyleSheet.absoluteFill,
+                {
+                    borderWidth: stroke,
+                    borderColor: color,
+                    borderRadius: Math.max(2, size * 0.12),
+                },
+            ] }),
+        React.createElement(View, { style: {
+                position: 'absolute',
+                left: inset,
+                bottom: inset,
+                width: dotSize,
+                height: dotSize,
+                borderRadius: dotSize / 2,
+                backgroundColor: color,
+            } }),
+        React.createElement(Arc, { origin: inset + dotSize / 2, radius: r1, stroke: stroke, color: color }),
+        React.createElement(Arc, { origin: inset + dotSize / 2, radius: r2, stroke: stroke, color: color })));
+}
+/**
+ * A quarter-circle arc (the top-right quadrant) centered at the bottom-left
+ * `origin` point. Produced by clipping a full bordered circle to one quadrant.
+ */
+function Arc({ origin, radius, stroke, color, }) {
+    return (React.createElement(View
+    // Clip box reveals only the quadrant facing up-and-right from the origin.
+    , { 
+        // Clip box reveals only the quadrant facing up-and-right from the origin.
+        style: {
+            position: 'absolute',
+            left: origin,
+            bottom: origin - radius,
+            width: radius,
+            height: radius,
+            overflow: 'hidden',
+        } },
+        React.createElement(View, { style: {
+                position: 'absolute',
+                left: -radius,
+                top: 0,
+                width: radius * 2,
+                height: radius * 2,
+                borderRadius: radius,
+                borderWidth: stroke,
+                borderColor: color,
+            } })));
+}

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;