react-native-nitro-player 0.0.1

package/package.json

@@ -0,0 +1,172 @@
+{
+  "name": "react-native-nitro-player",
+  "version": "0.0.1",
+  "description": "react-native-nitro-player",
+  "main": "lib/index",
+  "module": "lib/index",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "react-native.config.js",
+    "lib",
+    "nitrogen",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/fix-prefab.gradle",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios/**/*.h",
+    "ios/**/*.m",
+    "ios/**/*.mm",
+    "ios/**/*.cpp",
+    "ios/**/*.swift",
+    "app.plugin.js",
+    "nitro.json",
+    "*.podspec",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "tsc || exit 0;",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf android/build node_modules/**/android/build lib",
+    "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"
+  },
+  "keywords": [
+    "react-native",
+    "nitro"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrousavy/nitro.git"
+  },
+  "author": "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mrousavy/nitro/issues"
+  },
+  "homepage": "https://github.com/mrousavy/nitro#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@react-native/eslint-config": "0.82.0",
+    "@release-it-plugins/workspaces": "^5.0.3",
+    "@release-it/bumper": "^7.0.5",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/react": "^19.1.03",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "nitrogen": "*",
+    "prettier": "^3.3.3",
+    "react": "19.1.1",
+    "react-native": "0.82.0",
+    "react-native-nitro-modules": "*",
+    "release-it": "^19.0.4",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "*"
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@react-native",
+      "prettier"
+    ],
+    "plugins": [
+      "prettier"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "warn",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    }
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false,
+    "semi": false
+  },
+  "release-it": {
+    "npm": {
+      "publish": true
+    },
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}",
+      "requireCleanWorkingDir": false
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/bumper": {
+        "in": "package.json",
+        "out": [
+          {
+            "file": "package.json",
+            "path": "version"
+          },
+          {
+            "file": "../package.json",
+            "path": "version"
+          },
+          {
+            "file": "../example/package.json",
+            "path": "version"
+          }
+        ]
+      },
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "conventionalcommits",
+          "types": [
+            {
+              "type": "feat",
+              "section": "✨ Features"
+            },
+            {
+              "type": "perf",
+              "section": "💨 Performance Improvements"
+            },
+            {
+              "type": "fix",
+              "section": "🐛 Bug Fixes"
+            },
+            {
+              "type": "chore(deps)",
+              "section": "🛠️ Dependency Upgrades"
+            },
+            {
+              "type": "docs",
+              "section": "📚 Documentation"
+            }
+          ]
+        }
+      }
+    }
+  }
+}

package/react-native.config.js

@@ -0,0 +1,16 @@
+// https://github.com/react-native-community/cli/blob/main/docs/dependencies.md
+
+module.exports = {
+  dependency: {
+    platforms: {
+      /**
+       * @type {import('@react-native-community/cli-types').IOSDependencyParams}
+       */
+      ios: {},
+      /**
+       * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
+       */
+      android: {},
+    },
+  },
+}

package/src/hooks/index.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/src/hooks/useAndroidAutoConnection.ts

@@ -0,0 +1,30 @@
+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<boolean>(false)
+
+  useEffect(() => {
+    // Set initial state
+    const initialState = TrackPlayer.isAndroidAutoConnected()
+    setIsConnected(initialState)
+
+    // Listen for connection changes
+    TrackPlayer.onAndroidAutoConnectionChange((connected: boolean) => {
+      setIsConnected(connected)
+      console.log('🚗 Android Auto connection changed:', connected)
+    })
+  }, [])
+
+  return { isConnected }
+}

package/src/hooks/useAudioDevices.ts

