react-native-nitro-player 0.3.0-alpha.5 → 0.3.0-alpha.6

package/README.md

@@ -1 +1 @@
-Refer Root readme
+Refer Root readme

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,15 @@
+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 type { RepeatMode } from './specs/TrackPlayer.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';

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

@@ -0,0 +1,21 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+/**
+ * Android Auto Media Library Manager
+ * Android-only HybridObject for managing Android Auto media browser structure
+ */
+export interface AndroidAutoMediaLibrary extends HybridObject<{
+    android: 'kotlin';
+}> {
+    /**
+     * Set the Android Auto media library structure
+     * This defines what folders and playlists appear in Android Auto
+     *
+     * @param libraryJson - JSON string of the MediaLibrary structure
+     */
+    setMediaLibrary(libraryJson: string): void;
+    /**
+     * Clear the Android Auto media library
+     * Falls back to showing all playlists
+     */
+    clearMediaLibrary(): void;
+}

package/lib/specs/AndroidAutoMediaLibrary.nitro.js

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

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

@@ -0,0 +1,24 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export type TAudioDevice = {
+    id: number;
+    name: string;
+    type: number;
+    isActive: boolean;
+};
+export interface AudioDevices extends HybridObject<{
+    android: 'kotlin';
+}> {
+    /**
+     * Get the list of audio devices
+     *
+     * @returns The list of audio devices
+     */
+    getAudioDevices(): TAudioDevice[];
+    /**
+     * Set the audio device
+     *
+     * @param deviceId - The ID of the audio device
+     * @returns True if the audio device was set successfully, false otherwise
+     */
+    setAudioDevice(deviceId: number): boolean;
+}

package/lib/specs/AudioDevices.nitro.js

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

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

@@ -0,0 +1,10 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface AudioRoutePicker extends HybridObject<{
+    ios: 'swift';
+}> {
+    /**
+     * Show the audio route picker view (iOS only)
+     * This presents a native AVRoutePickerView for selecting audio output devices like AirPlay
+     */
+    showRoutePicker(): void;
+}

package/lib/specs/AudioRoutePicker.nitro.js

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

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

@@ -0,0 +1,41 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { QueueOperation, Reason, TrackItem, TrackPlayerState, PlayerState, PlayerConfig, Playlist } from '../types/PlayerQueue';
+export interface PlayerQueue extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    createPlaylist(name: string, description?: string, artwork?: string): string;
+    deletePlaylist(playlistId: string): void;
+    updatePlaylist(playlistId: string, name?: string, description?: string, artwork?: string): void;
+    getPlaylist(playlistId: string): Playlist | null;
+    getAllPlaylists(): Playlist[];
+    addTrackToPlaylist(playlistId: string, track: TrackItem, index?: number): void;
+    addTracksToPlaylist(playlistId: string, tracks: TrackItem[], index?: number): void;
+    removeTrackFromPlaylist(playlistId: string, trackId: string): void;
+    reorderTrackInPlaylist(playlistId: string, trackId: string, newIndex: number): void;
+    loadPlaylist(playlistId: string): void;
+    getCurrentPlaylistId(): string | null;
+    onPlaylistsChanged(callback: (playlists: Playlist[], operation?: QueueOperation) => void): void;
+    onPlaylistChanged(callback: (playlistId: string, playlist: Playlist, operation?: QueueOperation) => void): void;
+}
+export type RepeatMode = 'off' | 'Playlist' | 'track';
+export interface TrackPlayer extends HybridObject<{
+    android: 'kotlin';
+    ios: 'swift';
+}> {
+    play(): void;
+    pause(): void;
+    playSong(songId: string, fromPlaylist?: string): void;
+    skipToNext(): void;
+    skipToPrevious(): void;
+    seek(position: number): void;
+    getState(): PlayerState;
+    setRepeatMode(mode: RepeatMode): boolean;
+    configure(config: PlayerConfig): void;
+    onChangeTrack(callback: (track: TrackItem, reason?: Reason) => void): void;
+    onPlaybackStateChange(callback: (state: TrackPlayerState, reason?: Reason) => void): void;
+    onSeek(callback: (position: number, totalDuration: number) => void): void;
+    onPlaybackProgressChange(callback: (position: number, totalDuration: number, isManuallySeeked?: boolean) => void): void;
+    onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void;
+    isAndroidAutoConnected(): boolean;
+}

package/lib/specs/TrackPlayer.nitro.js

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

package/lib/types/AndroidAutoMediaLibrary.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Layout type for the Android Auto media browser
+ */
+export type LayoutType = 'grid' | 'list';
+/**
+ * Media type for different kinds of content
+ */
+export type MediaType = 'folder' | 'audio' | 'playlist';
+/**
+ * Media item that can be displayed in Android Auto
+ */
+export interface MediaItem {
+    /** Unique identifier for the media item */
+    id: string;
+    /** Display title */
+    title: string;
+    /** Optional subtitle/description */
+    subtitle?: string;
+    /** Optional icon/artwork URL */
+    iconUrl?: string;
+    /** Whether this item can be played directly */
+    isPlayable: boolean;
+    /** Media type */
+    mediaType: MediaType;
+    /** Reference to playlist ID (for playlist items) - will load tracks from this playlist */
+    playlistId?: string;
+    /** Child items for browsable folders */
+    children?: MediaItem[];
+    /** Layout type for folder items (overrides library default) */
+    layoutType?: LayoutType;
+}
+/**
+ * Media library structure for Android Auto
+ */
+export interface MediaLibrary {
+    /** Layout type for the media browser (applies to all folders by default) */
+    layoutType: LayoutType;
+    /** Root level media items */
+    rootItems: MediaItem[];
+    /** Optional app name to display */
+    appName?: string;
+    /** Optional app icon URL */
+    appIconUrl?: string;
+}

