@cloudflare/realtimekit-react-native 0.1.4-staging.1 → 0.1.4-staging.3

package/lib/commonjs/LocalMediaHandler.js

@@ -0,0 +1,785 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.MediaEvents = void 0;
+var _events = require("events");
+var _LocalMediaUtils = _interopRequireDefault(require("./LocalMediaUtils"));
+var _reactNative = require("react-native");
+var _BackgroundHandler = _interopRequireDefault(require("./BackgroundHandler"));
+var _NativeAudioManager = _interopRequireDefault(require("./NativeAudioManager"));
+var _PermissionHandler = require("./PermissionHandler");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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); }
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); } /* eslint-disable @typescript-eslint/no-unused-vars */
+const {
+  RTKHelper,
+  BroadcastEventEmitter
+} = _reactNative.NativeModules;
+const broadcastEmitter = new _reactNative.NativeEventEmitter(BroadcastEventEmitter);
+
+// eslint-disable-next-line no-shadow
+let MediaEvents = exports.MediaEvents = /*#__PURE__*/function (MediaEvents) {
+  MediaEvents[MediaEvents["AUDIO_TRACK_CHANGE"] = 0] = "AUDIO_TRACK_CHANGE";
+  MediaEvents[MediaEvents["VIDEO_TRACK_CHANGE"] = 1] = "VIDEO_TRACK_CHANGE";
+  MediaEvents[MediaEvents["SCREENSHARE_TRACK_CHANGE"] = 2] = "SCREENSHARE_TRACK_CHANGE";
+  MediaEvents[MediaEvents["SCREENSHARE_ENDED"] = 3] = "SCREENSHARE_ENDED";
+  MediaEvents[MediaEvents["DEVICE_CHANGE"] = 4] = "DEVICE_CHANGE";
+  MediaEvents[MediaEvents["SCREENSHARE_STARTED"] = 5] = "SCREENSHARE_STARTED";
+  MediaEvents[MediaEvents["MEDIA_PERMISSION_UPDATE"] = 6] = "MEDIA_PERMISSION_UPDATE";
+  MediaEvents[MediaEvents["DEVICE_LIST_UPDATED"] = 7] = "DEVICE_LIST_UPDATED";
+  return MediaEvents;
+}({});
+function checkIfAudioTrackIsSilent(track) {
+  //TODO
+  return !!track;
+}
+var _localMediaUtils = /*#__PURE__*/new WeakMap();
+var _appState = /*#__PURE__*/new WeakMap();
+var _appStateSubscription = /*#__PURE__*/new WeakMap();
+var _interval = /*#__PURE__*/new WeakMap();
+class LocalMediaHandler extends _events.EventEmitter {
+  async configureForeground() {
+    if (_reactNative.Platform.OS !== 'android') return;
+    const val = await RTKHelper.isForegroundServiceRunning();
+    if (!val) {
+      if (_reactNative.Platform.Version >= 33) {
+        const res = await _reactNative.PermissionsAndroid.request(_reactNative.PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
+        if (res !== _reactNative.PermissionsAndroid.RESULTS.GRANTED) {
+          console.warn('Permission required for screenshare notification');
+        }
+      }
+      if (_reactNative.Platform.Version >= 26) {
+        await RTKHelper.createNotificationChannel();
+      }
+      try {
+        await RTKHelper.startService();
+      } catch (e) {
+        console.warn('Failed to start foreground service', e);
+      }
+    }
+  }
+  constructor(localMediaUtils) {
+    super();
+    _classPrivateFieldInitSpec(this, _localMediaUtils, void 0);
+    _classPrivateFieldInitSpec(this, _appState, void 0);
+    _classPrivateFieldInitSpec(this, _appStateSubscription, void 0);
+    _classPrivateFieldInitSpec(this, _interval, void 0);
+    _defineProperty(this, "audioTrack", void 0);
+    _defineProperty(this, "rawAudioTrack", void 0);
+    _defineProperty(this, "videoTrack", void 0);
+    _defineProperty(this, "rawVideoTrack", void 0);
+    _defineProperty(this, "screenShareTracks", void 0);
+    _defineProperty(this, "audioEnabled", void 0);
+    _defineProperty(this, "videoEnabled", void 0);
+    _defineProperty(this, "screenShareEnabled", void 0);
+    _defineProperty(this, "_pendingScreenShare", false);
+    _defineProperty(this, "currentDevices", void 0);
+    _defineProperty(this, "permissions", void 0);
+    _defineProperty(this, "_handleAppStateChange", nextAppState => {
+      if (_classPrivateFieldGet(_appState, this).match(/inactive|background/) && nextAppState === 'active') {
+        _BackgroundHandler.default.clearInterval(_classPrivateFieldGet(_interval, this));
+        _classPrivateFieldSet(_interval, this, null);
+        if (this.videoTrack) {
+          this.videoTrack.enabled = false;
+          setTimeout(() => {
+            if (this.videoTrack) {
+              this.videoTrack.enabled = true;
+            }
+          }, 100);
+        }
+      } else {
+        if (_classPrivateFieldGet(_interval, this) === null) {
+          if (this.screenShareEnabled || this._pendingScreenShare) {
+            this.configureForeground();
+          }
+        }
+        _classPrivateFieldSet(_interval, this, _BackgroundHandler.default.setInterval(() => {}, 1000));
+        _classPrivateFieldSet(_appState, this, nextAppState);
+      }
+    });
+    _classPrivateFieldSet(_localMediaUtils, this, localMediaUtils);
+    _classPrivateFieldSet(_appState, this, '');
+    this.audioEnabled = true;
+    this.videoEnabled = true;
+    this.screenShareEnabled = false;
+    this.permissions = {
+      audio: 'NOT_REQUESTED',
+      video: 'NOT_REQUESTED'
+    };
+    this.screenShareTracks = {
+      audio: undefined,
+      video: undefined
+    };
+    this.currentDevices = {
+      audio: undefined,
+      video: undefined,
+      speaker: undefined
+    };
+    // LocalMediaUtils onDeviceChange with callback from native onAudioDeviceChanged events
+    _classPrivateFieldGet(_localMediaUtils, this).onDeviceChange(async changedDevices => {
+      await this.onDeviceChange(changedDevices, false);
+    });
+    if (_reactNative.Platform.OS === 'ios') {
+      broadcastEmitter.addListener('iOS_BroadcastStarted', () => {
+        this.oniOSBroadcastStart();
+      });
+      broadcastEmitter.addListener('iOS_BroadcastStopped', () => {
+        this.oniOSBroadcastStop();
+      });
+    }
+    _NativeAudioManager.default.start({});
+  }
+  async conditionallyRestartAudio() {
+    if (!this.currentDevices.audio || !this.audioEnabled) {
+      return;
+    }
+    // log.info('maybe_restart_audio: ');
+    await Promise.race([new Promise(resolve => {
+      var _this$audioTrack;
+      return (_this$audioTrack = this.audioTrack) === null || _this$audioTrack === void 0 ? void 0 : _this$audioTrack.addEventListener('unmute', e => {
+        resolve(e);
+      });
+    }), new Promise(resolve => setTimeout(resolve, 50))]);
+    const reacquireTrack = await this.shouldReacquireTrack('audio');
+    if (reacquireTrack) {
+      var _this$currentDevices$;
+      this.removeMediaStreamTrackListeners(this.audioTrack);
+      await this.setupAudioStream((_this$currentDevices$ = this.currentDevices.audio) === null || _this$currentDevices$ === void 0 ? void 0 : _this$currentDevices$.deviceId);
+      this.addMediaStreamTrackListeners(this.audioTrack);
+      this.emit('AUDIO_TRACK_CHANGE');
+    }
+  }
+  async conditionallyRestartVideo() {
+    if (!this.currentDevices.video || !this.videoEnabled) return;
+    // log.info('maybe_restart_video');
+
+    await Promise.race([new Promise(resolve => {
+      var _this$videoTrack;
+      return (_this$videoTrack = this.videoTrack) === null || _this$videoTrack === void 0 ? void 0 : _this$videoTrack.addEventListener('unmute', resolve);
+    }), new Promise(resolve => setTimeout(resolve, 50))]);
+    const reacquireTrack = await this.shouldReacquireTrack('video');
+    if (reacquireTrack) {
+      this.removeMediaStreamTrackListeners(this.videoTrack);
+      await this.setupVideoStream(this.currentDevices.video.deviceId);
+      this.addMediaStreamTrackListeners(this.videoTrack);
+      this.emit('VIDEO_TRACK_CHANGE');
+    }
+  }
+  async shouldReacquireTrack(kind) {
+    const workaroundWebKitBug1208516 = false;
+    let mediaStreamTrack;
+    let wasEnabled = false;
+    if (kind === 'audio') {
+      mediaStreamTrack = this.audioTrack;
+      wasEnabled = this.audioEnabled;
+    } else if (kind === 'video') {
+      mediaStreamTrack = this.videoTrack;
+      wasEnabled = this.videoEnabled;
+    }
+    if (!mediaStreamTrack) return false;
+    if (!this.rawAudioTrack || !this.audioTrack) return true;
+    if (!this.rawVideoTrack || !this.videoTrack) return true;
+    const isStopped = mediaStreamTrack.readyState === 'ended';
+    const isInadvertentlyStopped = isStopped && wasEnabled && workaroundWebKitBug1208516;
+    let isSilentAudio = false;
+    if (kind === 'audio') {
+      isSilentAudio = await checkIfAudioTrackIsSilent(this.audioTrack);
+    }
+    return mediaStreamTrack.muted || isInadvertentlyStopped || isSilentAudio;
+  }
+  async removeDocumentEventListeners() {}
+  onUnmute(ev) {
+    // log.info('Track unmuted', ev);
+  }
+  removeMediaStreamTrackListeners(mediaStreamTrack) {
+    if (!mediaStreamTrack) {
+      return undefined;
+    }
+    const conditionallyRestart = mediaStreamTrack.kind === 'audio' ? this.conditionallyRestartAudio : this.conditionallyRestartVideo;
+    mediaStreamTrack.removeEventListener('ended', conditionallyRestart);
+    mediaStreamTrack.removeEventListener('mute', conditionallyRestart);
+    mediaStreamTrack.removeEventListener('unmute', this.onUnmute);
+    return mediaStreamTrack;
+  }
+  addMediaStreamTrackListeners(mediaStreamTrack) {
+    if (!mediaStreamTrack) {
+      return null;
+    }
+    const conditionallyRestart = mediaStreamTrack.kind === 'audio' ? this.conditionallyRestartAudio : this.conditionallyRestartVideo;
+    mediaStreamTrack.addEventListener('ended', conditionallyRestart);
+    mediaStreamTrack.addEventListener('mute', conditionallyRestart);
+    mediaStreamTrack.addEventListener('unmute', this.onUnmute);
+    return mediaStreamTrack;
+  }
+  async setupAudioStream(deviceId, forceStopTrack = false) {
+    var _this$currentDevices$2;
+    const audioDevices = _classPrivateFieldGet(_localMediaUtils, this).getAudioDevices();
+    if (!audioDevices.length) {
+      return;
+    }
+    let audioDeviceId = deviceId;
+    if (!audioDeviceId) {
+      audioDeviceId = (await this.getOperationalMicDeviceId()).deviceId;
+    }
+    if (((_this$currentDevices$2 = this.currentDevices.audio) === null || _this$currentDevices$2 === void 0 ? void 0 : _this$currentDevices$2.deviceId) !== audioDeviceId) {
+      this.currentDevices.audio = _classPrivateFieldGet(_localMediaUtils, this).getDeviceById(audioDeviceId, 'audioinput');
+    }
+    if (forceStopTrack) {
+      var _this$audioTrack2, _this$rawAudioTrack;
+      (_this$audioTrack2 = this.audioTrack) === null || _this$audioTrack2 === void 0 || _this$audioTrack2.stop();
+      (_this$rawAudioTrack = this.rawAudioTrack) === null || _this$rawAudioTrack === void 0 || _this$rawAudioTrack.stop();
+    }
+    try {
+      this.rawAudioTrack = await _LocalMediaUtils.default.getAudioTrack();
+    } catch (err) {
+      console.warn('Failed to acquire audio track: ', err);
+      this.rawAudioTrack = undefined;
+    }
+    this.setAudioTrack(this.rawAudioTrack);
+    this.addMediaStreamTrackListeners(this.audioTrack);
+    this.emit('AUDIO_TRACK_CHANGE');
+    this.setDevice(this.currentDevices.audio);
+
+    /**
+     * NOTE(roerohan): Firefox does not show device labels until permissions are granted.
+     * So, we need to repopulate the devices once permission is granted.
+     */
+    if (this.audioTrack && this.permissions.audio === 'NOT_REQUESTED') {
+      await _classPrivateFieldGet(_localMediaUtils, this).repopulateAvailableDevices();
+    }
+    this.emit('DEVICE_CHANGE', {
+      device: this.currentDevices.audio
+    });
+  }
+  onVisibilityChange() {
+    // pass
+  }
+  async setupVideoStream(deviceId, forceStopTrack = false) {
+    var _this$currentDevices$3;
+    const videoDevices = _classPrivateFieldGet(_localMediaUtils, this).getVideoDevices();
+    if (!videoDevices.length) {
+      return;
+    }
+    let videoDeviceId = deviceId;
+    if (!videoDeviceId) {
+      videoDeviceId = (await this.getOperationalWebcamDeviceId()).deviceId;
+    }
+    if (((_this$currentDevices$3 = this.currentDevices.video) === null || _this$currentDevices$3 === void 0 ? void 0 : _this$currentDevices$3.deviceId) !== videoDeviceId) {
+      this.currentDevices.video = _classPrivateFieldGet(_localMediaUtils, this).getDeviceById(videoDeviceId, 'videoinput');
+    }
+
+    /**
+     * NOTE(roerohan): this.videoEnabled is checked, so that upon device change,
+     * the video track is not set when the user has turned off his camera.
+     */
+    if (this.videoEnabled) {
+      const videoConstraints = _LocalMediaUtils.default.getVideoConstraints({
+        videoDeviceId
+      });
+      if (!this.rawVideoTrack) {
+        try {
+          this.rawVideoTrack = await _LocalMediaUtils.default.getVideoTrack(videoConstraints);
+        } catch (err) {
+          console.warn('Failed to acquire video track: ', err);
+          this.rawVideoTrack = undefined;
+        }
+      }
+      this.setVideoTrack(this.rawVideoTrack);
+      this.addMediaStreamTrackListeners(this.rawVideoTrack);
+      this.emit('VIDEO_TRACK_CHANGE');
+    }
+    if (forceStopTrack) {
+      var _this$videoTrack2, _this$rawVideoTrack;
+      (_this$videoTrack2 = this.videoTrack) === null || _this$videoTrack2 === void 0 || _this$videoTrack2.stop();
+      (_this$rawVideoTrack = this.rawVideoTrack) === null || _this$rawVideoTrack === void 0 || _this$rawVideoTrack.stop();
+    }
+    /**
+     * NOTE(roerohan): Firefox does not show device labels until permissions are granted.
+     * So, we need to repopulate the devices once permission is granted.
+     */
+    if (this.videoTrack && this.permissions.video === 'NOT_REQUESTED') {
+      await _classPrivateFieldGet(_localMediaUtils, this).repopulateAvailableDevices();
+    }
+    this.emit('DEVICE_CHANGE', {
+      device: this.currentDevices.video
+    });
+  }
+  async setupSpeaker(deviceId) {
+    var _this$currentDevices$4;
+    const speakerDevices = _classPrivateFieldGet(_localMediaUtils, this).getSpeakerDevices();
+    if (!speakerDevices.length) {
+      return;
+    }
+    const lastDeviceIndex = speakerDevices.length - 1;
+    const speakerDeviceId = deviceId ?? speakerDevices[lastDeviceIndex].deviceId;
+    if (((_this$currentDevices$4 = this.currentDevices.speaker) === null || _this$currentDevices$4 === void 0 ? void 0 : _this$currentDevices$4.deviceId) !== speakerDeviceId) {
+      // Audio Input devices are same as output devices in mobile
+      this.currentDevices.audio = _classPrivateFieldGet(_localMediaUtils, this).getDeviceById(speakerDeviceId, 'audioinput');
+      this.currentDevices.speaker = this.currentDevices.audio;
+    }
+    await this.setDevice(this.currentDevices.audio);
+    this.emit('DEVICE_CHANGE', {
+      device: this.currentDevices.speaker
+    });
+  }
+  async getOperationalWebcamDeviceId() {
+    let videoDevices = _classPrivateFieldGet(_localMediaUtils, this).getVideoDevices();
+    if (!videoDevices.length) {
+      return {
+        isOperational: false,
+        deviceId: null
+      };
+    }
+
+    /*
+            NOTE(ravindra-dyte): Usually external devices come at the bottom,
+            By reversing the deviceList and breaking on first operational device
+            We are giving preference to external device
+        */
+
+    videoDevices = [...videoDevices].reverse();
+    let operationalDeviceId = null;
+    for (let deviceIndex = 0; deviceIndex < videoDevices.length; deviceIndex += 1) {
+      try {
+        operationalDeviceId = videoDevices[deviceIndex].deviceId;
+        break;
+      } catch (err) {}
+    }
+    return operationalDeviceId ? {
+      isOperational: true,
+      deviceId: operationalDeviceId
+    } : {
+      isOperational: false,
+      deviceId: videoDevices[0].deviceId
+    };
+  }
+  async getOperationalMicDeviceId() {
+    let audioDevices = _classPrivateFieldGet(_localMediaUtils, this).getAudioDevices();
+    if (!audioDevices.length) {
+      return {
+        isOperational: false,
+        deviceId: null
+      };
+    }
+    /*
+            NOTE(ravindra-dyte): Usually external devices come at the bottom,
+            By reversing the deviceList and breaking on first operational device
+            We are giving preference to external device
+        */
+
+    audioDevices = [...audioDevices].reverse();
+    let operationalDeviceId = null;
+    for (let deviceIndex = 0; deviceIndex < audioDevices.length; deviceIndex += 1) {
+      try {
+        const audioTrack = await _LocalMediaUtils.default.getAudioTrack();
+        const isSilent = await checkIfAudioTrackIsSilent(audioTrack);
+        audioTrack.stop();
+        audioTrack.release();
+        if (!isSilent) {
+          operationalDeviceId = audioDevices[deviceIndex].deviceId;
+          break;
+        }
+      } catch (err) {
+        console.warn('Failed to acquire audio track: ', err);
+      }
+    }
+    return operationalDeviceId ? {
+      isOperational: true,
+      deviceId: operationalDeviceId
+    } : {
+      isOperational: false,
+      deviceId: audioDevices[0].deviceId
+    };
+  }
+  async setupStreams({
+    audio,
+    video
+  }) {
+    try {
+      const permResult = await (0, _PermissionHandler.setupPermissions)(audio, video);
+      this.permissions.video = permResult.camera;
+      this.permissions.audio = permResult.microphone;
+    } catch (val) {
+      this.permissions.video = val.camera ?? false;
+      this.permissions.audio = val.microphone ?? false;
+    }
+    this.emit('MEDIA_PERMISSION_UPDATE', {
+      kind: 'audio',
+      message: this.permissions.audio
+    });
+    this.emit('MEDIA_PERMISSION_UPDATE', {
+      kind: 'video',
+      message: this.permissions.video
+    });
+    const constraints = {};
+    if (!this.currentDevices) {
+      this.currentDevices = {
+        audio: undefined,
+        video: undefined,
+        speaker: undefined
+      };
+    }
+    if (audio) {
+      const audioDevices = _classPrivateFieldGet(_localMediaUtils, this).getAudioDevices();
+      if (audioDevices.length !== 0) {
+        const audioDeviceId = (await this.getOperationalMicDeviceId()).deviceId;
+        this.currentDevices.audio = _classPrivateFieldGet(_localMediaUtils, this).getDeviceById(audioDeviceId, 'audioinput');
+        constraints.audio = true;
+      }
+    }
+    if (video) {
+      const videoDevices = _classPrivateFieldGet(_localMediaUtils, this).getVideoDevices();
+      if (videoDevices.length !== 0) {
+        const videoDeviceId = (await this.getOperationalWebcamDeviceId()).deviceId;
+        this.currentDevices.video = _classPrivateFieldGet(_localMediaUtils, this).getDeviceById(videoDeviceId, 'videoinput');
+        const videoConstraints = _LocalMediaUtils.default.getVideoConstraints({
+          videoDeviceId
+        });
+        constraints.video = videoConstraints.video;
+      }
+    }
+    if (audio) await this.setupAudioStream();
+    if (video) await this.setupVideoStream();
+    if (this.audioTrack) this.audioEnabled = true;else this.audioEnabled = false;
+    if (this.videoTrack) this.videoEnabled = true;else this.videoEnabled = false;
+    this.screenShareEnabled = false;
+
+    // Setting default audio output to speaker
+    await this.setupSpeaker();
+
+    // Setup Foreground Service after handling permissions
+    if (_reactNative.Platform.OS === 'android') {
+      _classPrivateFieldSet(_appStateSubscription, this, _reactNative.AppState.addEventListener('change', this._handleAppStateChange));
+    }
+  }
+  stopScreenShareTracks(tracks = {}) {
+    const {
+      audio = true,
+      video = true
+    } = tracks;
+    if (audio) {
+      var _this$screenShareTrac;
+      (_this$screenShareTrac = this.screenShareTracks) === null || _this$screenShareTrac === void 0 || (_this$screenShareTrac = _this$screenShareTrac.audio) === null || _this$screenShareTrac === void 0 || _this$screenShareTrac.stop();
+    }
+    if (video) {
+      var _this$screenShareTrac2;
+      (_this$screenShareTrac2 = this.screenShareTracks) === null || _this$screenShareTrac2 === void 0 || (_this$screenShareTrac2 = _this$screenShareTrac2.video) === null || _this$screenShareTrac2 === void 0 || _this$screenShareTrac2.stop();
+    }
+    if (audio && video) {
+      this.screenShareEnabled = false;
+    }
+  }
+  removeScreenShareTracks(tracks) {
+    var _this$screenShareTrac3;
+    (_this$screenShareTrac3 = this.screenShareTracks.video) === null || _this$screenShareTrac3 === void 0 || _this$screenShareTrac3.removeEventListener('ended', this.onScreenShareEnded);
+    this.stopScreenShareTracks(tracks);
+    this.screenShareTracks = {
+      audio: undefined,
+      video: undefined
+    };
+  }
+  setAudioTrack(audioTrack) {
+    if (audioTrack === this.audioTrack) {
+      return;
+    }
+    if (audioTrack === undefined) {
+      this.stopAudioTrack();
+    }
+    this.audioTrack = audioTrack;
+  }
+  setVideoTrack(videoTrack) {
+    if (videoTrack === this.videoTrack) {
+      return;
+    }
+    if (videoTrack === undefined) {
+      this.stopVideoTrack();
+    }
+    this.videoTrack = videoTrack;
+  }
+  setScreenShareTracks(tracks) {
+    var _this$screenShareTrac4;
+    const {
+      audio,
+      video
+    } = tracks;
+    // console.log('SetScreenshare called');
+    if (!audio || !video) {
+      this.stopScreenShareTracks({
+        audio: !!audio,
+        video: !!video
+      });
+    }
+    this.screenShareTracks = tracks;
+    (_this$screenShareTrac4 = this.screenShareTracks.video) === null || _this$screenShareTrac4 === void 0 || _this$screenShareTrac4.addEventListener('ended', this.onScreenShareEnded.bind(this));
+  }
+  onScreenShareEnded() {
+    this.emit('SCREENSHARE_ENDED');
+  }
+  async disableAudio() {
+    await this.toggleAudio();
+  }
+  async enableAudio() {
+    await this.toggleAudio();
+  }
+  async toggleAudio() {
+    if (this.permissions.audio !== 'ACCEPTED') {
+      try {
+        const permResult = await (0, _PermissionHandler.setupPermissions)(true, false);
+        this.permissions.audio = permResult.microphone;
+      } catch (val) {
+        this.permissions.audio = val.microphone ?? false;
+      }
+    }
+    this.emit('MEDIA_PERMISSION_UPDATE', {
+      kind: 'audio',
+      message: this.permissions.audio
+    });
+    if (this.permissions.audio === 'DENIED' || this.permissions.audio === 'NOT_REQUESTED') {
+      this.audioEnabled = false;
+      return;
+    }
+    if (this.audioEnabled) {
+      this.audioEnabled = false;
+      if (this.audioTrack) {
+        this.audioTrack.enabled = this.audioEnabled;
+      }
+      return;
+    }
+    try {
+      /**
+       * NOTE (@madhugb): We need to setup new stream,
+       * if the audio track is not preset or it has ended
+       */
+      if (!this.audioTrack || this.audioTrack.readyState === 'ended') {
+        var _this$currentDevices$5;
+        await this.setupAudioStream((_this$currentDevices$5 = this.currentDevices.audio) === null || _this$currentDevices$5 === void 0 ? void 0 : _this$currentDevices$5.deviceId);
+      }
+      // if we still can't get a track after setting up audio stream
+      // do not toggle the audio state
+      if (!this.audioTrack) {
+        this.audioEnabled = false;
+        return;
+      }
+      this.audioEnabled = true;
+    } catch (ex) {
+      this.audioEnabled = false;
+      this.audioTrack = undefined;
+      this.rawAudioTrack = undefined;
+    }
+    if (this.audioTrack) {
+      this.audioTrack.enabled = true;
+    }
+  }
+  async enableVideo() {
+    await this.toggleVideo();
+  }
+  async disableVideo() {
+    await this.toggleVideo();
+  }
+  async toggleVideo() {
+    var _this$currentDevices$6;
+    if (this.permissions.video !== 'ACCEPTED') {
+      try {
+        const permResult = await (0, _PermissionHandler.setupPermissions)(false, true);
+        this.permissions.video = permResult.camera;
+      } catch (val) {
+        this.permissions.video = val.camera ?? false;
+      }
+    }
+    this.emit('MEDIA_PERMISSION_UPDATE', {
+      kind: 'video',
+      message: this.permissions.video
+    });
+    if (this.permissions.video === 'DENIED' || this.permissions.video === 'NOT_REQUESTED') {
+      this.videoEnabled = false;
+      return;
+    }
+    if (this.videoEnabled) {
+      this.stopVideoTrack();
+      this.videoEnabled = false;
+      return;
+    }
+    /**
+     * NOTE(roerohan): The videoEnabled flag is used inside the setupVideoStream method
+     * hence it must be set to true first.
+     */
+    this.videoEnabled = true;
+    await this.setupVideoStream((_this$currentDevices$6 = this.currentDevices.video) === null || _this$currentDevices$6 === void 0 ? void 0 : _this$currentDevices$6.deviceId);
+  }
+  async setAudioDevice(device) {
+    await this.setupAudioStream(device.deviceId);
+  }
+  async setVideoDevice(device) {
+    if (this.videoEnabled) {
+      this.stopVideoTrack();
+    }
+    await this.setupVideoStream(device.deviceId);
+  }
+  async setSpeakerDevice(device) {
+    await this.setupSpeaker(device.deviceId);
+  }
+  async setDevice(route) {
+    await _classPrivateFieldGet(_localMediaUtils, this).chooseAudioRoute(route.deviceId);
+  }
+  async oniOSBroadcastStart() {
+    this.setScreenShareTracks(await _LocalMediaUtils.default.getScreenShareTracks());
+    this.screenShareEnabled = true;
+    this.emit('SCREENSHARE_TRACK_CHANGE');
+  }
+  async oniOSBroadcastStop() {
+    if (this.screenShareEnabled) {
+      this.removeScreenShareTracks();
+      this.emit('SCREENSHARE_TRACK_CHANGE');
+      return;
+    }
+  }
+  async toggleScreenShare() {
+    if (this.screenShareEnabled && _reactNative.Platform.OS !== 'ios') {
+      this.removeScreenShareTracks();
+      try {
+        await RTKHelper.stopService();
+      } catch (e) {
+        console.warn('Failed to stop foreground service', e);
+      }
+      return;
+    }
+    if (_reactNative.Platform.OS === 'ios' && this.screenShareEnabled) {
+      _reactNative.NativeModules.RTKScreensharePickerView.showScreenSharePickerView();
+      return;
+    }
+    if (_reactNative.Platform.OS === 'android') {
+      this._pendingScreenShare = true;
+      await this.configureForeground();
+      try {
+        this.setScreenShareTracks(await _LocalMediaUtils.default.getScreenShareTracks());
+        this.screenShareEnabled = true;
+      } catch (e) {
+        console.warn('Failed to start screenshare', e);
+        this.screenShareEnabled = false;
+        await RTKHelper.stopService();
+        this._pendingScreenShare = false;
+      } finally {
+        this._pendingScreenShare = false;
+      }
+    }
+    if (_reactNative.Platform.OS === 'ios') {
+      _reactNative.NativeModules.RTKScreensharePickerView.showScreenSharePickerView();
+    }
+  }
+  async enableScreenShare() {
+    await this.toggleScreenShare();
+  }
+  async disableScreenShare() {
+    await this.toggleScreenShare();
+  }
+  getAllDevices() {
+    return _classPrivateFieldGet(_localMediaUtils, this).availableDevices;
+  }
+  getCurrentDevices() {
+    return this.currentDevices;
+  }
+  getDeviceById(deviceId, kind) {
+    return _classPrivateFieldGet(_localMediaUtils, this).getDeviceById(deviceId, kind);
+  }
+  getAudioDevices() {
+    return _classPrivateFieldGet(_localMediaUtils, this).getAudioDevices();
+  }
+  getVideoDevices() {
+    return _classPrivateFieldGet(_localMediaUtils, this).getVideoDevices();
+  }
+  getSpeakerDevices() {
+    return _classPrivateFieldGet(_localMediaUtils, this).getSpeakerDevices();
+  }
+  async onDeviceChange(changedDevices, forceDeviceChange) {
+    let addedDevice;
+    let removedDevice;
+    if (changedDevices.added.length) [addedDevice] = changedDevices.added;
+    if (changedDevices.removed.length) [removedDevice] = changedDevices.removed;
+
+    /**
+     * NOTE(roerohan): forceStopTrack is set required to be set to true for firefox.
+     * https://stackoverflow.com/questions/59068146/navigator-mediadevices-getusermedia-api-rejecting-with-error-notreadableerror
+     * forceStopTrack is the second argument of setupAudioStream and setupVideoStream.
+     */
+    if (addedDevice) {
+      if (addedDevice.kind === 'audioinput') {
+        if (this.permissions.audio === 'DENIED' || this.permissions.audio === 'NOT_REQUESTED') {
+          await this.setupSpeaker(addedDevice.deviceId);
+        } else {
+          await this.setupAudioStream(addedDevice.deviceId);
+        }
+      } else if (addedDevice.kind === 'videoinput') {
+        await this.setupVideoStream(addedDevice.deviceId);
+      } else if (addedDevice.kind === 'audiooutput') {
+        await this.setupSpeaker(addedDevice.deviceId);
+      }
+      this.emit('AUDIO_TRACK_CHANGE');
+    }
+    if (removedDevice) {
+      if (removedDevice.kind === 'audioinput') {
+        if (this.permissions.audio === 'DENIED' || this.permissions.audio === 'NOT_REQUESTED') {
+          await this.setupSpeaker();
+        } else {
+          await this.setupAudioStream();
+        }
+      } else if (removedDevice.kind === 'videoinput') {
+        await this.setupVideoStream();
+      } else if (removedDevice.kind === 'audiooutput') {
+        await this.setupSpeaker();
+      }
+      this.emit('AUDIO_TRACK_CHANGE');
+    }
+    if (changedDevices.added.length || changedDevices.removed.length) {
+      this.emit('DEVICE_LIST_UPDATED', changedDevices);
+    }
+  }
+  static async init(_) {
+    const localMediaUtils = await _LocalMediaUtils.default.init();
+    return new LocalMediaHandler(localMediaUtils);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  destruct() {
+    // TODO: Do not remove native broadcast listeners when going OFF_STAGE in webinar
+    // this.#localMediaUtils.destruct();
+    if (_reactNative.Platform.OS === 'android') _classPrivateFieldGet(_appStateSubscription, this).remove();
+    _BackgroundHandler.default.stop();
+    try {
+      if (_reactNative.Platform.OS === 'android') RTKHelper.stopService();
+    } catch (_err) {}
+    // InCallManger.stop(undefined);
+  }
+  stopAudioTrack() {
+    var _this$rawAudioTrack2, _this$audioTrack3, _this$rawAudioTrack3, _this$audioTrack4;
+    (_this$rawAudioTrack2 = this.rawAudioTrack) === null || _this$rawAudioTrack2 === void 0 || _this$rawAudioTrack2.stop();
+    (_this$audioTrack3 = this.audioTrack) === null || _this$audioTrack3 === void 0 || _this$audioTrack3.stop();
+    (_this$rawAudioTrack3 = this.rawAudioTrack) === null || _this$rawAudioTrack3 === void 0 || _this$rawAudioTrack3.release();
+    (_this$audioTrack4 = this.audioTrack) === null || _this$audioTrack4 === void 0 || _this$audioTrack4.release();
+    this.audioEnabled = false;
+    this.audioTrack = undefined;
+    this.rawAudioTrack = undefined;
+  }
+  stopVideoTrack() {
+    var _this$rawVideoTrack2, _this$videoTrack3, _this$rawVideoTrack3, _this$videoTrack4;
+    (_this$rawVideoTrack2 = this.rawVideoTrack) === null || _this$rawVideoTrack2 === void 0 || _this$rawVideoTrack2.stop();
+    (_this$videoTrack3 = this.videoTrack) === null || _this$videoTrack3 === void 0 || _this$videoTrack3.stop();
+    (_this$rawVideoTrack3 = this.rawVideoTrack) === null || _this$rawVideoTrack3 === void 0 || _this$rawVideoTrack3.release();
+    (_this$videoTrack4 = this.videoTrack) === null || _this$videoTrack4 === void 0 || _this$videoTrack4.release();
+    this.videoTrack = undefined;
+    this.rawVideoTrack = undefined;
+  }
+}
+exports.default = LocalMediaHandler;
+//# sourceMappingURL=LocalMediaHandler.js.map