@sendbird/uikit-react-native/lib/commonjs/platform/createPlayerService.native.js

Sendbird UIKit for React Native: A feature-rich and customizable chat UI kit with messaging, channel management, and user authentication.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _reactNative = require("react-native");
var _uikitUtils = require("@sendbird/uikit-utils");
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
class AudioRecorderPlayerAdapter {
  constructor(audioRecorderModule) {
    _defineProperty(this, "module", void 0);
    this.module = new audioRecorderModule.default();
  }
  async setSubscriptionDuration(duration) {
    await this.module.setSubscriptionDuration(duration);
  }
  addPlayBackListener(callback) {
    this.module.addPlayBackListener(callback);
  }
  removePlayBackListener() {
    this.module.removePlayBackListener();
  }
  async startPlayer(uri) {
    await this.module.startPlayer(uri);
  }
  async pausePlayer() {
    await this.module.pausePlayer();
  }
  async resumePlayer() {
    await this.module.resumePlayer();
  }
  async stopPlayer() {
    await this.module.stopPlayer();
  }
  async seekToPlayer(time) {
    await this.module.seekToPlayer(time);
  }
}
class NitroSoundOrLegacyV4Adapter {
  constructor(audioRecorderModule) {
    _defineProperty(this, "module", void 0);
    this.module = audioRecorderModule.default;
  }
  setSubscriptionDuration(duration) {
    try {
      this.module.setSubscriptionDuration(duration);
    } catch (error) {
      _uikitUtils.Logger.warn('[PlayerService.Native] Failed to set subscription duration', error);
    }
  }
  addPlayBackListener(callback) {
    this.module.addPlayBackListener(callback);
  }
  removePlayBackListener() {
    this.module.removePlayBackListener();
  }
  async startPlayer(uri) {
    await this.module.startPlayer(uri);
  }
  async pausePlayer() {
    await this.module.pausePlayer();
  }
  async resumePlayer() {
    await this.module.resumePlayer();
  }
  async stopPlayer() {
    await this.module.stopPlayer();
  }
  async seekToPlayer(time) {
    await this.module.seekToPlayer(time);
  }
}
class VoicePlayer {
  constructor(adapter, permissionModule) {
    this.adapter = adapter;
    this.permissionModule = permissionModule;
    _defineProperty(this, "uri", void 0);
    _defineProperty(this, "state", 'idle');
    _defineProperty(this, "playbackSubscribers", new Set());
    _defineProperty(this, "stateSubscribers", new Set());
    _defineProperty(this, "setState", state => {
      this.state = state;
      this.stateSubscribers.forEach(callback => {
        callback(state);
      });
    });
    _defineProperty(this, "setListener", () => {
      this.adapter.addPlayBackListener(async data => {
        const stopped = data.currentPosition >= data.duration;
        if (stopped) {
          this.stop().catch(error => {
            _uikitUtils.Logger.warn('[PlayerService.Native] Failed to stop in PlayBackListener', error);
          });
        }
        if (this.state === 'playing') {
          this.playbackSubscribers.forEach(callback => {
            callback({
              currentTime: data.currentPosition,
              duration: data.duration,
              stopped
            });
          });
        }
      });
    });
    _defineProperty(this, "removeListener", () => {
      this.adapter.removePlayBackListener();
    });
    _defineProperty(this, "requestPermission", async () => {
      if (_reactNative.Platform.OS === 'android') {
        if (_reactNative.Platform.Version > 32) return true;
        const {
          READ_EXTERNAL_STORAGE
        } = this.permissionModule.PERMISSIONS.ANDROID;
        const status = await this.permissionModule.check(READ_EXTERNAL_STORAGE);
        if (status === 'granted') {
          return true;
        } else {
          const status = await this.permissionModule.request(READ_EXTERNAL_STORAGE);
          return status === 'granted';
        }
      } else {
        return true;
      }
    });
    _defineProperty(this, "addPlaybackListener", callback => {
      this.playbackSubscribers.add(callback);
      return () => {
        this.playbackSubscribers.delete(callback);
      };
    });
    _defineProperty(this, "addStateListener", callback => {
      this.stateSubscribers.add(callback);
      return () => {
        this.stateSubscribers.delete(callback);
      };
    });
    _defineProperty(this, "play", async uri => {
      if ((0, _uikitUtils.matchesOneOf)(this.state, ['idle', 'stopped'])) {
        try {
          this.setState('preparing');
          this.uri = uri;
          this.setListener();

          // FIXME: Workaround, `module.startPlayer()` caused a significant frame-drop and prevented the 'preparing' UI transition.
          await (0, _uikitUtils.sleep)(0);
          await this.adapter.startPlayer(uri);
          this.setState('playing');
        } catch (e) {
          this.setState('idle');
          this.uri = undefined;
          this.removeListener();
          throw e;
        }
      } else if ((0, _uikitUtils.matchesOneOf)(this.state, ['paused']) && this.uri === uri) {
        try {
          this.setListener();
          await this.adapter.resumePlayer();
          this.setState('playing');
        } catch (e) {
          this.removeListener();
          throw e;
        }
      }
    });
    _defineProperty(this, "pause", async () => {
      if ((0, _uikitUtils.matchesOneOf)(this.state, ['playing'])) {
        await this.adapter.pausePlayer();
        this.removeListener();
        this.setState('paused');
      }
    });
    _defineProperty(this, "stop", async () => {
      if ((0, _uikitUtils.matchesOneOf)(this.state, ['preparing', 'playing', 'paused'])) {
        await this.adapter.stopPlayer();
        this.removeListener();
        this.setState('stopped');
      }
    });
    _defineProperty(this, "reset", async () => {
      await this.stop();
      this.setState('idle');
      this.uri = undefined;
      this.playbackSubscribers.clear();
      this.stateSubscribers.clear();
    });
    _defineProperty(this, "seek", async time => {
      if ((0, _uikitUtils.matchesOneOf)(this.state, ['playing', 'paused'])) {
        await this.adapter.seekToPlayer(time);
      }
    });
    this.initialize();
  }
  initialize() {
    const setDurationResult = this.adapter.setSubscriptionDuration(0.1);
    if (setDurationResult instanceof Promise) {
      setDurationResult.catch(error => {
        _uikitUtils.Logger.warn('[PlayerService.Native] Failed to set subscription duration', error);
      });
    }
  }
}
const createNativePlayerService = modules => {
  const adapter = isNitroSoundOrLegacyV4Module(modules.audioRecorderModule) ? new NitroSoundOrLegacyV4Adapter(modules.audioRecorderModule) : new AudioRecorderPlayerAdapter(modules.audioRecorderModule);
  return new VoicePlayer(adapter, modules.permissionModule);
};
function isNitroSoundOrLegacyV4Module(module) {
  const isNitroSound = 'createSound' in module && typeof module.createSound === 'function';
  const isLegacyV4 = 'default' in module && 'getHybridObject' in module.default && typeof module.default.getHybridObject === 'function';
  if (isLegacyV4) {
    _uikitUtils.Logger.warn('react-native-audio-recorder-player is deprecated. Please use react-native-nitro-sound instead.');
  }
  return isNitroSound || isLegacyV4;
}
var _default = exports.default = createNativePlayerService;
//# sourceMappingURL=createPlayerService.native.js.map