AudioPro Class — Complete Method Reference

import { AudioPro } from 'react-native-audio-pro';

configure(options: AudioProConfigureOptions): void

import { AudioPro, AudioProContentType } from 'react-native-audio-pro';

AudioPro.configure({
  contentType: AudioProContentType.MUSIC,
  progressIntervalMs: 500,
  debug: __DEV__,
  maxCacheSize: 300 * 1024 * 1024, // 300 MB
});

syncFromNative(): void

// In your root component, after JS re-hydration
useEffect(() => {
  AudioPro.syncFromNative();
}, []);

play(options?: AudioProPlayOptions): void

// Simple resume
AudioPro.play();

// Start at 30 s with an auth header
AudioPro.play({
  startTimeMs: 30_000,
  headers: { audio: { Authorization: 'Bearer token' } },
});

pause(): void

AudioPro.pause();

stop(): void

AudioPro.stop();

seekTo(positionMs: number): void

// Jump to 1 minute 30 seconds
AudioPro.seekTo(90_000);

seekBy(offsetMs: number): void

AudioPro.seekBy(30_000);  // +30 s
AudioPro.seekBy(-10_000); // -10 s

setPlaybackSpeed(speed: number): void

AudioPro.setPlaybackSpeed(1.5); // 1.5×
AudioPro.setPlaybackSpeed(0.8); // 0.8×

setVolume(volume: number): void

AudioPro.setVolume(0.7);

setRepeatMode(mode: 'OFF' | 'ONE' | 'ALL'): void

AudioPro.setRepeatMode('ALL');

setShuffleModeEnabled(enabled: boolean): void

AudioPro.setShuffleModeEnabled(true);

setSkipSilence(enabled: boolean): void

AudioPro.setSkipSilence(true);

setProgressInterval(ms: number): void

// Emit progress every 250 ms for a high-fidelity scrubber
AudioPro.setProgressInterval(250);

addMediaItems(items: AudioProTrack | AudioProTrack[]): void

AudioPro.addMediaItems([
  { id: '1', url: 'https://cdn.example.com/track1.mp3', title: 'Track 1', artwork: 'https://cdn.example.com/art1.jpg' },
  { id: '2', url: 'https://cdn.example.com/track2.mp3', title: 'Track 2', artwork: 'https://cdn.example.com/art2.jpg' },
]);

setMediaItems(items: AudioProTrack[]): void

AudioPro.setMediaItems(playlist);
AudioPro.play();

addMediaItemsAt(index: number, items: AudioProTrack | AudioProTrack[]): void

// Insert a track at position 2
AudioPro.addMediaItemsAt(2, nextUpTrack);

removeMediaItem(index: number): void

AudioPro.removeMediaItem(3);

removeMediaItems(fromIndex: number, toIndex: number): void

// Remove tracks at indices 1, 2, 3
AudioPro.removeMediaItems(1, 4);

moveMediaItem(currentIndex: number, newIndex: number): void

// Drag-and-drop reorder callback
AudioPro.moveMediaItem(fromIndex, toIndex);

clearMediaItems(): void

AudioPro.clearMediaItems();

getMediaItems(): Promise<AudioProTrack[]>

const queue = await AudioPro.getMediaItems();
console.log(`Queue has ${queue.length} tracks`);

seekToMediaItem(index: number, positionMs?: number): void

// Jump to track 4 at the 45-second mark
AudioPro.seekToMediaItem(4, 45_000);

seekToNextMediaItem(): void

AudioPro.seekToNextMediaItem();

seekToPreviousMediaItem(): void

AudioPro.seekToPreviousMediaItem();

updateTrack(index: number, track: AudioProTrack): void

// Refresh an expiring stream URL before it expires
AudioPro.updateTrack(currentIndex, { ...currentTrack, url: freshSignedUrl });

setEqualizer(gains: number[]): void

// Boost bass and treble slightly (10 bands: 31Hz–16kHz)
AudioPro.setEqualizer([4, 2, 0, 0, 0, 0, 0, 2, 3, 3]);

setBassBoost(strength: number): void

AudioPro.setBassBoost(500); // medium bass boost

setNotificationButtons(buttons: AudioProNotificationButton[]): void

updateNotificationState(options: { liked?: boolean; disliked?: boolean; bookmarked?: boolean }): void

// After user taps the like button
AudioPro.updateNotificationState({ liked: true });

addEventListener(callback: AudioProEventCallback): EmitterSubscription

const subscription = AudioPro.addEventListener((event) => {
  switch (event.type) {
    case 'STATE_CHANGED':
      console.log('State:', event.payload?.state);
      break;
    case 'TRACK_CHANGED':
      console.log('Now playing:', event.track?.title);
      break;
    case 'PLAYBACK_ERROR':
      console.error('Error:', event.payload?.error);
      break;
  }
});

// Later — clean up
subscription.remove();

addAmbientListener(callback: AudioProAmbientEventCallback): EmitterSubscription

const sub = AudioPro.addAmbientListener((event) => {
  if (event.type === 'AMBIENT_TRACK_ENDED') {
    // Loop manually or trigger next ambient track
  }
});

sub.remove(); // when done

ambientPlay(options: AmbientAudioPlayOptions): void

AudioPro.ambientPlay({
  url: 'https://cdn.example.com/rain.mp3',
  loop: true,
});

ambientStop(): void

AudioPro.ambientStop();

ambientPause(): void

AudioPro.ambientPause();

ambientResume(): void

AudioPro.ambientResume();

ambientSeekTo(positionMs: number): void

AudioPro.ambientSeekTo(10_000); // seek to 10 s

ambientSetVolume(volume: number): void

// Duck ambient audio when main track starts
AudioPro.ambientSetVolume(0.3);

getCacheSize(): Promise<number>

const bytes = await AudioPro.getCacheSize();
const mb = (bytes / (1024 * 1024)).toFixed(1);
console.log(`Cache size: ${mb} MB`);

clearCache(): Promise<boolean>

const cleared = await AudioPro.clearCache();
if (cleared) {
  console.log('Cache cleared');
}

startSleepTimer(seconds: number): void

// Pause after 30 minutes
AudioPro.startSleepTimer(30 * 60);

cancelSleepTimer(): void

AudioPro.cancelSleepTimer();

getTimings(): { position: number; duration: number }

const { position, duration } = AudioPro.getTimings();

getPlaybackState(): AudioProState

if (AudioPro.getPlaybackState() === 'PLAYING') {
  AudioPro.pause();
}

getCurrentMediaItem(): AudioProTrack | null

const track = AudioPro.getCurrentMediaItem();
console.log(track?.title);

getCurrentMediaItemIndex(): number

const index = AudioPro.getCurrentMediaItemIndex();

getPlaybackSpeed(): number

const speed = AudioPro.getPlaybackSpeed(); // e.g. 1.5

getVolume(): number

const vol = AudioPro.getVolume();

getError(): AudioProPlaybackErrorPayload | null

const err = AudioPro.getError();
if (err) {
  console.error(err.error, err.errorCode);
}

getProgressInterval(): number

const interval = AudioPro.getProgressInterval(); // e.g. 1000