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

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,42 @@
+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;
+    setVolume(volume: number): 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/nitrogen/generated/android/c++/JHybridTrackPlayerSpec.cpp

@@ -142,5 +142,10 @@ namespace margelo::nitro::nitroplayer {
     auto __result = method(_javaPart);
     return static_cast<bool>(__result);
   }
+  bool JHybridTrackPlayerSpec::setVolume(double volume) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(double /* volume */)>("setVolume");
+    auto __result = method(_javaPart, volume);
+    return static_cast<bool>(__result);
+  }
 
 } // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/android/c++/JHybridTrackPlayerSpec.hpp

@@ -69,6 +69,7 @@ namespace margelo::nitro::nitroplayer {
     void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) override;
     void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override;
     bool isAndroidAutoConnected() override;
+    bool setVolume(double volume) override;
 
   private:
     friend HybridBase;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridTrackPlayerSpec.kt

@@ -129,6 +129,10 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun isAndroidAutoConnected(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setVolume(volume: Double): Boolean
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -177,6 +177,14 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool setVolume(double volume) override {
+      auto __result = _swiftPart.setVolume(std::forward<decltype(volume)>(volume));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroPlayer::HybridTrackPlayerSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -29,6 +29,7 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func onPlaybackProgressChange(callback: @escaping (_ position: Double, _ totalDuration: Double, _ isManuallySeeked: Bool?) -> Void) throws -> Void
   func onAndroidAutoConnectionChange(callback: @escaping (_ connected: Bool) -> Void) throws -> Void
   func isAndroidAutoConnected() throws -> Bool
+  func setVolume(volume: Double) throws -> Bool
 }
 
 public extension HybridTrackPlayerSpec_protocol {

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

@@ -334,4 +334,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/shared/c++/HybridTrackPlayerSpec.cpp

@@ -29,6 +29,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

@@ -82,6 +82,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.3.0-alpha.5",
+  "version": "0.3.0-alpha.7",
   "description": "react-native-nitro-player",
   "main": "lib/index",
   "module": "lib/index",
@@ -30,13 +30,14 @@
   "scripts": {
     "postinstall": "tsc || exit 0;",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf android/build node_modules/**/android/build lib nitrogen",
+    "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\"",
+    "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"
+    "build": "bun run clean && bun run specs && bun run typescript && bun run copy-readme"
   },
   "keywords": [
     "react-native",
@@ -44,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/"
   },
@@ -124,7 +125,7 @@
       "release": true
     },
     "hooks": {
-      "after:bump": "bun run build"
+      "before:release": "bun run clean && bun run specs && bun run typescript && bun run copy-readme"
     },
     "plugins": {
       "@release-it/bumper": {

package/src/specs/TrackPlayer.nitro.ts

@@ -81,4 +81,5 @@ export interface TrackPlayer
   ): void
   onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void
   isAndroidAutoConnected(): boolean
+  setVolume(volume: number): boolean
 }