@javascriptcommon/react-native-track-player 1.2.9 → 4.1.4

package/web/TrackPlayer/Player.ts

@@ -0,0 +1,201 @@
+import { State } from '../../src/constants/State';
+import type { Track, Progress, PlaybackState } from '../../src/interfaces';
+import { SetupNotCalledError } from './SetupNotCalledError';
+
+export class Player {
+  protected hasInitialized: boolean = false;
+  protected element?: HTMLMediaElement;
+  protected player?: shaka.Player;
+  protected _current?: Track = undefined;
+  protected _playWhenReady: boolean = false;
+  protected _state: PlaybackState = { state: State.None };
+
+  // current getter/setter
+  public get current(): Track | undefined {
+    return this._current;
+  }
+  public set current(cur: Track | undefined) {
+    this._current = cur;
+  }
+
+  // state getter/setter
+  public get state(): PlaybackState {
+    return this._state;
+  }
+  public set state(newState: PlaybackState) {
+    this._state = newState;
+  }
+
+  // playWhenReady getter/setter
+  public get playWhenReady(): boolean {
+    return this._playWhenReady;
+  }
+  public set playWhenReady(pwr: boolean) {
+    this._playWhenReady = pwr;
+  }
+
+  async setupPlayer() {
+    // shaka only runs in a browser
+    if (typeof window === 'undefined') return;
+    if (this.hasInitialized === true) {
+      // TODO: double check the structure of this error message
+      throw { code: 'player_already_initialized', message: 'The player has already been initialized via setupPlayer.' };
+    }
+
+    // @ts-ignore
+    const shaka = (await import('shaka-player/dist/shaka-player.ui')).default;
+    // Install built-in polyfills to patch browser incompatibilities.
+    shaka.polyfill.installAll();
+    // Check to see if the browser supports the basic APIs Shaka needs.
+    if (!shaka.Player.isBrowserSupported()) {
+      // This browser does not have the minimum set of APIs we need.
+      this.state = {
+        state: State.Error,
+        error: {
+          code: 'not_supported',
+          message: 'Browser not supported.',
+        },
+      };
+      throw new Error('Browser not supported.');
+    }
+
+    // build dom element and attach shaka-player
+    this.element = document.createElement('audio');
+    this.element.setAttribute('id', 'react-native-track-player');
+    this.player = new shaka.Player();
+    this.player?.attach(this.element);
+
+    // Listen for relevant events events.
+    this.player!.addEventListener('error', (error: any) => {
+      // Extract the shaka.util.Error object from the event.
+      this.onError(error.detail);
+    });
+    this.element.addEventListener('ended', this.onStateUpdate.bind(this, State.Ended));
+    this.element.addEventListener('playing', this.onStateUpdate.bind(this, State.Playing));
+    this.element.addEventListener('pause', this.onStateUpdate.bind(this, State.Paused));
+    this.player!.addEventListener('loading', this.onStateUpdate.bind(this, State.Loading));
+    this.player!.addEventListener('loaded', this.onStateUpdate.bind(this, State.Ready));
+    this.player!.addEventListener('buffering', ({ buffering }: any) => {
+      if (buffering === true) {
+        this.onStateUpdate(State.Buffering);
+      }
+    });
+
+    // Attach player to the window to make it easy to access in the JS console.
+    // @ts-ignore
+    window.rntp = this.player;
+    this.hasInitialized = true;
+  }
+
+  /**
+   * event handlers
+   */
+  protected onStateUpdate(state: Exclude<State, State.Error>) {
+    this.state = { state };
+ }
+
+  protected onError(error: any) {
+    // unload the current track to allow for clean playback on other
+    this.player?.unload();
+    this.state = {
+      state: State.Error,
+      error: {
+        code: error.code.toString(),
+        message: error.message,
+      },
+    };
+
+    // Log the error.
+    console.debug('Error code', error.code, 'object', error);
+  }
+
+  /**
+   * player control
+   */
+  public async load(track: Track) {
+    if (!this.player) throw new SetupNotCalledError();
+    await this.player.load(track.url as string);
+    this.current = track;
+  }
+
+  public async retry() {
+    if (!this.player) throw new SetupNotCalledError();
+    this.player.retryStreaming();
+  }
+
+  public async stop() {
+    if (!this.player) throw new SetupNotCalledError();
+    this.current = undefined;
+    await this.player.unload()
+  }
+
+  public play() {
+    if (!this.element) throw new SetupNotCalledError();
+    this.playWhenReady = true;
+    return this.element.play()
+      .catch(err => {
+        console.error(err);
+      })
+    ;
+  }
+
+  public pause() {
+    if (!this.element) throw new SetupNotCalledError();
+    this.playWhenReady = false;
+    return this.element.pause();
+  }
+
+  public setRate(rate: number) {
+    if (!this.element) throw new SetupNotCalledError();
+    return this.element.playbackRate = rate;
+  }
+
+  public getRate() {
+    if (!this.element) throw new SetupNotCalledError();
+    return this.element.playbackRate;
+  }
+
+  public seekBy(offset: number) {
+    if (!this.element) throw new SetupNotCalledError();
+    this.element.currentTime += offset;
+  }
+
+  public seekTo(seconds: number) {
+    if (!this.element) throw new SetupNotCalledError();
+    this.element.currentTime = seconds;
+  }
+
+  public setVolume(volume: number) {
+    if (!this.element) throw new SetupNotCalledError();
+    this.element.volume = volume;
+  }
+
+  public getVolume() {
+    if (!this.element) throw new SetupNotCalledError();
+    return this.element.volume;
+  }
+
+  public getDuration() {
+    if (!this.element) throw new SetupNotCalledError();
+    return this.element.duration
+  }
+
+  public getPosition() {
+    if (!this.element) throw new SetupNotCalledError();
+    return this.element.currentTime
+  }
+
+  public getProgress(): Progress {
+    if (!this.element) throw new SetupNotCalledError();
+    return {
+      position: this.element.currentTime,
+      duration: this.element.duration || 0,
+      buffered: 0, // TODO: this.element.buffered.end,
+    }
+  }
+
+  public getBufferedPosition() {
+    if (!this.element) throw new SetupNotCalledError();
+    return this.element.buffered.end;
+  }
+}

