react-native-nitro-player 0.0.1

package/ios/queue/HybridPlayerQueue.swift

@@ -0,0 +1,95 @@
+//
+//  HybridPlayerQueue.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 24/11/25.
+//
+
+import NitroModules
+
+final class HybridPlayerQueue: HybridPlayerQueueSpec {
+  private let playlistManager = PlaylistManager.shared
+  private var playlistsChangeListener: (() -> Void)?
+  private var playlistChangeListeners: [String: () -> Void] = [:]
+
+  func createPlaylist(name: String, description: String?, artwork: String?) throws -> String {
+    return playlistManager.createPlaylist(name: name, description: description, artwork: artwork)
+  }
+
+  func deletePlaylist(playlistId: String) throws {
+    _ = playlistManager.deletePlaylist(playlistId: playlistId)
+  }
+
+  func updatePlaylist(playlistId: String, name: String?, description: String?, artwork: String?)
+    throws
+  {
+    _ = playlistManager.updatePlaylist(
+      playlistId: playlistId, name: name, description: description, artwork: artwork)
+  }
+
+  func getPlaylist(playlistId: String) throws -> Variant_NullType_Playlist {
+    if let playlist = playlistManager.getPlaylist(playlistId: playlistId) {
+      return Variant_NullType_Playlist.second(playlist.toGeneratedPlaylist())
+    } else {
+      return Variant_NullType_Playlist.first(NullType.null)
+    }
+  }
+
+  func getAllPlaylists() throws -> [Playlist] {
+    return playlistManager.getAllPlaylists().map { $0.toGeneratedPlaylist() }
+  }
+
+  func addTrackToPlaylist(playlistId: String, track: TrackItem, index: Double?) throws {
+    let insertIndex = index.map { Int($0) }
+    _ = playlistManager.addTrackToPlaylist(playlistId: playlistId, track: track, index: insertIndex)
+  }
+
+  func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws {
+    let insertIndex = index.map { Int($0) }
+    _ = playlistManager.addTracksToPlaylist(
+      playlistId: playlistId, tracks: tracks, index: insertIndex)
+  }
+
+  func removeTrackFromPlaylist(playlistId: String, trackId: String) throws {
+    _ = playlistManager.removeTrackFromPlaylist(playlistId: playlistId, trackId: trackId)
+  }
+
+  func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws {
+    _ = playlistManager.reorderTrackInPlaylist(
+      playlistId: playlistId, trackId: trackId, newIndex: Int(newIndex))
+  }
+
+  func loadPlaylist(playlistId: String) throws {
+    _ = playlistManager.loadPlaylist(playlistId: playlistId)
+  }
+
+  func getCurrentPlaylistId() throws -> Variant_NullType_String {
+    if let playlistId = playlistManager.getCurrentPlaylistId() {
+      return Variant_NullType_String.second(playlistId)
+    } else {
+      return Variant_NullType_String.first(NullType.null)
+    }
+  }
+
+  func onPlaylistsChanged(callback: @escaping ([Playlist], QueueOperation?) -> Void) throws {
+    // Remove previous listener if exists
+    playlistsChangeListener?()
+
+    // Add new listener
+    playlistsChangeListener = playlistManager.addPlaylistsChangeListener { playlists, operation in
+      callback(playlists.map { $0.toGeneratedPlaylist() }, operation)
+    }
+  }
+
+  func onPlaylistChanged(callback: @escaping (String, Playlist, QueueOperation?) -> Void) throws {
+    // Listen to all playlists
+    let allPlaylists = playlistManager.getAllPlaylists()
+    for playlist in allPlaylists {
+      let removeListener = playlistManager.addPlaylistChangeListener(playlistId: playlist.id) {
+        updatedPlaylist, operation in
+        callback(updatedPlaylist.id, updatedPlaylist.toGeneratedPlaylist(), operation)
+      }
+      playlistChangeListeners[playlist.id] = removeListener
+    }
+  }
+}

package/ios/queue/Queue.swift

