@react-native-ohos/audio-toolkit 2.0.4-rc.1 → 2.0.4-rc.3

package/src/Player.js

@@ -1,329 +1,329 @@
-import { DeviceEventEmitter, NativeAppEventEmitter, Platform } from 'react-native';
-import RCTAudioPlayer from './PlayerModule'
-import async from 'async';
-import EventEmitter from 'eventemitter3';
-import MediaStates from '@react-native-community/audio-toolkit/src/MediaStates';
-// Only import specific items from lodash to keep build size down
-import filter from 'lodash/filter';
-import identity from 'lodash/identity';
-import last from 'lodash/last';
-import noop from 'lodash/noop';
-
-let playerId = 0;
-
-export const PlaybackCategories = {
-  Playback: 1,
-  Ambient: 2,
-  SoloAmbient: 3,
-}
-
-const defaultPlayerOptions = {
-  autoDestroy: true,
-  continuesToPlayInBackground: false,
-  category: PlaybackCategories.Playback,
-  mixWithOthers: false,
-};
-
-/**
- * Represents a media player
- * @constructor
- */
-class Player extends EventEmitter {
-  constructor(path, options = defaultPlayerOptions) {
-    super();
-
-    this._path = path;
-
-    if (options == null) {
-      this._options = defaultPlayerOptions;
-    } else {
-      // Make sure all required options have values
-      if (options.autoDestroy == null)
-        options.autoDestroy = defaultPlayerOptions.autoDestroy;
-      if (options.continuesToPlayInBackground == null)
-        options.continuesToPlayInBackground = defaultPlayerOptions.continuesToPlayInBackground;
-      if (options.category == null)
-        options.category = defaultPlayerOptions.category;
-      if (options.mixWithOthers == null)
-        options.mixWithOthers = defaultPlayerOptions.mixWithOthers;
-
-      this._options = options;
-    }
-
-    this._playerId = playerId++;
-    this._reset();
-
-    const appEventEmitter = Platform.OS === 'ios' ? NativeAppEventEmitter : DeviceEventEmitter;
-
-    appEventEmitter.addListener(`RCTAudioPlayerEvent:${this._playerId}`, (payload: Event) => {
-      this._handleEvent(payload.event, payload.data);
-    });
-  }
-
-  _reset() {
-    this._state = MediaStates.IDLE;
-    this._volume = 1.0;
-    this._pan = 0.0;
-    this._speed = 1.0;
-    this._wakeLock = false;
-    this._duration = -1;
-    this._position = -1;
-    this._lastSync = -1;
-    this._looping = false;
-  }
-
-  _storeInfo(info) {
-    if (!info) {
-      return;
-    }
-
-    this._duration = info.duration;
-    this._position = info.position;
-    this._lastSync = Date.now();
-  }
-
-  _updateState(err, state, results) {
-    this._state = err ? MediaStates.ERROR : state;
-
-    if (err || !results) {
-      return;
-    }
-
-    // Use last truthy value from results array as new media info
-    const info = last(filter(results, identity));
-    this._storeInfo(info);
-  }
-
-  _handleEvent(event, data) {
-    switch (event) {
-      case 'progress':
-        // TODO
-        break;
-      case 'ended':
-        this._updateState(null, MediaStates.PREPARED);
-        this._position = -1;
-        break;
-      case 'info':
-        // TODO
-        break;
-      case 'error':
-        this._state = MediaStates.ERROR;
-        break;
-      case 'pause':
-        this._state = MediaStates.PAUSED;
-        this._storeInfo(data.info);
-        break;
-      case 'forcePause':
-        this.pause();
-        break;
-      case 'looped':
-        this._position = 0;
-        this._lastSync = Date.now();
-        break;
-    }
-
-    this.emit(event, data);
-  }
-
-  prepare(callback = noop) {
-    this._updateState(null, MediaStates.PREPARING);
-
-    const tasks = [];
-
-    // Prepare player
-    tasks.push((next) => {
-      RCTAudioPlayer.prepare(this._playerId, this._path, this._options, next);
-    });
-
-    // Set initial values for player options
-    tasks.push((next) => {
-      RCTAudioPlayer.set(
-        this._playerId,
-        {
-          volume: this._volume,
-          pan: this._pan,
-          wakeLock: this._wakeLock,
-          looping: this._looping,
-          speed: this._speed,
-        },
-        next,
-      );
-    });
-
-    async.series(tasks, (err, results) => {
-      this._updateState(err, MediaStates.PREPARED, results);
-      callback(err);
-    });
-
-    return this;
-  }
-
-  play(callback = noop) {
-    const tasks = [];
-    // Make sure player is prepared
-    if (this._state === MediaStates.IDLE) {
-      tasks.push((next) => {
-        this.prepare(next);
-      });
-    }
-
-    // Start playback
-    tasks.push((next) => {
-      RCTAudioPlayer.play(this._playerId, next);
-    });
-    async.series(tasks, (err, results) => {
-      this._updateState(err, MediaStates.PLAYING, results);
-      callback(err);
-    });
-
-    return this;
-  }
-
-  pause(callback = noop) {
-    RCTAudioPlayer.pause(this._playerId, (err, results) => {
-      // Android emits a pause event on the native side
-      if (Platform.OS === 'ios' || Platform.OS === 'harmony') {
-        this._updateState(err, MediaStates.PAUSED, [results]);
-      }
-      callback(err);
-    });
-
-    return this;
-  }
-
-  playPause(callback = noop) {
-    if (this._state === MediaStates.PLAYING) {
-      this.pause((err) => {
-        callback(err, true);
-      });
-    } else {
-      this.play((err) => {
-        callback(err, false);
-      });
-    }
-
-    return this;
-  }
-
-  stop(callback = noop) {
-    RCTAudioPlayer.stop(this._playerId, (err, results) => {
-      this._updateState(err, MediaStates.PREPARED);
-      this._position = -1;
-      callback(err);
-    });
-
-    return this;
-  }
-
-  destroy(callback = noop) {
-    this._reset();
-    RCTAudioPlayer.destroy(this._playerId, callback);
-  }
-
-  seek(position = 0, callback = noop) {
-    // Store old state, but not if it was already SEEKING
-    if (this._state != MediaStates.SEEKING) {
-      this._preSeekState = this._state;
-    }
-
-    this._updateState(null, MediaStates.SEEKING);
-    RCTAudioPlayer.seek(this._playerId, position, (err, results) => {
-      if (err && err.err === 'seekfail') {
-        // Seek operation was cancelled; ignore
-        return;
-      }
-      this._updateState(err, this._preSeekState, [results]);
-      callback(err);
-    });
-  }
-
-  _setIfInitialized(options, callback = noop) {
-    if (this._state >= MediaStates.PREPARED) {
-      RCTAudioPlayer.set(this._playerId, options, callback);
-    }
-  }
-
-  set volume(value) {
-    this._volume = value;
-    this._setIfInitialized({ volume: value });
-  }
-
-  set currentTime(value) {
-    this.seek(value);
-  }
-
-  set wakeLock(value) {
-    this._wakeLock = value;
-    this._setIfInitialized({ wakeLock: value });
-  }
-
-  set looping(value) {
-    this._looping = value;
-    this._setIfInitialized({ looping: value });
-  }
-
-  set speed(value) {
-    this._speed = value;
-    this._setIfInitialized({ speed: value });
-  }
-
-  get currentTime() {
-    // Queue up an async call to get an accurate current time
-    RCTAudioPlayer.getCurrentTime(this._playerId, (err, results) => {
-      this._storeInfo(results);
-    });
-
-    if (this._position < 0) {
-      return -1;
-    }
-
-    if (this._state === MediaStates.PLAYING) {
-      // Estimate the current time based on the latest info we received
-      let pos = this._position + (Date.now() - this._lastSync) * this._speed;
-      pos = Math.min(pos, this._duration);
-      return pos;
-    }
-
-    return this._position;
-  }
-
-  get volume() {
-    return this._volume;
-  }
-  get looping() {
-    return this._looping;
-  }
-  get duration() {
-    return this._duration;
-  }
-  get speed() {
-    return this._speed;
-  }
-
-  get state() {
-    return this._state;
-  }
-  get canPlay() {
-    return this._state >= MediaStates.PREPARED;
-  }
-  get canStop() {
-    return this._state >= MediaStates.PLAYING;
-  }
-  get canPrepare() {
-    return this._state == MediaStates.IDLE;
-  }
-  get isPlaying() {
-    return this._state == MediaStates.PLAYING;
-  }
-  get isStopped() {
-    return this._state <= MediaStates.PREPARED;
-  }
-  get isPaused() {
-    return this._state == MediaStates.PAUSED;
-  }
-  get isPrepared() {
-    return this._state == MediaStates.PREPARED;
-  }
-}
-
-export default Player;
+import { DeviceEventEmitter, NativeAppEventEmitter, Platform } from 'react-native';
+import RCTAudioPlayer from './PlayerModule'
+import async from 'async';
+import EventEmitter from 'eventemitter3';
+import MediaStates from '@react-native-community/audio-toolkit/src/MediaStates';
+// Only import specific items from lodash to keep build size down
+import filter from 'lodash/filter';
+import identity from 'lodash/identity';
+import last from 'lodash/last';
+import noop from 'lodash/noop';
+
+let playerId = 0;
+
+export const PlaybackCategories = {
+  Playback: 1,
+  Ambient: 2,
+  SoloAmbient: 3,
+}
+
+const defaultPlayerOptions = {
+  autoDestroy: true,
+  continuesToPlayInBackground: false,
+  category: PlaybackCategories.Playback,
+  mixWithOthers: false,
+};
+
+/**
+ * Represents a media player
+ * @constructor
+ */
+class Player extends EventEmitter {
+  constructor(path, options = defaultPlayerOptions) {
+    super();
+
+    this._path = path;
+
+    if (options == null) {
+      this._options = defaultPlayerOptions;
+    } else {
+      // Make sure all required options have values
+      if (options.autoDestroy == null)
+        options.autoDestroy = defaultPlayerOptions.autoDestroy;
+      if (options.continuesToPlayInBackground == null)
+        options.continuesToPlayInBackground = defaultPlayerOptions.continuesToPlayInBackground;
+      if (options.category == null)
+        options.category = defaultPlayerOptions.category;
+      if (options.mixWithOthers == null)
+        options.mixWithOthers = defaultPlayerOptions.mixWithOthers;
+
+      this._options = options;
+    }
+
+    this._playerId = playerId++;
+    this._reset();
+
+    const appEventEmitter = Platform.OS === 'ios' ? NativeAppEventEmitter : DeviceEventEmitter;
+
+    appEventEmitter.addListener(`RCTAudioPlayerEvent:${this._playerId}`, (payload: Event) => {
+      this._handleEvent(payload.event, payload.data);
+    });
+  }
+
+  _reset() {
+    this._state = MediaStates.IDLE;
+    this._volume = 1.0;
+    this._pan = 0.0;
+    this._speed = 1.0;
+    this._wakeLock = false;
+    this._duration = -1;
+    this._position = -1;
+    this._lastSync = -1;
+    this._looping = false;
+  }
+
+  _storeInfo(info) {
+    if (!info) {
+      return;
+    }
+
+    this._duration = info.duration;
+    this._position = info.position;
+    this._lastSync = Date.now();
+  }
+
+  _updateState(err, state, results) {
+    this._state = err ? MediaStates.ERROR : state;
+
+    if (err || !results) {
+      return;
+    }
+
+    // Use last truthy value from results array as new media info
+    const info = last(filter(results, identity));
+    this._storeInfo(info);
+  }
+
+  _handleEvent(event, data) {
+    switch (event) {
+      case 'progress':
+        // TODO
+        break;
+      case 'ended':
+        this._updateState(null, MediaStates.PREPARED);
+        this._position = -1;
+        break;
+      case 'info':
+        // TODO
+        break;
+      case 'error':
+        this._state = MediaStates.ERROR;
+        break;
+      case 'pause':
+        this._state = MediaStates.PAUSED;
+        this._storeInfo(data.info);
+        break;
+      case 'forcePause':
+        this.pause();
+        break;
+      case 'looped':
+        this._position = 0;
+        this._lastSync = Date.now();
+        break;
+    }
+
+    this.emit(event, data);
+  }
+
+  prepare(callback = noop) {
+    this._updateState(null, MediaStates.PREPARING);
+
+    const tasks = [];
+
+    // Prepare player
+    tasks.push((next) => {
+      RCTAudioPlayer.prepare(this._playerId, this._path, this._options, next);
+    });
+
+    // Set initial values for player options
+    tasks.push((next) => {
+      RCTAudioPlayer.set(
+        this._playerId,
+        {
+          volume: this._volume,
+          pan: this._pan,
+          wakeLock: this._wakeLock,
+          looping: this._looping,
+          speed: this._speed,
+        },
+        next,
+      );
+    });
+
+    async.series(tasks, (err, results) => {
+      this._updateState(err, MediaStates.PREPARED, results);
+      callback(err);
+    });
+
+    return this;
+  }
+
+  play(callback = noop) {
+    const tasks = [];
+    // Make sure player is prepared
+    if (this._state === MediaStates.IDLE) {
+      tasks.push((next) => {
+        this.prepare(next);
+      });
+    }
+
+    // Start playback
+    tasks.push((next) => {
+      RCTAudioPlayer.play(this._playerId, next);
+    });
+    async.series(tasks, (err, results) => {
+      this._updateState(err, MediaStates.PLAYING, results);
+      callback(err);
+    });
+
+    return this;
+  }
+
+  pause(callback = noop) {
+    RCTAudioPlayer.pause(this._playerId, (err, results) => {
+      // Android emits a pause event on the native side
+      if (Platform.OS === 'ios' || Platform.OS === 'harmony') {
+        this._updateState(err, MediaStates.PAUSED, [results]);
+      }
+      callback(err);
+    });
+
+    return this;
+  }
+
+  playPause(callback = noop) {
+    if (this._state === MediaStates.PLAYING) {
+      this.pause((err) => {
+        callback(err, true);
+      });
+    } else {
+      this.play((err) => {
+        callback(err, false);
+      });
+    }
+
+    return this;
+  }
+
+  stop(callback = noop) {
+    RCTAudioPlayer.stop(this._playerId, (err, results) => {
+      this._updateState(err, MediaStates.PREPARED);
+      this._position = -1;
+      callback(err);
+    });
+
+    return this;
+  }
+
+  destroy(callback = noop) {
+    this._reset();
+    RCTAudioPlayer.destroy(this._playerId, callback);
+  }
+
+  seek(position = 0, callback = noop) {
+    // Store old state, but not if it was already SEEKING
+    if (this._state != MediaStates.SEEKING) {
+      this._preSeekState = this._state;
+    }
+
+    this._updateState(null, MediaStates.SEEKING);
+    RCTAudioPlayer.seek(this._playerId, position, (err, results) => {
+      if (err && err.err === 'seekfail') {
+        // Seek operation was cancelled; ignore
+        return;
+      }
+      this._updateState(err, this._preSeekState, [results]);
+      callback(err);
+    });
+  }
+
+  _setIfInitialized(options, callback = noop) {
+    if (this._state >= MediaStates.PREPARED) {
+      RCTAudioPlayer.set(this._playerId, options, callback);
+    }
+  }
+
+  set volume(value) {
+    this._volume = value;
+    this._setIfInitialized({ volume: value });
+  }
+
+  set currentTime(value) {
+    this.seek(value);
+  }
+
+  set wakeLock(value) {
+    this._wakeLock = value;
+    this._setIfInitialized({ wakeLock: value });
+  }
+
+  set looping(value) {
+    this._looping = value;
+    this._setIfInitialized({ looping: value });
+  }
+
+  set speed(value) {
+    this._speed = value;
+    this._setIfInitialized({ speed: value });
+  }
+
+  get currentTime() {
+    // Queue up an async call to get an accurate current time
+    RCTAudioPlayer.getCurrentTime(this._playerId, (err, results) => {
+      this._storeInfo(results);
+    });
+
+    if (this._position < 0) {
+      return -1;
+    }
+
+    if (this._state === MediaStates.PLAYING) {
+      // Estimate the current time based on the latest info we received
+      let pos = this._position + (Date.now() - this._lastSync) * this._speed;
+      pos = Math.min(pos, this._duration);
+      return pos;
+    }
+
+    return this._position;
+  }
+
+  get volume() {
+    return this._volume;
+  }
+  get looping() {
+    return this._looping;
+  }
+  get duration() {
+    return this._duration;
+  }
+  get speed() {
+    return this._speed;
+  }
+
+  get state() {
+    return this._state;
+  }
+  get canPlay() {
+    return this._state >= MediaStates.PREPARED;
+  }
+  get canStop() {
+    return this._state >= MediaStates.PLAYING;
+  }
+  get canPrepare() {
+    return this._state == MediaStates.IDLE;
+  }
+  get isPlaying() {
+    return this._state == MediaStates.PLAYING;
+  }
+  get isStopped() {
+    return this._state <= MediaStates.PREPARED;
+  }
+  get isPaused() {
+    return this._state == MediaStates.PAUSED;
+  }
+  get isPrepared() {
+    return this._state == MediaStates.PREPARED;
+  }
+}
+
+export default Player;