expo-native-track-player 0.1.1

package/package.json

@@ -0,0 +1,172 @@
+{
+  "name": "expo-native-track-player",
+  "version": "0.1.1",
+  "description": "TurboModule track player (New Architecture)",
+  "main": "./lib/module/index.js",
+  "react-native": "./src/index.tsx",
+  "source": "./src/index.tsx",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "react-native": "./src/index.tsx",
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace expo-native-track-player-example",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest",
+    "release": "release-it --only-version"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+.git"
+  },
+  "author": " <> ()",
+  "license": "MIT",
+  "bugs": {
+    "url": "/issues"
+  },
+  "homepage": "#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@react-native/babel-preset": "0.83.0",
+    "@react-native/eslint-config": "0.83.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.0",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "lefthook": "^2.0.3",
+    "prettier": "^2.8.8",
+    "react": "19.2.0",
+    "react-native": "0.83.0",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "packageManager": "yarn@4.11.0",
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "ExpoNativeTrackPlayerSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.exponativetrackplayer"
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  },
+  "create-react-native-library": {
+    "type": "turbo-module",
+    "languages": "kotlin-objc",
+    "tools": [
+      "eslint",
+      "jest",
+      "lefthook",
+      "release-it"
+    ],
+    "version": "0.57.0"
+  },
+  "workspaces": [
+    "example"
+  ]
+}

package/src/NativeExpoNativeTrackPlayer.ts