@@ -0,0 +1,126 @@
+//
+//  Queue.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 24/11/25.
+//
+
+import Foundation
+
+/// Queue class that manages a list of tracks.
+/// Thread-safe implementation using a serial dispatch queue.
+class Queue {
+  private var tracks: [TrackItem] = []
+  private let queue = DispatchQueue(label: "com.margelo.nitro.nitroplayer.queue")
+
+  /**
+   * Get all tracks in the queue
+   */
+  func getTracks() -> [TrackItem] {
+    return queue.sync {
+      return Array(tracks)
+    }
+  }
+
+  /**
+   * Add a single track to the queue
+   */
+  func addTrack(_ track: TrackItem) {
+    queue.sync {
+      self.tracks.append(track)
+    }
+  }
+
+  /**
+   * Add a track at a specific index
+   */
+  func addTrackAtIndex(_ track: TrackItem, index: Int) {
+    queue.sync {
+      if index < 0 || index > self.tracks.count {
+        self.tracks.append(track)
+      } else {
+        self.tracks.insert(track, at: index)
+      }
+    }
+  }
+
+  /**
+   * Load multiple tracks into the queue (replaces existing queue)
+   */
+  func loadTracks(_ newTracks: [TrackItem]) {
+    queue.sync {
+      self.tracks.removeAll()
+      self.tracks.append(contentsOf: newTracks)
+    }
+  }
+
+  /**
+   * Remove a track by ID
+   * @return true if track was found and removed, false otherwise
+   */
+  func removeTrack(id: String) -> Bool {
+    return queue.sync {
+      let initialCount = self.tracks.count
+      self.tracks.removeAll { $0.id == id }
+      return self.tracks.count < initialCount
+    }
+  }
+
+  /**
+   * Clear all tracks from the queue
+   */
+  func clear() {
+    queue.sync {
+      self.tracks.removeAll()
+    }
+  }
+
+  /**
+   * Get the size of the queue
+   */
+  func size() -> Int {
+    return queue.sync {
+      return self.tracks.count
+    }
+  }
+
+  /**
+   * Check if the queue is empty
+   */
+  func isEmpty() -> Bool {
+    return queue.sync {
+      return self.tracks.isEmpty
+    }
+  }
+
+  /**
+   * Get a track by index
+   */
+  func getTrack(index: Int) -> TrackItem? {
+    return queue.sync {
+      if index >= 0 && index < self.tracks.count {
+        return self.tracks[index]
+      } else {
+        return nil
+      }
+    }
+  }
+
+  /**
+   * Get a track by ID
+   */
+  func getTrackById(id: String) -> TrackItem? {
+    return queue.sync {
+      return self.tracks.first { $0.id == id }
+    }
+  }
+
+  /**
+   * Get the index of a track by ID
+   */
+  func getTrackIndex(id: String) -> Int {
+    return queue.sync {
+      return self.tracks.firstIndex { $0.id == id } ?? -1
+    }
+  }
+}

package/ios/queue/QueueManager.swift

