react-native-nitro-player 0.0.1 → 0.3.0-alpha.10

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec_cxx.swift

@@ -190,6 +190,46 @@ open class HybridTrackPlayerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func addToUpNext(trackId: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.addToUpNext(trackId: String(trackId))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func playNext(trackId: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.playNext(trackId: String(trackId))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getActualQueue() -> bridge.Result_std__vector_TrackItem__ {
+    do {
+      let __result = try self.__implementation.getActualQueue()
+      let __resultCpp = { () -> bridge.std__vector_TrackItem_ in
+        var __vector = bridge.create_std__vector_TrackItem_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_TrackItem__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_TrackItem__(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getState() -> bridge.Result_PlayerState_ {
     do {
@@ -202,6 +242,18 @@ open class HybridTrackPlayerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setRepeatMode(mode: Int32) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.setRepeatMode(mode: margelo.nitro.nitroplayer.RepeatMode(rawValue: mode)!)
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func configure(config: PlayerConfig) -> bridge.Result_void_ {
     do {
@@ -322,4 +374,16 @@ open class HybridTrackPlayerSpec_cxx {
       return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func setVolume(volume: Double) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.setVolume(volume: volume)
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/RepeatMode.swift

@@ -0,0 +1,44 @@
+///
+/// RepeatMode.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `RepeatMode`, backed by a C++ enum.
+ */
+public typealias RepeatMode = margelo.nitro.nitroplayer.RepeatMode
+
+public extension RepeatMode {
+  /**
+   * Get a RepeatMode for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "off":
+        self = .off
+      case "Playlist":
+        self = .playlist
+      case "track":
+        self = .track
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this RepeatMode represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .off:
+        return "off"
+      case .playlist:
+        return "Playlist"
+      case .track:
+        return "track"
+    }
+  }
+}

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.cpp

@@ -20,7 +20,11 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("skipToNext", &HybridTrackPlayerSpec::skipToNext);
       prototype.registerHybridMethod("skipToPrevious", &HybridTrackPlayerSpec::skipToPrevious);
       prototype.registerHybridMethod("seek", &HybridTrackPlayerSpec::seek);
+      prototype.registerHybridMethod("addToUpNext", &HybridTrackPlayerSpec::addToUpNext);
+      prototype.registerHybridMethod("playNext", &HybridTrackPlayerSpec::playNext);
+      prototype.registerHybridMethod("getActualQueue", &HybridTrackPlayerSpec::getActualQueue);
       prototype.registerHybridMethod("getState", &HybridTrackPlayerSpec::getState);
+      prototype.registerHybridMethod("setRepeatMode", &HybridTrackPlayerSpec::setRepeatMode);
       prototype.registerHybridMethod("configure", &HybridTrackPlayerSpec::configure);
       prototype.registerHybridMethod("onChangeTrack", &HybridTrackPlayerSpec::onChangeTrack);
       prototype.registerHybridMethod("onPlaybackStateChange", &HybridTrackPlayerSpec::onPlaybackStateChange);
@@ -28,6 +32,7 @@ namespace margelo::nitro::nitroplayer {
       prototype.registerHybridMethod("onPlaybackProgressChange", &HybridTrackPlayerSpec::onPlaybackProgressChange);
       prototype.registerHybridMethod("onAndroidAutoConnectionChange", &HybridTrackPlayerSpec::onAndroidAutoConnectionChange);
       prototype.registerHybridMethod("isAndroidAutoConnected", &HybridTrackPlayerSpec::isAndroidAutoConnected);
+      prototype.registerHybridMethod("setVolume", &HybridTrackPlayerSpec::setVolume);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.hpp

@@ -13,12 +13,14 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `PlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerState; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
-// Forward declaration of `TrackItem` to properly resolve imports.
-namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
@@ -26,9 +28,11 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 
 #include <string>
 #include <optional>
+#include "TrackItem.hpp"
+#include <vector>
 #include "PlayerState.hpp"
+#include "RepeatMode.hpp"
 #include "PlayerConfig.hpp"
-#include "TrackItem.hpp"
 #include "Reason.hpp"
 #include <functional>
 #include "TrackPlayerState.hpp"
@@ -70,7 +74,11 @@ namespace margelo::nitro::nitroplayer {
       virtual void skipToNext() = 0;
       virtual void skipToPrevious() = 0;
       virtual void seek(double position) = 0;
+      virtual void addToUpNext(const std::string& trackId) = 0;
+      virtual void playNext(const std::string& trackId) = 0;
+      virtual std::vector<TrackItem> getActualQueue() = 0;
       virtual PlayerState getState() = 0;
+      virtual bool setRepeatMode(RepeatMode mode) = 0;
       virtual void configure(const PlayerConfig& config) = 0;
       virtual void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) = 0;
       virtual void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) = 0;
@@ -78,6 +86,7 @@ namespace margelo::nitro::nitroplayer {
       virtual void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) = 0;
       virtual void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) = 0;
       virtual bool isAndroidAutoConnected() = 0;
+      virtual bool setVolume(double volume) = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/RepeatMode.hpp

@@ -0,0 +1,80 @@
+///
+/// RepeatMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::nitroplayer {
+
+  /**
+   * An enum which can be represented as a JavaScript union (RepeatMode).
+   */
+  enum class RepeatMode {
+    OFF      SWIFT_NAME(off) = 0,
+    PLAYLIST      SWIFT_NAME(playlist) = 1,
+    TRACK      SWIFT_NAME(track) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitroplayer
+
+namespace margelo::nitro {
+
+  // C++ RepeatMode <> JS RepeatMode (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroplayer::RepeatMode> final {
+    static inline margelo::nitro::nitroplayer::RepeatMode fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("off"): return margelo::nitro::nitroplayer::RepeatMode::OFF;
+        case hashString("Playlist"): return margelo::nitro::nitroplayer::RepeatMode::PLAYLIST;
+        case hashString("track"): return margelo::nitro::nitroplayer::RepeatMode::TRACK;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum RepeatMode - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitroplayer::RepeatMode arg) {
+      switch (arg) {
+        case margelo::nitro::nitroplayer::RepeatMode::OFF: return JSIConverter<std::string>::toJSI(runtime, "off");
+        case margelo::nitro::nitroplayer::RepeatMode::PLAYLIST: return JSIConverter<std::string>::toJSI(runtime, "Playlist");
+        case margelo::nitro::nitroplayer::RepeatMode::TRACK: return JSIConverter<std::string>::toJSI(runtime, "track");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert RepeatMode to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("off"):
+        case hashString("Playlist"):
+        case hashString("track"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.0.1",
+  "version": "0.3.0-alpha.10",
   "description": "react-native-nitro-player",
   "main": "lib/index",
   "module": "lib/index",
@@ -30,12 +30,14 @@
   "scripts": {
     "postinstall": "tsc || exit 0;",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf android/build node_modules/**/android/build lib",
+    "clean": "rm -rf android/build node_modules/**/android/build lib nitrogen tsconfig.tsbuildinfo",
     "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
     "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
     "typescript": "tsc",
-    "specs": "tsc --noEmit false && nitrogen --logLevel=\"debug\"",
-    "release": "release-it"
+    "specs": "tsc && nitrogen --logLevel=\"debug\"",
+    "copy-readme": "cp ../README.md README.md",
+    "release": "release-it",
+    "build": "bun run clean && bun run specs && bun run typescript && bun run copy-readme"
   },
   "keywords": [
     "react-native",
@@ -43,14 +45,14 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mrousavy/nitro.git"
+    "url": "git+https://github.com/riteshshukla04/react-native-nitro-player"
   },
-  "author": "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+  "author": "Ritesh Shukla <riteshshukla2381@gmail.com> (https://github.com/riteshshukla04)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/mrousavy/nitro/issues"
+    "url": "https://github.com/riteshshukla04/react-native-nitro-player/issues"
   },
-  "homepage": "https://github.com/mrousavy/nitro#readme",
+  "homepage": "https://github.com/riteshshukla04/react-native-nitro-player#readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -122,14 +124,13 @@
     "github": {
       "release": true
     },
+    "hooks": {
+      "before:release": "bun run clean && bun run specs && bun run typescript && bun run copy-readme"
+    },
     "plugins": {
       "@release-it/bumper": {
         "in": "package.json",
         "out": [
-          {
-            "file": "package.json",
-            "path": "version"
-          },
           {
             "file": "../package.json",
             "path": "version"

package/src/hooks/callbackManager.ts

@@ -0,0 +1,96 @@
+import { TrackPlayer } from '../index'
+import type { TrackItem, TrackPlayerState, Reason } from '../types/PlayerQueue'
+
+type PlaybackStateCallback = (state: TrackPlayerState, reason?: Reason) => void
+type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void
+
+/**
+ * Internal subscription manager that allows multiple hooks to subscribe
+ * to a single native callback. This solves the problem where registering
+ * a new callback overwrites the previous one.
+ */
+class CallbackSubscriptionManager {
+  private playbackStateSubscribers = new Set<PlaybackStateCallback>()
+  private trackChangeSubscribers = new Set<TrackChangeCallback>()
+  private isPlaybackStateRegistered = false
+  private isTrackChangeRegistered = false
+
+  /**
+   * Subscribe to playback state changes
+   * @returns Unsubscribe function
+   */
+  subscribeToPlaybackState(callback: PlaybackStateCallback): () => void {
+    this.playbackStateSubscribers.add(callback)
+    this.ensurePlaybackStateRegistered()
+
+    return () => {
+      this.playbackStateSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to track changes
+   * @returns Unsubscribe function
+   */
+  subscribeToTrackChange(callback: TrackChangeCallback): () => void {
+    this.trackChangeSubscribers.add(callback)
+    this.ensureTrackChangeRegistered()
+
+    return () => {
+      this.trackChangeSubscribers.delete(callback)
+    }
+  }
+
+  private ensurePlaybackStateRegistered(): void {
+    if (this.isPlaybackStateRegistered) return
+
+    try {
+      TrackPlayer.onPlaybackStateChange((state, reason) => {
+        this.playbackStateSubscribers.forEach((subscriber) => {
+          try {
+            subscriber(state, reason)
+          } catch (error) {
+            console.error(
+              '[CallbackManager] Error in playback state subscriber:',
+              error
+            )
+          }
+        })
+      })
+      this.isPlaybackStateRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register playback state callback:',
+        error
+      )
+    }
+  }
+
+  private ensureTrackChangeRegistered(): void {
+    if (this.isTrackChangeRegistered) return
+
+    try {
+      TrackPlayer.onChangeTrack((track, reason) => {
+        this.trackChangeSubscribers.forEach((subscriber) => {
+          try {
+            subscriber(track, reason)
+          } catch (error) {
+            console.error(
+              '[CallbackManager] Error in track change subscriber:',
+              error
+            )
+          }
+        })
+      })
+      this.isTrackChangeRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register track change callback:',
+        error
+      )
+    }
+  }
+}
+
+// Export singleton instance
+export const callbackManager = new CallbackSubscriptionManager()

package/src/hooks/index.ts

@@ -1,6 +1,13 @@
 export { useOnChangeTrack } from './useOnChangeTrack'
+export type { TrackChangeResult } from './useOnChangeTrack'
 export { useOnPlaybackStateChange } from './useOnPlaybackStateChange'
+export type { PlaybackStateResult } from './useOnPlaybackStateChange'
 export { useOnSeek } from './useOnSeek'
 export { useOnPlaybackProgressChange } from './useOnPlaybackProgressChange'
 export { useAndroidAutoConnection } from './useAndroidAutoConnection'
 export { useAudioDevices } from './useAudioDevices'
+export { useNowPlaying } from './useNowPlaying'
+export { usePlaylist } from './usePlaylist'
+export type { UsePlaylistResult } from './usePlaylist'
+export { useActualQueue } from './useActualQueue'
+export type { UseActualQueueResult } from './useActualQueue'

package/src/hooks/useActualQueue.ts

@@ -0,0 +1,116 @@
+import { useEffect, useState, useRef, useCallback } from 'react'
+import { TrackPlayer } from '../index'
+import { callbackManager } from './callbackManager'
+import type { TrackItem } from '../types/PlayerQueue'
+
+export interface UseActualQueueResult {
+  /** The current queue in playback order */
+  queue: TrackItem[]
+  /** Manually refresh the queue */
+  refreshQueue: () => void
+  /** Whether the queue is currently loading */
+  isLoading: boolean
+}
+
+/**
+ * Hook to get the actual playback queue including temporary tracks
+ *
+ * Returns the complete queue in playback order:
+ * [tracks_before_current] + [current] + [playNext_stack] + [upNext_queue] + [remaining_tracks]
+ *
+ * Auto-updates when:
+ * - Track changes
+ * - Playback state changes
+ *
+ * Call `refreshQueue()` after adding tracks via `playNext()` or `addToUpNext()`
+ * to immediately see the updated queue.
+ *
+ * @returns Object containing queue array, refresh function, and loading state
+ *
+ * @example
+ * ```tsx
+ * function QueueView() {
+ *   const { queue, refreshQueue, isLoading } = useActualQueue();
+ *
+ *   const handleAddToUpNext = (trackId: string) => {
+ *     TrackPlayer.addToUpNext(trackId);
+ *     // Refresh queue after adding track
+ *     setTimeout(refreshQueue, 100);
+ *   };
+ *
+ *   return (
+ *     <ScrollView>
+ *       {queue.map((track, index) => (
+ *         <Text key={track.id}>
+ *           {index + 1}. {track.title}
+ *         </Text>
+ *       ))}
+ *     </ScrollView>
+ *   );
+ * }
+ * ```
+ */
+export function useActualQueue(): UseActualQueueResult {
+  const [queue, setQueue] = useState<TrackItem[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const isMounted = useRef(true)
+
+  const updateQueue = useCallback(() => {
+    if (!isMounted.current) return
+
+    try {
+      const actualQueue = TrackPlayer.getActualQueue()
+      if (isMounted.current) {
+        setQueue(actualQueue)
+        setIsLoading(false)
+      }
+    } catch (error) {
+      console.error('[useActualQueue] Error getting queue:', error)
+      if (isMounted.current) {
+        setQueue([])
+        setIsLoading(false)
+      }
+    }
+  }, [])
+
+  const refreshQueue = useCallback(() => {
+    if (!isMounted.current) return
+    setIsLoading(true)
+    updateQueue()
+  }, [updateQueue])
+
+  // Initialize queue
+  useEffect(() => {
+    isMounted.current = true
+    updateQueue()
+
+    return () => {
+      isMounted.current = false
+    }
+  }, [updateQueue])
+
+  // Update queue on track changes (with slight delay to ensure native side has updated)
+  useEffect(() => {
+    const unsubscribe = callbackManager.subscribeToTrackChange(() => {
+      // Small delay to ensure native queue is updated
+      setTimeout(updateQueue, 50)
+    })
+
+    return () => {
+      unsubscribe()
+    }
+  }, [updateQueue])
+
+  // Update queue on playback state changes
+  useEffect(() => {
+    const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
+      updateQueue()
+    })
+
+    return () => {
+      unsubscribe()
+    }
+  }, [updateQueue])
+
+  return { queue, refreshQueue, isLoading }
+}

package/src/hooks/useNowPlaying.ts

@@ -0,0 +1,97 @@
+import { useEffect, useState, useRef, useCallback } from 'react'
+import { TrackPlayer } from '../index'
+import { callbackManager } from './callbackManager'
+import type { PlayerState } from '../types/PlayerQueue'
+
+const DEFAULT_STATE: PlayerState = {
+  currentTrack: null,
+  currentPosition: 0,
+  totalDuration: 0,
+  currentState: 'stopped',
+  currentPlaylistId: null,
+  currentIndex: -1,
+}
+
+/**
+ * Hook to get the current player state (same as TrackPlayer.getState())
+ *
+ * This hook provides all player state information including:
+ * - Current track
+ * - Current position and duration
+ * - Playback state (playing, paused, stopped)
+ * - Current playlist ID
+ * - Current track index
+ *
+ * The hook uses native callbacks for immediate updates when state changes.
+ * Multiple components can use this hook simultaneously.
+ *
+ * @returns PlayerState object with all current player information
+ *
+ * @example
+ * ```tsx
+ * function PlayerComponent() {
+ *   const state = useNowPlaying()
+ *
+ *   return (
+ *     <View>
+ *       {state.currentTrack && (
+ *         <Text>Now Playing: {state.currentTrack.title}</Text>
+ *       )}
+ *       <Text>Position: {state.currentPosition} / {state.totalDuration}</Text>
+ *       <Text>State: {state.currentState}</Text>
+ *       <Text>Playlist: {state.currentPlaylistId || 'None'}</Text>
+ *       <Text>Index: {state.currentIndex}</Text>
+ *     </View>
+ *   )
+ * }
+ * ```
+ */
+export function useNowPlaying(): PlayerState {
+  const [state, setState] = useState<PlayerState>(DEFAULT_STATE)
+  const isMounted = useRef(true)
+
+  const updateState = useCallback(() => {
+    if (!isMounted.current) return
+
+    try {
+      const newState = TrackPlayer.getState()
+      setState(newState)
+    } catch (error) {
+      console.error('[useNowPlaying] Error updating player state:', error)
+    }
+  }, [])
+
+  // Initialize with current state
+  useEffect(() => {
+    isMounted.current = true
+    updateState()
+
+    return () => {
+      isMounted.current = false
+    }
+  }, [updateState])
+
+  // Subscribe to track changes
+  useEffect(() => {
+    const unsubscribe = callbackManager.subscribeToTrackChange(() => {
+      updateState()
+    })
+
+    return () => {
+      unsubscribe()
+    }
+  }, [updateState])
+
+  // Subscribe to playback state changes
+  useEffect(() => {
+    const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
+      updateState()
+    })
+
+    return () => {
+      unsubscribe()
+    }
+  }, [updateState])
+
+  return state
+}