package/lib/types/AndroidAutoMediaLibrary.js

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

package/lib/types/PlayerQueue.d.ts

@@ -0,0 +1,32 @@
+export interface TrackItem {
+    id: string;
+    title: string;
+    artist: string;
+    album: string;
+    duration: number;
+    url: string;
+    artwork?: string | null;
+}
+export interface Playlist {
+    id: string;
+    name: string;
+    description?: string | null;
+    artwork?: string | null;
+    tracks: TrackItem[];
+}
+export type QueueOperation = 'add' | 'remove' | 'clear' | 'update';
+export type TrackPlayerState = 'playing' | 'paused' | 'stopped';
+export type Reason = 'user_action' | 'skip' | 'end' | 'error';
+export interface PlayerState {
+    currentTrack: TrackItem | null;
+    currentPosition: number;
+    totalDuration: number;
+    currentState: TrackPlayerState;
+    currentPlaylistId: string | null;
+    currentIndex: number;
+}
+export interface PlayerConfig {
+    androidAutoEnabled?: boolean;
+    carPlayEnabled?: boolean;
+    showInNotification?: boolean;
+}

package/lib/types/PlayerQueue.js

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

package/lib/utils/androidAutoMediaLibrary.d.ts

@@ -0,0 +1,47 @@
+import type { MediaLibrary } from '../types/AndroidAutoMediaLibrary';
+/**
+ * Helper utilities for Android Auto Media Library
+ * Android-only functionality
+ */
+export declare const AndroidAutoMediaLibraryHelper: {
+    /**
+     * Set the Android Auto media library structure
+     * This defines what folders and playlists appear in Android Auto
+     *
+     * @param library - The media library structure
+     *
+     * @example
+     * ```ts
+     * AndroidAutoMediaLibraryHelper.set({
+     *   layoutType: 'grid',
+     *   rootItems: [
+     *     {
+     *       id: 'my_music',
+     *       title: 'My Music',
+     *       mediaType: 'folder',
+     *       isPlayable: false,
+     *       children: [
+     *         {
+     *           id: 'favorites',
+     *           title: 'Favorites',
+     *           mediaType: 'playlist',
+     *           playlistId: 'favorites-playlist-id', // References a playlist created with PlayerQueue
+     *           isPlayable: false,
+     *         },
+     *       ],
+     *     },
+     *   ],
+     * })
+     * ```
+     */
+    set: (library: MediaLibrary) => void;
+    /**
+     * Clear the Android Auto media library
+     * Falls back to showing all playlists
+     */
+    clear: () => void;
+    /**
+     * Check if Android Auto Media Library is available (Android only)
+     */
+    isAvailable: () => boolean;
+};

package/lib/utils/androidAutoMediaLibrary.js

@@ -0,0 +1,62 @@
+import { AndroidAutoMediaLibrary as AndroidAutoMediaLibraryModule } from '../index';
+/**
+ * Helper utilities for Android Auto Media Library
+ * Android-only functionality
+ */
+export const AndroidAutoMediaLibraryHelper = {
+    /**
+     * Set the Android Auto media library structure
+     * This defines what folders and playlists appear in Android Auto
+     *
+     * @param library - The media library structure
+     *
+     * @example
+     * ```ts
+     * AndroidAutoMediaLibraryHelper.set({
+     *   layoutType: 'grid',
+     *   rootItems: [
+     *     {
+     *       id: 'my_music',
+     *       title: 'My Music',
+     *       mediaType: 'folder',
+     *       isPlayable: false,
+     *       children: [
+     *         {
+     *           id: 'favorites',
+     *           title: 'Favorites',
+     *           mediaType: 'playlist',
+     *           playlistId: 'favorites-playlist-id', // References a playlist created with PlayerQueue
+     *           isPlayable: false,
+     *         },
+     *       ],
+     *     },
+     *   ],
+     * })
+     * ```
+     */
+    set: (library) => {
+        if (!AndroidAutoMediaLibraryModule) {
+            console.warn('AndroidAutoMediaLibrary is only available on Android');
+            return;
+        }
+        const json = JSON.stringify(library);
+        AndroidAutoMediaLibraryModule.setMediaLibrary(json);
+    },
+    /**
+     * Clear the Android Auto media library
+     * Falls back to showing all playlists
+     */
+    clear: () => {
+        if (!AndroidAutoMediaLibraryModule) {
+            console.warn('AndroidAutoMediaLibrary is only available on Android');
+            return;
+        }
+        AndroidAutoMediaLibraryModule.clearMediaLibrary();
+    },
+    /**
+     * Check if Android Auto Media Library is available (Android only)
+     */
+    isAvailable: () => {
+        return AndroidAutoMediaLibraryModule !== null;
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.3.0-alpha.5",
+  "version": "0.3.0-alpha.6",
   "description": "react-native-nitro-player",
   "main": "lib/index",
   "module": "lib/index",
@@ -44,14 +44,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/"
   },
@@ -123,9 +123,6 @@
     "github": {
       "release": true
     },
-    "hooks": {
-      "after:bump": "bun run build"
-    },
     "plugins": {
       "@release-it/bumper": {
         "in": "package.json",