package/web/TrackPlayer/PlaylistPlayer.ts

@@ -0,0 +1,215 @@
+import { Player } from './Player';
+
+import type { Track } from '../../src/interfaces';
+import {RepeatMode} from './RepeatMode';
+import { State } from '../../src';
+
+export class PlaylistPlayer extends Player {
+  // TODO: use immer to make the `playlist` immutable
+  protected playlist: Track[] = [];
+  protected lastIndex?: number;
+  protected _currentIndex?: number;
+  protected repeatMode: RepeatMode = RepeatMode.Off;
+
+  protected async onStateUpdate(state: Exclude<State, State.Error>) {
+    super.onStateUpdate(state);
+
+    if (state === State.Ended) {
+      await this.onTrackEnded();
+    }
+  }
+
+  protected async onTrackEnded() {
+    switch (this.repeatMode) {
+      case RepeatMode.Track:
+        if (this.currentIndex !== undefined) {
+          await this.goToIndex(this.currentIndex);
+        }
+        break;
+      case RepeatMode.Playlist:
+        if (this.currentIndex === this.playlist.length - 1) {
+          await this.goToIndex(0);
+        } else {
+          await this.skipToNext();
+        }
+        break;
+      default:
+        try {
+          await this.skipToNext();
+        } catch (err) {
+          if ((err as Error).message !== 'playlist_exhausted') {
+            throw err;
+          }
+          this.onPlaylistEnded();
+        }
+        break;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  protected onPlaylistEnded() {}
+
+  protected get currentIndex() {
+    return this._currentIndex;
+  }
+
+  protected set currentIndex(current: number | undefined) {
+    this.lastIndex = this.currentIndex;
+    this._currentIndex = current;
+  }
+
+  protected async goToIndex(index: number, initialPosition?: number) {
+    const track = this.playlist[index];
+
+    if (!track) {
+      throw new Error('playlist_exhausted');
+    }
+
+    if (this.currentIndex !== index) {
+      this.currentIndex = index;
+      await this.load(track);
+    }
+
+    if (initialPosition) {
+      this.seekTo(initialPosition);
+    }
+
+    if (this.playWhenReady) {
+      await this.play();
+    }
+  }
+
+  public async add(tracks: Track[], insertBeforeIndex?: number) {
+    if (insertBeforeIndex !== -1 && insertBeforeIndex !== undefined) {
+      this.playlist.splice(insertBeforeIndex, 0, ...tracks);
+    } else {
+      this.playlist.push(...tracks);
+    }
+
+    if (this.currentIndex === undefined) {
+      await this.goToIndex(0);
+    }
+  }
+
+  public async skip(index: number, initialPosition?: number) {
+    const track = this.playlist[index];
+
+    if (track === undefined) {
+      throw new Error('index out of bounds');
+    }
+
+    await this.goToIndex(index, initialPosition);
+  }
+
+  public async skipToNext(initialPosition?: number) {
+    if (this.currentIndex === undefined) return;
+
+    const index = this.currentIndex + 1;
+    await this.goToIndex(index, initialPosition);
+  }
+
+  public async skipToPrevious(initialPosition?: number) {
+    if (this.currentIndex === undefined) return;
+
+    const index = this.currentIndex - 1;
+    await this.goToIndex(index, initialPosition);
+  }
+
+  public getTrack(index: number): Track | null {
+    const track = this.playlist[index];
+    return track || null;
+  }
+
+  public setRepeatMode(mode: RepeatMode) {
+    this.repeatMode = mode;
+  }
+
+  public getRepeatMode() {
+    return this.repeatMode;
+  }
+
+  public async remove(indexes: number[]) {
+    const idxMap = indexes.reduce<Record<number, boolean>>((acc, elem) => {
+      acc[elem] = true
+      return acc;
+    }, {});
+    let isCurrentRemoved = false;
+    this.playlist = this.playlist.filter((_track, idx) => {
+      const keep = !idxMap[idx]
+
+      if (!keep && idx === this.currentIndex) {
+        isCurrentRemoved = true;
+      }
+
+      return keep;
+    });
+
+    if (this.currentIndex === undefined) {
+      return;
+    }
+
+    const hasItems = this.playlist.length > 0;
+    if (isCurrentRemoved && hasItems) {
+      await this.goToIndex(this.currentIndex % this.playlist.length);
+    } else if (isCurrentRemoved) {
+      await this.stop();
+    }
+  }
+
+  public async stop() {
+    await super.stop();
+    this.currentIndex = undefined;
+  }
+
+  public async reset() {
+    await this.stop();
+    this.playlist = [];
+  }
+
+  public async removeUpcomingTracks() {
+    if (this.currentIndex === undefined) return;
+    this.playlist = this.playlist.slice(0, this.currentIndex + 1);
+  }
+
+  public async move(fromIndex: number, toIndex: number): Promise<void> {
+    if (!this.playlist[fromIndex]) {
+      throw new Error('index out of bounds');
+    }
+
+    if (this.currentIndex === fromIndex) {
+      throw new Error('you cannot move the currently playing track');
+    }
+
+    if (this.currentIndex === toIndex) {
+      throw new Error('you cannot replace the currently playing track');
+    }
+
+    // calculate `currentIndex` after move
+    let shift: number | undefined = undefined;
+    if (this.currentIndex) {
+      if (fromIndex < this.currentIndex && toIndex > this.currentIndex) {
+        shift = -1;
+      } else if (fromIndex > this.currentIndex && toIndex < this.currentIndex) {
+        shift = + 1;
+      }
+    }
+
+    // move the track
+    const fromItem = this.playlist[fromIndex];
+    this.playlist.splice(fromIndex, 1);
+    this.playlist.splice(toIndex, 0, fromItem);
+
+    if (this.currentIndex && shift) {
+      this.currentIndex = this.currentIndex + shift
+    }
+  }
+
+  // TODO
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  public updateMetadataForTrack(index: number, metadata: Partial<Track>) {}
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  public clearNowPlayingMetadata() {}
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  public updateNowPlayingMetadata(metadata: Partial<Track>) {}
+
+}

package/web/TrackPlayer/RepeatMode.ts

@@ -0,0 +1,6 @@
+
+export enum RepeatMode {
+  Off = 'REPEAT_OFF',
+  Track = 'REPEAT_TRACK',
+  Playlist = 'REPEAT_PLAYLIST',
+}

package/web/TrackPlayer/SetupNotCalledError.ts

@@ -0,0 +1,5 @@
+export class SetupNotCalledError extends Error {
+  constructor() {
+    super('You must call `setupPlayer` prior to interacting with the player.');
+  }
+}

package/web/TrackPlayer/index.ts

@@ -0,0 +1,3 @@
+export * from './Player';
+export * from './PlaylistPlayer';
+export * from './RepeatMode';

package/web/TrackPlayerModule.ts

@@ -0,0 +1,181 @@
+import { DeviceEventEmitter } from 'react-native';
+
+import { Event, PlaybackState, State } from '../src';
+import type { Track, UpdateOptions } from '../src';
+import { PlaylistPlayer, RepeatMode } from './TrackPlayer';
+import { SetupNotCalledError } from './TrackPlayer/SetupNotCalledError';
+
+export class TrackPlayerModule extends PlaylistPlayer {
+  protected emitter = DeviceEventEmitter;
+  protected progressUpdateEventInterval: any;
+
+  // Capabilities
+  public readonly CAPABILITY_PLAY = 'CAPABILITY_PLAY';
+  public readonly CAPABILITY_PLAY_FROM_ID = 'CAPABILITY_PLAY_FROM_ID';
+  public readonly CAPABILITY_PLAY_FROM_SEARCH = 'CAPABILITY_PLAY_FROM_SEARCH';
+  public readonly CAPABILITY_PAUSE = 'CAPABILITY_PAUSE';
+  public readonly CAPABILITY_STOP = 'CAPABILITY_STOP';
+  public readonly CAPABILITY_SEEK_TO = 'CAPABILITY_SEEK_TO';
+  public readonly CAPABILITY_SKIP = 'CAPABILITY_SKIP';
+  public readonly CAPABILITY_SKIP_TO_NEXT = 'CAPABILITY_SKIP_TO_NEXT';
+  public readonly CAPABILITY_SKIP_TO_PREVIOUS = 'CAPABILITY_SKIP_TO_PREVIOUS';
+  public readonly CAPABILITY_JUMP_FORWARD = 'CAPABILITY_JUMP_FORWARD';
+  public readonly CAPABILITY_JUMP_BACKWARD = 'CAPABILITY_JUMP_BACKWARD';
+  public readonly CAPABILITY_SET_RATING = 'CAPABILITY_SET_RATING';
+  public readonly CAPABILITY_LIKE = 'CAPABILITY_LIKE';
+  public readonly CAPABILITY_DISLIKE = 'CAPABILITY_DISLIKE';
+  public readonly CAPABILITY_BOOKMARK = 'CAPABILITY_BOOKMARK';
+
+  // States
+  public readonly STATE_NONE = 'STATE_NONE';
+  public readonly STATE_READY = 'STATE_READY';
+  public readonly STATE_PLAYING = 'STATE_PLAYING';
+  public readonly STATE_PAUSED = 'STATE_PAUSED';
+  public readonly STATE_STOPPED = 'STATE_STOPPED';
+  public readonly STATE_BUFFERING = 'STATE_BUFFERING';
+  public readonly STATE_CONNECTING = 'STATE_CONNECTING';
+
+  // Rating Types
+  public readonly RATING_HEART = 'RATING_HEART';
+  public readonly RATING_THUMBS_UP_DOWN = 'RATING_THUMBS_UP_DOWN';
+  public readonly RATING_3_STARS = 'RATING_3_STARS';
+  public readonly RATING_4_STARS = 'RATING_4_STARS';
+  public readonly RATING_5_STARS = 'RATING_5_STARS';
+  public readonly RATING_PERCENTAGE = 'RATING_PERCENTAGE';
+
+  // Repeat Modes
+  public readonly REPEAT_OFF = RepeatMode.Off;
+  public readonly REPEAT_TRACK = RepeatMode.Track;
+  public readonly REPEAT_QUEUE = RepeatMode.Playlist;
+
+  // Pitch Algorithms
+  public readonly PITCH_ALGORITHM_LINEAR = 'PITCH_ALGORITHM_LINEAR';
+  public readonly PITCH_ALGORITHM_MUSIC = 'PITCH_ALGORITHM_MUSIC';
+  public readonly PITCH_ALGORITHM_VOICE = 'PITCH_ALGORITHM_VOICE';
+
+  // observe and emit state changes
+  public get state(): PlaybackState {
+    return super.state;
+  }
+  public set state(newState: PlaybackState) {
+    super.state = newState;
+    this.emitter.emit(Event.PlaybackState, newState);
+  }
+
+  public async updateOptions(options: UpdateOptions) {
+    this.setupProgressUpdates(options.progressUpdateEventInterval);
+  }
+
+  protected setupProgressUpdates(interval?: number) {
+    // clear and reset interval
+    this.clearUpdateEventInterval();
+    if (interval) {
+      this.clearUpdateEventInterval()
+      this.progressUpdateEventInterval = setInterval(
+        async () => {
+          if (this.state.state === State.Playing) {
+            const progress = await this.getProgress()
+            this.emitter.emit(Event.PlaybackProgressUpdated, {
+              ...progress,
+              track: this.currentIndex,
+            });
+          }
+        },
+        interval * 1000,
+      )
+    }
+  }
+
+  protected clearUpdateEventInterval() {
+    if (this.progressUpdateEventInterval) {
+      clearInterval(this.progressUpdateEventInterval);
+    }
+  }
+
+  protected async onTrackEnded() {
+    const position = this.element!.currentTime;
+    await super.onTrackEnded();
+
+    this.emitter.emit(Event.PlaybackTrackChanged, {
+      track: this.lastIndex,
+      position,
+      nextTrack: this.currentIndex,
+    });
+  }
+
+  protected async onPlaylistEnded() {
+    await super.onPlaylistEnded();
+    this.emitter.emit(Event.PlaybackQueueEnded, {
+      track: this.currentIndex,
+      position: this.element!.currentTime,
+    });
+  }
+
+  public get playWhenReady(): boolean {
+    return super.playWhenReady;
+  }
+
+  public set playWhenReady(pwr: boolean) {
+    const didChange = pwr !== this._playWhenReady;
+    super.playWhenReady = pwr;
+
+    if (didChange) {
+      this.emitter.emit(Event.PlaybackPlayWhenReadyChanged, { playWhenReady: this._playWhenReady });
+    }
+  }
+
+  public getPlayWhenReady(): boolean {
+    return this.playWhenReady;
+  }
+
+  public setPlayWhenReady(pwr: boolean): boolean {
+    this.playWhenReady = pwr;
+    return this.playWhenReady;
+  }
+
+  public async load(track: Track) {
+    if (!this.element) throw new SetupNotCalledError();
+    const lastTrack = this.current;
+    const lastPosition = this.element.currentTime;
+    await super.load(track);
+
+    this.emitter.emit(Event.PlaybackActiveTrackChanged, {
+      lastTrack,
+      lastPosition,
+      lastIndex: this.lastIndex,
+      index: this.currentIndex,
+      track,
+    });
+  }
+
+  public getQueue(): Track[] {
+    return this.playlist;
+  }
+
+  public async setQueue(queue: Track[]) {
+    await this.stop();
+    this.playlist = queue;
+  }
+
+  public getActiveTrack(): Track | undefined {
+    return this.current;
+  }
+
+  public getActiveTrackIndex(): number | undefined {
+    // per the existing spec, this should throw if setup hasn't been called
+    if (!this.element || !this.player) throw new SetupNotCalledError();
+    return this.currentIndex;
+  }
+
+  /**
+   * @deprecated
+   * @returns State
+   */
+  public getState(): State {
+    return this.state.state;
+  }
+
+  public getPlaybackState(): PlaybackState {
+    return this.state;
+  }
+};

package/web/index.ts

@@ -0,0 +1,4 @@
+import {TrackPlayerModule} from './TrackPlayerModule';
+
+const module = new TrackPlayerModule();
+export default module;

package/CHANGELOG.md

@@ -1,75 +0,0 @@
-## [0.10.5](https://github.com/tanguyantoine/react-native-music-control/compare/v0.10.4...v0.10.5) (2019-07-10)
-
-
-### Bug Fixes
-
-* **android:** error can't find symbol Notification ([b572320](https://github.com/tanguyantoine/react-native-music-control/commit/b572320))
-* **android:** migrate support libraries to androidx ([260f720](https://github.com/tanguyantoine/react-native-music-control/commit/260f720)), closes [#280](https://github.com/tanguyantoine/react-native-music-control/issues/280)
-* **package.json:** remove unused rnpm object to fix warning in RN 0.60 ([fc48d40](https://github.com/tanguyantoine/react-native-music-control/commit/fc48d40))
-* bump version ([9e6991a](https://github.com/tanguyantoine/react-native-music-control/commit/9e6991a))
-* bump version ([3fccd12](https://github.com/tanguyantoine/react-native-music-control/commit/3fccd12))
-
-## [0.10.4](https://github.com/tanguyantoine/react-native-music-control/compare/v0.10.3...v0.10.4) (2019-05-24)
-
-
-### Bug Fixes
-
-* Illegal null AudioFocusRequest exception  ([#261](https://github.com/tanguyantoine/react-native-music-control/issues/261)) ([351a1ab](https://github.com/tanguyantoine/react-native-music-control/commit/351a1ab)), closes [#260](https://github.com/tanguyantoine/react-native-music-control/issues/260)
-
-## [0.10.3](https://github.com/tanguyantoine/react-native-music-control/compare/v0.10.2...v0.10.3) (2019-05-23)
-
-
-### Bug Fixes
-
-* move variables around and trigger deploy ([6703bf7](https://github.com/tanguyantoine/react-native-music-control/commit/6703bf7))
-
-## [0.10.2](https://github.com/tanguyantoine/react-native-music-control/compare/v0.10.1...v0.10.2) (2019-04-26)
-
-
-### Bug Fixes
-
-* **ios:** call beginReceivingRemoteControlEvents ([442b77b](https://github.com/tanguyantoine/react-native-music-control/commit/442b77b))
-* **ios:** update playback state using :setPlaybackState in iOS 11+ ([b2b1acc](https://github.com/tanguyantoine/react-native-music-control/commit/b2b1acc)), closes [#242](https://github.com/tanguyantoine/react-native-music-control/issues/242)
-
-## [0.10.1](https://github.com/tanguyantoine/react-native-music-control/compare/v0.10.0...v0.10.1) (2019-04-26)
-
-
-### Bug Fixes
-
-* do no skip prepack script ([51a2532](https://github.com/tanguyantoine/react-native-music-control/commit/51a2532))
-
-# [0.10.0](https://github.com/tanguyantoine/react-native-music-control/compare/v0.9.9...v0.10.0) (2019-04-25)
-
-
-### Features
-
-* Android interuption ([#240](https://github.com/tanguyantoine/react-native-music-control/issues/240)) ([7c5fe92](https://github.com/tanguyantoine/react-native-music-control/commit/7c5fe92))
-
-## [0.9.9](https://github.com/tanguyantoine/react-native-music-control/compare/v0.9.8...v0.9.9) (2019-02-09)
-
-
-### Bug Fixes
-
-* bump version ([c0c7754](https://github.com/tanguyantoine/react-native-music-control/commit/c0c7754))
-
-## [0.9.8](https://github.com/tanguyantoine/react-native-music-control/compare/v0.9.7...v0.9.8) (2019-02-01)
-
-
-### Bug Fixes
-
-* controls not showing on Android lock screen ([#227](https://github.com/tanguyantoine/react-native-music-control/issues/227)) ([51a6fc2](https://github.com/tanguyantoine/react-native-music-control/commit/51a6fc2))
-* remove extra pause event related to app suspension in IOS10+ ([6ee2a86](https://github.com/tanguyantoine/react-native-music-control/commit/6ee2a86))
-
-## [0.9.7](https://github.com/tanguyantoine/react-native-music-control/compare/v0.9.6...v0.9.7) (2019-01-11)
-
-
-### Bug Fixes
-
-* stopForeground service ([36b1922](https://github.com/tanguyantoine/react-native-music-control/commit/36b1922))
-
-## [0.9.6](https://github.com/tanguyantoine/react-native-music-control/compare/v0.9.5...v0.9.6) (2019-01-05)
-
-
-### Bug Fixes
-
-* release ([6efc1ad](https://github.com/tanguyantoine/react-native-music-control/commit/6efc1ad))