@@ -0,0 +1,70 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+export interface TrackMetadata {
+  id: string;
+  url: string;
+  title?: string;
+  artist?: string;
+  albumName?: string;
+  artworkUri?: string;
+  trackNumber?: number;
+  duration?: number;
+  composer?: string;
+  conductor?: string;
+  genre?: string;
+  compilation?: string;
+  subtitle?: string;
+  description?: string;
+  station?: string;
+  mediaType?: number;
+  type?: string;
+  userAgent?: string;
+  contentType?: string;
+  pitchAlgorithm?: string;
+}
+
+export type RepeatMode = 'off' | 'track' | 'queue' | 'loop_portion';
+export type State =
+  | 'none'
+  | 'ready'
+  | 'playing'
+  | 'paused'
+  | 'stopped'
+  | 'loading'
+  | 'buffering'
+  | 'error'
+  | 'ended';
+export type PlaybackState = State;
+export interface Spec extends TurboModule {
+  addToQueue(track: TrackMetadata): void;
+  addQueue(tracks: Array<TrackMetadata>): void;
+  getQueue(): Array<TrackMetadata>;
+  removeFromQueue(trackId: string): void;
+  clearQueue(): void;
+  play(index?: number | null): void;
+  pause(): void;
+  stop(): void;
+  skipToNext(): void;
+  skipToPrevious(): void;
+  skipToIndex(index: number): void;
+  seekTo(positionMs: number): void;
+  reset(): void;
+  setRepeatMode(
+    mode: RepeatMode,
+    startMs?: number | null,
+    endMs?: number | null
+  ): void;
+  getRepeatMode(): RepeatMode;
+  getCurrentTrack(): TrackMetadata | null;
+  getCurrentTrackIndex(): number;
+  getPosition(): number;
+  getDuration(): number;
+  getPlaybackState(): State;
+  setVolume(volume: number): void;
+  getVolume(): number;
+  setRate(rate: number): void;
+  getRate(): number;
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ExpoNativeTrackPlayer');

package/src/constants.ts

@@ -0,0 +1,40 @@
+export const TrackTypes = {
+  Default: 'default',
+  Dash: 'dash',
+  Hls: 'hls',
+  SmoothStreaming: 'smoothstreaming',
+} as const;
+
+export type TrackType = (typeof TrackTypes)[keyof typeof TrackTypes];
+
+export const PitchAlgorithms = {
+  Linear: 'linear',
+  Music: 'music',
+  Voice: 'voice',
+} as const;
+
+export type PitchAlgorithm =
+  (typeof PitchAlgorithms)[keyof typeof PitchAlgorithms];
+
+export const State: Record<string, string> = {
+  None: 'none',
+  Ready: 'ready',
+  Playing: 'playing',
+  Paused: 'paused',
+  Stopped: 'stopped',
+  Loading: 'loading',
+  Buffering: 'buffering',
+  Error: 'error',
+  Ended: 'ended',
+} as const;
+
+export type StateType = (typeof State)[keyof typeof State];
+
+export const RepeatModes = {
+  Off: 'off',
+  Track: 'track',
+  Queue: 'queue',
+  LoopPortion: 'loop_portion',
+} as const;
+
+export type RepeatModeType = (typeof RepeatModes)[keyof typeof RepeatModes];

package/src/events.ts

@@ -0,0 +1,136 @@
+import { NativeEventEmitter, type EmitterSubscription } from 'react-native';
+import ExpoNativeTrackPlayer, {
+  type State,
+  type TrackMetadata,
+} from './NativeExpoNativeTrackPlayer';
+
+export const Event = {
+  PlayerError: 'player-error',
+  PlaybackState: 'playback-state',
+  PlaybackError: 'playback-error',
+  PlaybackQueueEnded: 'playback-queue-ended',
+  PlaybackActiveTrackChanged: 'playback-active-track-changed',
+  PlaybackPlayWhenReadyChanged: 'playback-play-when-ready-changed',
+  PlaybackProgressUpdated: 'playback-progress-updated',
+  PlaybackResume: 'android-playback-resume',
+  RemotePlay: 'remote-play',
+  RemotePlayPause: 'remote-play-pause',
+  RemotePause: 'remote-pause',
+  RemoteStop: 'remote-stop',
+  RemoteNext: 'remote-next',
+  RemotePrevious: 'remote-previous',
+  RemoteJumpForward: 'remote-jump-forward',
+  RemoteJumpBackward: 'remote-jump-backward',
+  RemoteSeek: 'remote-seek',
+  RemoteSetRating: 'remote-set-rating',
+  RemoteDuck: 'remote-duck',
+  RemoteLike: 'remote-like',
+  RemoteDislike: 'remote-dislike',
+  RemoteBookmark: 'remote-bookmark',
+  RemotePlayId: 'remote-play-id',
+  RemotePlaySearch: 'remote-play-search',
+  RemoteSkip: 'remote-skip',
+  MetadataChapterReceived: 'metadata-chapter-received',
+  MetadataTimedReceived: 'metadata-timed-received',
+  MetadataCommonReceived: 'metadata-common-received',
+  AndroidConnectorConnected: 'android-controller-connected',
+  AndroidConnectorDisconnected: 'android-controller-disconnected',
+} as const;
+
+export type EventName = (typeof Event)[keyof typeof Event];
+
+export const TrackPlayerEvents = {
+  ...Event,
+  QueueUpdated: 'queue-updated',
+} as const;
+
+export type TrackPlayerEventName =
+  (typeof TrackPlayerEvents)[keyof typeof TrackPlayerEvents];
+
+export interface PlaybackStateEvent {
+  state: State;
+}
+
+export interface PlaybackPositionEvent {
+  position: number;
+  duration: number;
+  trackIndex: number;
+}
+
+export interface TrackChangedEvent {
+  trackIndex: number;
+  track: TrackMetadata | null;
+}
+
+export interface QueueUpdatedEvent {
+  count: number;
+  trackIndex: number;
+  queue: TrackMetadata[];
+}
+
+export interface PlaybackQueueEndedEvent {
+  trackIndex: number;
+  position: number;
+}
+
+export type EventPayloadMap = {
+  [Event.PlayerError]: { message?: string } | undefined;
+  [Event.PlaybackState]: PlaybackStateEvent;
+  [Event.PlaybackError]: { message?: string } | undefined;
+  [Event.PlaybackQueueEnded]: PlaybackQueueEndedEvent;
+  [Event.PlaybackActiveTrackChanged]: TrackChangedEvent;
+  [Event.PlaybackPlayWhenReadyChanged]: { playWhenReady: boolean };
+  [Event.PlaybackProgressUpdated]: PlaybackPositionEvent;
+  [Event.PlaybackResume]: undefined;
+  [Event.RemotePlay]: undefined;
+  [Event.RemotePlayPause]: undefined;
+  [Event.RemotePause]: undefined;
+  [Event.RemoteStop]: undefined;
+  [Event.RemoteNext]: undefined;
+  [Event.RemotePrevious]: undefined;
+  [Event.RemoteJumpForward]: { interval?: number } | undefined;
+  [Event.RemoteJumpBackward]: { interval?: number } | undefined;
+  [Event.RemoteSeek]: { position: number };
+  [Event.RemoteSetRating]: { rating: number };
+  [Event.RemoteDuck]: { paused: boolean; permanent: boolean };
+  [Event.RemoteLike]: undefined;
+  [Event.RemoteDislike]: undefined;
+  [Event.RemoteBookmark]: undefined;
+  [Event.RemotePlayId]: { id: string };
+  [Event.RemotePlaySearch]: { query: string };
+  [Event.RemoteSkip]: { interval: number };
+  [Event.MetadataChapterReceived]: { title?: string; startTime?: number };
+  [Event.MetadataTimedReceived]: { value: string };
+  [Event.MetadataCommonReceived]: { title?: string; artist?: string };
+  [Event.AndroidConnectorConnected]: undefined;
+  [Event.AndroidConnectorDisconnected]: undefined;
+  [TrackPlayerEvents.QueueUpdated]: QueueUpdatedEvent;
+};
+
+const emitter = new NativeEventEmitter(ExpoNativeTrackPlayer);
+
+export function addEventListener<T>(
+  eventName: TrackPlayerEventName,
+  listener: (event: T) => void
+): EmitterSubscription {
+  return emitter.addListener(eventName, (event: any) => listener(event as T));
+}
+
+export function addTypedEventListener<E extends TrackPlayerEventName>(
+  eventName: E,
+  listener: (event: EventPayloadMap[E]) => void
+): EmitterSubscription {
+  return emitter.addListener(eventName, (event: any) =>
+    listener(event as EventPayloadMap[E])
+  );
+}
+
+export function removeAllEventListeners(eventName: TrackPlayerEventName): void {
+  emitter.removeAllListeners(eventName);
+}
+
+export const AudioEvents = {
+  addListener: addEventListener,
+  addTypedListener: addTypedEventListener,
+  removeAllListeners: removeAllEventListeners,
+};

package/src/hooks.ts

@@ -0,0 +1,149 @@
+import { useEffect, useState } from 'react';
+import ExpoNativeTrackPlayer, {
+  type State,
+  type TrackMetadata,
+} from './NativeExpoNativeTrackPlayer';
+import {
+  addEventListener,
+  Event,
+  type PlaybackStateEvent,
+  type QueueUpdatedEvent,
+  type TrackChangedEvent,
+  TrackPlayerEvents,
+} from './events';
+
+export interface PlaybackProgress {
+  position: number;
+  duration: number;
+  trackIndex: number;
+}
+
+export function usePlaybackState(): State {
+  const [state, setState] = useState<State>('none');
+
+  useEffect(() => {
+    const subscription = addEventListener<PlaybackStateEvent>(
+      Event.PlaybackState,
+      (event) => setState(event.state)
+    );
+    return () => subscription.remove();
+  }, []);
+
+  return state;
+}
+
+export function useProgress(intervalMs: number = 1000): PlaybackProgress {
+  const [progress, setProgress] = useState<PlaybackProgress>({
+    position: 0,
+    duration: 0,
+    trackIndex: -1,
+  });
+
+  useEffect(() => {
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) return;
+
+    let isActive = true;
+
+    const update = () => {
+      if (!isActive) return;
+      try {
+        const position = ExpoNativeTrackPlayer.getPosition();
+        const duration = ExpoNativeTrackPlayer.getDuration();
+        const trackIndex = ExpoNativeTrackPlayer.getCurrentTrackIndex();
+        setProgress({ position, duration, trackIndex });
+      } catch (error) {
+        setProgress({ position: 0, duration: 0, trackIndex: -1 });
+      }
+    };
+
+    update();
+    const timer = setInterval(update, intervalMs);
+    return () => {
+      isActive = false;
+      clearInterval(timer);
+    };
+  }, [intervalMs]);
+
+  return progress;
+}
+
+export function useQueue(): TrackMetadata[] {
+  const [queue, setQueue] = useState<TrackMetadata[]>([]);
+
+  useEffect(() => {
+    let isActive = true;
+
+    try {
+      const result = ExpoNativeTrackPlayer.getQueue();
+      if (isActive) setQueue(result);
+    } catch (error) {
+      if (isActive) setQueue([]);
+    }
+
+    const subscription = addEventListener<QueueUpdatedEvent>(
+      TrackPlayerEvents.QueueUpdated,
+      (event) => setQueue(event.queue)
+    );
+
+    return () => {
+      isActive = false;
+      subscription.remove();
+    };
+  }, []);
+
+  return queue;
+}
+
+export function useCurrentTrack(): TrackMetadata | null {
+  const [track, setTrack] = useState<TrackMetadata | null>(null);
+
+  useEffect(() => {
+    let isActive = true;
+
+    try {
+      const result = ExpoNativeTrackPlayer.getCurrentTrack();
+      if (isActive) setTrack(result);
+    } catch (error) {
+      if (isActive) setTrack(null);
+    }
+
+    const subscription = addEventListener<TrackChangedEvent>(
+      Event.PlaybackActiveTrackChanged,
+      (event) => setTrack(event.track)
+    );
+
+    return () => {
+      isActive = false;
+      subscription.remove();
+    };
+  }, []);
+
+  return track;
+}
+
+export function useCurrentTrackIndex(): number {
+  const [index, setIndex] = useState<number>(-1);
+
+  useEffect(() => {
+    let isActive = true;
+
+    try {
+      const result = ExpoNativeTrackPlayer.getCurrentTrackIndex();
+      if (isActive) setIndex(result);
+    } catch (error) {
+      if (isActive) setIndex(-1);
+    }
+
+    const subscription = addEventListener<TrackChangedEvent>(
+      Event.PlaybackActiveTrackChanged,
+      (event) => setIndex(event.trackIndex)
+    );
+
+    return () => {
+      isActive = false;
+      subscription.remove();
+    };
+  }, []);
+
+  return index;
+}