@@ -0,0 +1,157 @@
+//
+//  QueueManager.swift
+//  NitroPlayer
+//
+//  Created by Ritesh Shukla on 24/11/25.
+//
+
+import Foundation
+
+/// Wrapper class to store listeners with unique IDs for removal
+private class ListenerWrapper {
+  let id: UUID
+  let listener: ([TrackItem], QueueOperation?) -> Void
+
+  init(id: UUID = UUID(), listener: @escaping ([TrackItem], QueueOperation?) -> Void) {
+    self.id = id
+    self.listener = listener
+  }
+}
+
+/// QueueManager is a singleton that manages the queue state across the app session.
+/// It provides thread-safe access to the queue and notifies listeners of queue changes.
+class QueueManager {
+  private let queue = Queue()
+  private var listeners: [ListenerWrapper] = []
+  private let listenersQueue = DispatchQueue(label: "com.margelo.nitro.nitroplayer.listeners")
+
+  static let shared = QueueManager()
+
+  private init() {}
+
+  /**
+   * Get the current queue
+   */
+  func getQueue() -> Queue {
+    return queue
+  }
+
+  /**
+   * Get all tracks in the queue
+   */
+  func getTracks() -> [TrackItem] {
+    return queue.getTracks()
+  }
+
+  /**
+   * Load multiple tracks into the queue (replaces existing queue)
+   */
+  func loadQueue(_ tracks: [TrackItem]) {
+    queue.loadTracks(tracks)
+    notifyListeners(.add)
+  }
+
+  /**
+   * Load a single track at a specific index
+   */
+  func loadSingleTrack(_ track: TrackItem, index: Double?) {
+    let insertIndex = index.map { Int($0) }
+    if let insertIndex = insertIndex, insertIndex >= 0 {
+      queue.addTrackAtIndex(track, index: insertIndex)
+    } else {
+      queue.addTrack(track)
+    }
+    notifyListeners(.add)
+  }
+
+  /**
+   * Delete a track by ID
+   */
+  func deleteTrack(id: String) {
+    let removed = queue.removeTrack(id: id)
+    if removed {
+      notifyListeners(.remove)
+    }
+  }
+
+  /**
+   * Clear all tracks from the queue
+   */
+  func clearQueue() {
+    queue.clear()
+    notifyListeners(.clear)
+  }
+
+  /**
+   * Add a listener for queue changes
+   * @param listener Callback that receives (queue, operation)
+   * @return A function to remove the listener
+   */
+  func addQueueChangeListener(
+    _ listener: @escaping (_ queue: [TrackItem], _ operation: QueueOperation?) -> Void
+  ) -> () -> Void {
+    let wrapper = ListenerWrapper(listener: listener)
+    listenersQueue.sync {
+      listeners.append(wrapper)
+    }
+
+    return { [weak self, wrapper] in
+      self?.listenersQueue.sync {
+        self?.listeners.removeAll { $0.id == wrapper.id }
+      }
+    }
+  }
+
+  /**
+   * Notify all listeners of queue changes
+   */
+  private func notifyListeners(_ operation: QueueOperation?) {
+    let currentTracks = queue.getTracks()
+    listenersQueue.sync {
+      let listenersCopy = listeners
+      for wrapper in listenersCopy {
+        do {
+          wrapper.listener(currentTracks, operation)
+        } catch {
+          // Log error but don't break other listeners
+          print("Error in queue change listener: \(error)")
+        }
+      }
+    }
+  }
+
+  /**
+   * Get queue size
+   */
+  func getQueueSize() -> Int {
+    return queue.size()
+  }
+
+  /**
+   * Check if queue is empty
+   */
+  func isQueueEmpty() -> Bool {
+    return queue.isEmpty()
+  }
+
+  /**
+   * Get a track by index
+   */
+  func getTrack(index: Int) -> TrackItem? {
+    return queue.getTrack(index: index)
+  }
+
+  /**
+   * Get a track by ID
+   */
+  func getTrackById(id: String) -> TrackItem? {
+    return queue.getTrackById(id: id)
+  }
+
+  /**
+   * Get the index of a track by ID
+   */
+  func getTrackIndex(id: String) -> Int {
+    return queue.getTrackIndex(id: id)
+  }
+}

package/lib/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export { useOnChangeTrack } from './useOnChangeTrack';
+export { useOnPlaybackStateChange } from './useOnPlaybackStateChange';
+export { useOnSeek } from './useOnSeek';
+export { useOnPlaybackProgressChange } from './useOnPlaybackProgressChange';
+export { useAndroidAutoConnection } from './useAndroidAutoConnection';
+export { useAudioDevices } from './useAudioDevices';

package/lib/hooks/index.js

@@ -0,0 +1,6 @@
+export { useOnChangeTrack } from './useOnChangeTrack';
+export { useOnPlaybackStateChange } from './useOnPlaybackStateChange';
+export { useOnSeek } from './useOnSeek';
+export { useOnPlaybackProgressChange } from './useOnPlaybackProgressChange';
+export { useAndroidAutoConnection } from './useAndroidAutoConnection';
+export { useAudioDevices } from './useAudioDevices';

package/lib/hooks/useAndroidAutoConnection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hook to detect Android Auto connection status using the official Android for Cars API
+ * Based on: https://developer.android.com/training/cars/apps#car-connection
+ *
+ * @returns Object with isConnected boolean
+ *
+ * @example
+ * const { isConnected } = useAndroidAutoConnection();
+ * console.log('Android Auto connected:', isConnected);
+ */
+export declare function useAndroidAutoConnection(): {
+    isConnected: boolean;
+};

package/lib/hooks/useAndroidAutoConnection.js

@@ -0,0 +1,26 @@
+import { useEffect, useState } from 'react';
+import { TrackPlayer } from '../index';
+/**
+ * Hook to detect Android Auto connection status using the official Android for Cars API
+ * Based on: https://developer.android.com/training/cars/apps#car-connection
+ *
+ * @returns Object with isConnected boolean
+ *
+ * @example
+ * const { isConnected } = useAndroidAutoConnection();
+ * console.log('Android Auto connected:', isConnected);
+ */
+export function useAndroidAutoConnection() {
+    const [isConnected, setIsConnected] = useState(false);
+    useEffect(() => {
+        // Set initial state
+        const initialState = TrackPlayer.isAndroidAutoConnected();
+        setIsConnected(initialState);
+        // Listen for connection changes
+        TrackPlayer.onAndroidAutoConnectionChange((connected) => {
+            setIsConnected(connected);
+            console.log('🚗 Android Auto connection changed:', connected);
+        });
+    }, []);
+    return { isConnected };
+}