@@ -0,0 +1,64 @@
+import { useEffect, useState } from 'react'
+import { Platform } from 'react-native'
+import { NitroModules } from 'react-native-nitro-modules'
+import type { AudioDevices as AudioDevicesType } from '../specs/AudioDevices.nitro'
+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 function useAudioDevices() {
+  const [devices, setDevices] = useState<TAudioDevice[]>([])
+
+  useEffect(() => {
+    if (Platform.OS !== 'android') {
+      return undefined
+    }
+
+    try {
+      const AudioDevices =
+        NitroModules.createHybridObject<AudioDevicesType>('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/src/hooks/useOnChangeTrack.ts

@@ -0,0 +1,24 @@
+import { useEffect, useState } from 'react'
+import { TrackPlayer } from '../index'
+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 function useOnChangeTrack(): {
+  track: TrackItem | undefined
+  reason: Reason | undefined
+} {
+  const [track, setTrack] = useState<TrackItem | undefined>(undefined)
+  const [reason, setReason] = useState<Reason | undefined>(undefined)
+
+  useEffect(() => {
+    TrackPlayer.onChangeTrack((newTrack, newReason) => {
+      setTrack(newTrack)
+      setReason(newReason)
+    })
+  }, [])
+
+  return { track, reason }
+}

package/src/hooks/useOnPlaybackProgressChange.ts

@@ -0,0 +1,30 @@
+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(): {
+  position: number
+  totalDuration: number
+  isManuallySeeked: boolean | undefined
+} {
+  const [position, setPosition] = useState<number>(0)
+  const [totalDuration, setTotalDuration] = useState<number>(0)
+  const [isManuallySeeked, setIsManuallySeeked] = useState<boolean | undefined>(
+    undefined
+  )
+
+  useEffect(() => {
+    TrackPlayer.onPlaybackProgressChange(
+      (newPosition, newTotalDuration, newIsManuallySeeked) => {
+        setPosition(newPosition)
+        setTotalDuration(newTotalDuration)
+        setIsManuallySeeked(newIsManuallySeeked)
+      }
+    )
+  }, [])
+
+  return { position, totalDuration, isManuallySeeked }
+}

package/src/hooks/useOnPlaybackStateChange.ts

@@ -0,0 +1,24 @@
+import { useEffect, useState } from 'react'
+import { TrackPlayer } from '../index'
+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 function useOnPlaybackStateChange(): {
+  state: TrackPlayerState | undefined
+  reason: Reason | undefined
+} {
+  const [state, setState] = useState<TrackPlayerState | undefined>(undefined)
+  const [reason, setReason] = useState<Reason | undefined>(undefined)
+
+  useEffect(() => {
+    TrackPlayer.onPlaybackStateChange((newState, newReason) => {
+      setState(newState)
+      setReason(newReason)
+    })
+  }, [])
+
+  return { state, reason }
+}

package/src/hooks/useOnSeek.ts

@@ -0,0 +1,25 @@
+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(): {
+  position: number | undefined
+  totalDuration: number | undefined
+} {
+  const [position, setPosition] = useState<number | undefined>(undefined)
+  const [totalDuration, setTotalDuration] = useState<number | undefined>(
+    undefined
+  )
+
+  useEffect(() => {
+    TrackPlayer.onSeek((newPosition, newTotalDuration) => {
+      setPosition(newPosition)
+      setTotalDuration(newTotalDuration)
+    })
+  }, [])
+
+  return { position, totalDuration }
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+// TODO: Export all HybridObjects here for the user
+
+import { NitroModules } from 'react-native-nitro-modules'
+import { Platform } from 'react-native'
+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 const PlayerQueue =
+  NitroModules.createHybridObject<PlayerQueueType>('PlayerQueue')
+export const TrackPlayer =
+  NitroModules.createHybridObject<TrackPlayerType>('TrackPlayer')
+
+// Android-only: Android Auto Media Library
+export const AndroidAutoMediaLibrary =
+  Platform.OS === 'android'
+    ? NitroModules.createHybridObject<AndroidAutoMediaLibraryType>(
+        'AndroidAutoMediaLibrary'
+      )
+    : null
+
+// Android-only: Audio Devices
+export const AudioDevices =
+  Platform.OS === 'android'
+    ? NitroModules.createHybridObject<AudioDevicesType>('AudioDevices')
+    : null
+
+// iOS-only: Audio Route Picker
+export const AudioRoutePicker =
+  Platform.OS === 'ios'
+    ? NitroModules.createHybridObject<AudioRoutePickerType>('AudioRoutePicker')
+    : null
+
+// Export hooks
+export * from './hooks'
+
+// Export types
+export * from './types/PlayerQueue'
+export * from './types/AndroidAutoMediaLibrary'
+export type { TAudioDevice } from './specs/AudioDevices.nitro'
+
+// Export utilities
+export { AndroidAutoMediaLibraryHelper } from './utils/androidAutoMediaLibrary'

package/src/specs/AndroidAutoMediaLibrary.nitro.ts

@@ -0,0 +1,22 @@
+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/src/specs/AudioDevices.nitro.ts

@@ -0,0 +1,25 @@
+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/src/specs/AudioRoutePicker.nitro.ts

@@ -0,0 +1,9 @@
+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/src/specs/TrackPlayer.nitro.ts

@@ -0,0 +1,81 @@
+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' }> {
+  // Playlist management
+  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[]
+
+  // Track management within playlists
+  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
+
+  // Playback control
+  loadPlaylist(playlistId: string): void
+  getCurrentPlaylistId(): string | null
+
+  // Events
+  onPlaylistsChanged(
+    callback: (playlists: Playlist[], operation?: QueueOperation) => void
+  ): void
+  onPlaylistChanged(
+    callback: (
+      playlistId: string,
+      playlist: Playlist,
+      operation?: QueueOperation
+    ) => void
+  ): void
+}
+
+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
+  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/src/types/AndroidAutoMediaLibrary.ts

@@ -0,0 +1,58 @@
+/**
+ * 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/src/types/PlayerQueue.ts

@@ -0,0 +1,38 @@
+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
+}