package/lib/hooks/useAudioDevices.d.ts

@@ -0,0 +1,26 @@
+import type { TAudioDevice } from '../specs/AudioDevices.nitro';
+/**
+ * Hook to get audio devices (Android only)
+ *
+ * Polls for device changes every 2 seconds
+ *
+ * @returns Object containing the current list of audio devices
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { devices } = useAudioDevices()
+ *
+ *   return (
+ *     <View>
+ *       {devices.map(device => (
+ *         <Text key={device.id}>{device.name}</Text>
+ *       ))}
+ *     </View>
+ *   )
+ * }
+ * ```
+ */
+export declare function useAudioDevices(): {
+    devices: TAudioDevice[];
+};

package/lib/hooks/useAudioDevices.js

@@ -0,0 +1,55 @@
+import { useEffect, useState } from 'react';
+import { Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+/**
+ * Hook to get audio devices (Android only)
+ *
+ * Polls for device changes every 2 seconds
+ *
+ * @returns Object containing the current list of audio devices
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { devices } = useAudioDevices()
+ *
+ *   return (
+ *     <View>
+ *       {devices.map(device => (
+ *         <Text key={device.id}>{device.name}</Text>
+ *       ))}
+ *     </View>
+ *   )
+ * }
+ * ```
+ */
+export function useAudioDevices() {
+    const [devices, setDevices] = useState([]);
+    useEffect(() => {
+        if (Platform.OS !== 'android') {
+            return undefined;
+        }
+        try {
+            const AudioDevices = NitroModules.createHybridObject('AudioDevices');
+            // Get initial devices
+            const updateDevices = () => {
+                try {
+                    const currentDevices = AudioDevices.getAudioDevices();
+                    setDevices(currentDevices);
+                }
+                catch (error) {
+                    console.error('Error getting audio devices:', error);
+                }
+            };
+            updateDevices();
+            // Poll for changes every 2 seconds
+            const interval = setInterval(updateDevices, 2000);
+            return () => clearInterval(interval);
+        }
+        catch (error) {
+            console.error('Error setting up audio devices polling:', error);
+            return undefined;
+        }
+    }, []);
+    return { devices };
+}

package/lib/hooks/useOnChangeTrack.d.ts

@@ -0,0 +1,9 @@
+import type { TrackItem, Reason } from '../types/PlayerQueue';
+/**
+ * Hook to get the current track and track change reason
+ * @returns Object with current track and reason, or undefined if no track is playing
+ */
+export declare function useOnChangeTrack(): {
+    track: TrackItem | undefined;
+    reason: Reason | undefined;
+};

package/lib/hooks/useOnChangeTrack.js

@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react';
+import { TrackPlayer } from '../index';
+/**
+ * Hook to get the current track and track change reason
+ * @returns Object with current track and reason, or undefined if no track is playing
+ */
+export function useOnChangeTrack() {
+    const [track, setTrack] = useState(undefined);
+    const [reason, setReason] = useState(undefined);
+    useEffect(() => {
+        TrackPlayer.onChangeTrack((newTrack, newReason) => {
+            setTrack(newTrack);
+            setReason(newReason);
+        });
+    }, []);
+    return { track, reason };
+}

package/lib/hooks/useOnPlaybackProgressChange.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook to get the current playback progress
+ * @returns Object with current position, total duration, and manual seek indicator
+ */
+export declare function useOnPlaybackProgressChange(): {
+    position: number;
+    totalDuration: number;
+    isManuallySeeked: boolean | undefined;
+};

package/lib/hooks/useOnPlaybackProgressChange.js

@@ -0,0 +1,19 @@
+import { useEffect, useState } from 'react';
+import { TrackPlayer } from '../index';
+/**
+ * Hook to get the current playback progress
+ * @returns Object with current position, total duration, and manual seek indicator
+ */
+export function useOnPlaybackProgressChange() {
+    const [position, setPosition] = useState(0);
+    const [totalDuration, setTotalDuration] = useState(0);
+    const [isManuallySeeked, setIsManuallySeeked] = useState(undefined);
+    useEffect(() => {
+        TrackPlayer.onPlaybackProgressChange((newPosition, newTotalDuration, newIsManuallySeeked) => {
+            setPosition(newPosition);
+            setTotalDuration(newTotalDuration);
+            setIsManuallySeeked(newIsManuallySeeked);
+        });
+    }, []);
+    return { position, totalDuration, isManuallySeeked };
+}

package/lib/hooks/useOnPlaybackStateChange.d.ts

@@ -0,0 +1,9 @@
+import type { TrackPlayerState, Reason } from '../types/PlayerQueue';
+/**
+ * Hook to get the current playback state and reason
+ * @returns Object with current playback state and reason
+ */
+export declare function useOnPlaybackStateChange(): {
+    state: TrackPlayerState | undefined;
+    reason: Reason | undefined;
+};

package/lib/hooks/useOnPlaybackStateChange.js

@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react';
+import { TrackPlayer } from '../index';
+/**
+ * Hook to get the current playback state and reason
+ * @returns Object with current playback state and reason
+ */
+export function useOnPlaybackStateChange() {
+    const [state, setState] = useState(undefined);
+    const [reason, setReason] = useState(undefined);
+    useEffect(() => {
+        TrackPlayer.onPlaybackStateChange((newState, newReason) => {
+            setState(newState);
+            setReason(newReason);
+        });
+    }, []);
+    return { state, reason };
+}

package/lib/hooks/useOnSeek.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Hook to get the last seek event information
+ * @returns Object with last seek position and total duration, or undefined if no seek has occurred
+ */
+export declare function useOnSeek(): {
+    position: number | undefined;
+    totalDuration: number | undefined;
+};

package/lib/hooks/useOnSeek.js

@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react';
+import { TrackPlayer } from '../index';
+/**
+ * Hook to get the last seek event information
+ * @returns Object with last seek position and total duration, or undefined if no seek has occurred
+ */
+export function useOnSeek() {
+    const [position, setPosition] = useState(undefined);
+    const [totalDuration, setTotalDuration] = useState(undefined);
+    useEffect(() => {
+        TrackPlayer.onSeek((newPosition, newTotalDuration) => {
+            setPosition(newPosition);
+            setTotalDuration(newTotalDuration);
+        });
+    }, []);
+    return { position, totalDuration };
+}

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+import type { PlayerQueue as PlayerQueueType, TrackPlayer as TrackPlayerType } from './specs/TrackPlayer.nitro';
+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';
+export declare const PlayerQueue: PlayerQueueType;
+export declare const TrackPlayer: TrackPlayerType;
+export declare const AndroidAutoMediaLibrary: AndroidAutoMediaLibraryType | null;
+export declare const AudioDevices: AudioDevicesType | null;
+export declare const AudioRoutePicker: AudioRoutePickerType | null;
+export * from './hooks';
+export * from './types/PlayerQueue';
+export * from './types/AndroidAutoMediaLibrary';
+export type { TAudioDevice } from './specs/AudioDevices.nitro';
+export { AndroidAutoMediaLibraryHelper } from './utils/androidAutoMediaLibrary';

package/lib/index.js

@@ -0,0 +1,24 @@
+// TODO: Export all HybridObjects here for the user
+import { NitroModules } from 'react-native-nitro-modules';
+import { Platform } from 'react-native';
+export const PlayerQueue = NitroModules.createHybridObject('PlayerQueue');
+export const TrackPlayer = NitroModules.createHybridObject('TrackPlayer');
+// Android-only: Android Auto Media Library
+export const AndroidAutoMediaLibrary = Platform.OS === 'android'
+    ? NitroModules.createHybridObject('AndroidAutoMediaLibrary')
+    : null;
+// Android-only: Audio Devices
+export const AudioDevices = Platform.OS === 'android'
+    ? NitroModules.createHybridObject('AudioDevices')
+    : null;
+// iOS-only: Audio Route Picker
+export const AudioRoutePicker = Platform.OS === 'ios'
+    ? NitroModules.createHybridObject('AudioRoutePicker')
+    : null;
+// Export hooks
+export * from './hooks';
+// Export types
+export * from './types/PlayerQueue';
+export * from './types/AndroidAutoMediaLibrary';
+// Export utilities
+export { AndroidAutoMediaLibraryHelper } from './utils/androidAutoMediaLibrary';