fcr-ui-scene 3.3.1 → 3.4.1

package/lib/providers/device-privilege-provider.js

@@ -0,0 +1,386 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIDevicePrivilegeProviderImpl = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/esnext.async-iterator.find.js");
+require("core-js/modules/esnext.async-iterator.for-each.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _imports = require("fcr-core/lib/imports");
+var _base = require("../base");
+var _fcrCore = require("fcr-core");
+var FcrUIDevicePrivilegeProviderImpl = exports.FcrUIDevicePrivilegeProviderImpl = /*#__PURE__*/function () {
+  function FcrUIDevicePrivilegeProviderImpl(_privilegeControl, _streamControl, _userControl) {
+    var _this = this;
+    (0, _classCallCheck2["default"])(this, FcrUIDevicePrivilegeProviderImpl);
+    (0, _defineProperty2["default"])(this, "_firstGetMicrophonePrivilege", true);
+    (0, _defineProperty2["default"])(this, "_observable", new _imports.AgoraObservable());
+    this._privilegeControl = _privilegeControl;
+    this._streamControl = _streamControl;
+    this._userControl = _userControl;
+    var localUserId = this._userControl.getLocalUser().userId;
+    this._privilegeObserver = {
+      onLocalUserPermissionInfoAdded: function () {
+        var _onLocalUserPermissionInfoAdded = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(roomId, event) {
+          var hasVideoPermission, hasAudioPermission, localStream, hasVideo, hasAudio;
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                hasVideoPermission = event.permissionInfo.find(function (permissionInfo) {
+                  var _permissionInfo$info;
+                  ((_permissionInfo$info = permissionInfo.info) === null || _permissionInfo$info === void 0 ? void 0 : _permissionInfo$info.action) === _fcrCore.FcrPermissionAction.StreamStartVideo;
+                });
+                hasAudioPermission = event.permissionInfo.find(function (permissionInfo) {
+                  var _permissionInfo$info2;
+                  ((_permissionInfo$info2 = permissionInfo.info) === null || _permissionInfo$info2 === void 0 ? void 0 : _permissionInfo$info2.action) === _fcrCore.FcrPermissionAction.StreamStartAudio;
+                });
+                localStream = _this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                  return stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA;
+                });
+                hasVideo = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.VIDEO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+                hasAudio = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.AUDIO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+                if (!hasVideoPermission) {
+                  _context.next = 17;
+                  break;
+                }
+                if (!(!hasVideo && localStream)) {
+                  _context.next = 16;
+                  break;
+                }
+                _context.prev = 7;
+                _context.next = 10;
+                return _this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                  videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE,
+                  audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+                }));
+              case 10:
+                _context.next = 16;
+                break;
+              case 12:
+                _context.prev = 12;
+                _context.t0 = _context["catch"](7);
+                _this._observable.notifyObservers('onOpenCameraPrivilegeUpdated', false);
+                return _context.abrupt("return");
+              case 16:
+                _this._observable.notifyObservers('onOpenCameraPrivilegeUpdated', true);
+              case 17:
+                if (!hasAudioPermission) {
+                  _context.next = 29;
+                  break;
+                }
+                if (!(!hasAudio && localStream)) {
+                  _context.next = 28;
+                  break;
+                }
+                _context.prev = 19;
+                _context.next = 22;
+                return _this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                  videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION,
+                  audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE
+                }));
+              case 22:
+                _context.next = 28;
+                break;
+              case 24:
+                _context.prev = 24;
+                _context.t1 = _context["catch"](19);
+                _this._observable.notifyObservers('onOpenMicrophonePrivilegeUpdated', false);
+                return _context.abrupt("return");
+              case 28:
+                _this._observable.notifyObservers('onOpenMicrophonePrivilegeUpdated', true);
+              case 29:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee, null, [[7, 12], [19, 24]]);
+        }));
+        function onLocalUserPermissionInfoAdded(_x, _x2) {
+          return _onLocalUserPermissionInfoAdded.apply(this, arguments);
+        }
+        return onLocalUserPermissionInfoAdded;
+      }(),
+      onLocalUserPermissionInfoDeleted: function () {
+        var _onLocalUserPermissionInfoDeleted = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(roomId, event) {
+          var hasVideoPermission, hasAudioPermission;
+          return _regenerator["default"].wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                hasVideoPermission = event.permissionInfo.find(function (permissionInfo) {
+                  var _permissionInfo$info3;
+                  ((_permissionInfo$info3 = permissionInfo.info) === null || _permissionInfo$info3 === void 0 ? void 0 : _permissionInfo$info3.action) === _fcrCore.FcrPermissionAction.StreamStartVideo;
+                });
+                hasAudioPermission = event.permissionInfo.find(function (permissionInfo) {
+                  var _permissionInfo$info4;
+                  ((_permissionInfo$info4 = permissionInfo.info) === null || _permissionInfo$info4 === void 0 ? void 0 : _permissionInfo$info4.action) === _fcrCore.FcrPermissionAction.StreamStartAudio;
+                });
+                if (hasVideoPermission) {
+                  _this._observable.notifyObservers('onOpenCameraPrivilegeUpdated', false);
+                }
+                if (hasAudioPermission) {
+                  _this._observable.notifyObservers('onOpenMicrophonePrivilegeUpdated', false);
+                }
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }));
+        function onLocalUserPermissionInfoDeleted(_x3, _x4) {
+          return _onLocalUserPermissionInfoDeleted.apply(this, arguments);
+        }
+        return onLocalUserPermissionInfoDeleted;
+      }()
+    };
+    this._streamObserver = {
+      onStreamsUpdated: function () {
+        var _onStreamsUpdated = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(roomId, events) {
+          return _regenerator["default"].wrap(function _callee3$(_context3) {
+            while (1) switch (_context3.prev = _context3.next) {
+              case 0:
+                events.forEach(function (event) {
+                  var stream = event.modifiedStream;
+                  if (stream.owner.userId === localUserId && stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA) {
+                    if (stream.streamType === _fcrCore.FcrStreamType.NONE || stream.streamType === _fcrCore.FcrStreamType.AUDIO) {
+                      _this._observable.notifyObservers('onCameraNeedClosed');
+                    }
+                    if (stream.streamType === _fcrCore.FcrStreamType.NONE || stream.streamType === _fcrCore.FcrStreamType.VIDEO) {
+                      _this._observable.notifyObservers('onMicrophoneNeedClosed');
+                    }
+                    var hasVideo = stream.streamType === _fcrCore.FcrStreamType.VIDEO || stream.streamType === _fcrCore.FcrStreamType.BOTH;
+                    var hasAudio = stream.streamType === _fcrCore.FcrStreamType.AUDIO || stream.streamType === _fcrCore.FcrStreamType.BOTH;
+                    if (!hasVideo) {
+                      _this._observable.notifyObservers('onOpenCameraPrivilegeUpdated', false);
+                    }
+                    if (!hasAudio) {
+                      _this._observable.notifyObservers('onOpenMicrophonePrivilegeUpdated', false);
+                    }
+                    var hasVideoPermission = _this._privilegeControl.getLocalUserPermissionInfo(_fcrCore.FcrPermissionAction.StreamStartVideo).enable;
+                    var hasAudioPermission = _this._privilegeControl.getLocalUserPermissionInfo(_fcrCore.FcrPermissionAction.StreamStartAudio).enable;
+                    if (hasVideoPermission && !hasVideo || hasAudioPermission && !hasAudio) {
+                      _this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, stream.streamId, {
+                        videoPrivilege: hasVideoPermission ? _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE : _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION,
+                        audioPrivilege: hasAudioPermission ? _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE : _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+                      }));
+                    }
+                  }
+                });
+              case 1:
+              case "end":
+                return _context3.stop();
+            }
+          }, _callee3);
+        }));
+        function onStreamsUpdated(_x5, _x6) {
+          return _onStreamsUpdated.apply(this, arguments);
+        }
+        return onStreamsUpdated;
+      }()
+    };
+    this._privilegeControl.addObserver(this._privilegeObserver);
+    this._streamControl.addObserver(this._streamObserver);
+  }
+  return (0, _createClass2["default"])(FcrUIDevicePrivilegeProviderImpl, [{
+    key: "release",
+    value: function release() {
+      this._privilegeControl.removeObserver(this._privilegeObserver);
+    }
+  }, {
+    key: "setAlwaysHasCameraPrivilege",
+    value: function () {
+      var _setAlwaysHasCameraPrivilege = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", false);
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function setAlwaysHasCameraPrivilege() {
+        return _setAlwaysHasCameraPrivilege.apply(this, arguments);
+      }
+      return setAlwaysHasCameraPrivilege;
+    }()
+  }, {
+    key: "hasOpenCameraPrivilege",
+    value: function () {
+      var _hasOpenCameraPrivilege = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+        var permissionInfo, localUserId, localStream, hasVideo;
+        return _regenerator["default"].wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              permissionInfo = this._privilegeControl.getLocalUserPermissionInfo(_fcrCore.FcrPermissionAction.StreamStartVideo);
+              localUserId = this._userControl.getLocalUser().userId;
+              localStream = this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                return stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA;
+              });
+              hasVideo = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.VIDEO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+              if (!permissionInfo.enable) {
+                _context5.next = 21;
+                break;
+              }
+              if (!hasVideo) {
+                _context5.next = 9;
+                break;
+              }
+              return _context5.abrupt("return", true);
+            case 9:
+              if (!localStream) {
+                _context5.next = 18;
+                break;
+              }
+              _context5.prev = 10;
+              _context5.next = 13;
+              return this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE,
+                audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+              }));
+            case 13:
+              _context5.next = 18;
+              break;
+            case 15:
+              _context5.prev = 15;
+              _context5.t0 = _context5["catch"](10);
+              return _context5.abrupt("return", false);
+            case 18:
+              return _context5.abrupt("return", true);
+            case 19:
+              _context5.next = 25;
+              break;
+            case 21:
+              if (!hasVideo) {
+                _context5.next = 24;
+                break;
+              }
+              _context5.next = 24;
+              return this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOPRIVILEGE,
+                audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+              }));
+            case 24:
+              return _context5.abrupt("return", false);
+            case 25:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[10, 15]]);
+      }));
+      function hasOpenCameraPrivilege() {
+        return _hasOpenCameraPrivilege.apply(this, arguments);
+      }
+      return hasOpenCameraPrivilege;
+    }()
+  }, {
+    key: "hasOpenMicrophonePrivilege",
+    value: function () {
+      var _hasOpenMicrophonePrivilege = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+        var permissionInfo, localUserId, localStream, hasAudio;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              permissionInfo = this._privilegeControl.getLocalUserPermissionInfo(_fcrCore.FcrPermissionAction.StreamStartAudio);
+              localUserId = this._userControl.getLocalUser().userId;
+              localStream = this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                return stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA;
+              });
+              hasAudio = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.AUDIO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+              if (!this._firstGetMicrophonePrivilege) {
+                _context6.next = 13;
+                break;
+              }
+              this._firstGetMicrophonePrivilege = false;
+              if (!hasAudio) {
+                _context6.next = 10;
+                break;
+              }
+              return _context6.abrupt("return", true);
+            case 10:
+              return _context6.abrupt("return", false);
+            case 11:
+              _context6.next = 34;
+              break;
+            case 13:
+              if (!permissionInfo.enable) {
+                _context6.next = 30;
+                break;
+              }
+              if (!hasAudio) {
+                _context6.next = 18;
+                break;
+              }
+              return _context6.abrupt("return", true);
+            case 18:
+              if (!localStream) {
+                _context6.next = 27;
+                break;
+              }
+              _context6.prev = 19;
+              _context6.next = 22;
+              return this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE,
+                audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+              }));
+            case 22:
+              _context6.next = 27;
+              break;
+            case 24:
+              _context6.prev = 24;
+              _context6.t0 = _context6["catch"](19);
+              return _context6.abrupt("return", false);
+            case 27:
+              return _context6.abrupt("return", true);
+            case 28:
+              _context6.next = 34;
+              break;
+            case 30:
+              if (!hasAudio) {
+                _context6.next = 33;
+                break;
+              }
+              _context6.next = 33;
+              return this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOPRIVILEGE,
+                audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+              }));
+            case 33:
+              return _context6.abrupt("return", false);
+            case 34:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[19, 24]]);
+      }));
+      function hasOpenMicrophonePrivilege() {
+        return _hasOpenMicrophonePrivilege.apply(this, arguments);
+      }
+      return hasOpenMicrophonePrivilege;
+    }()
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._observable.removeObserver(observer);
+    }
+  }]);
+}();
+(0, _base.registerDependency)('devicePrivilegeProvider');

package/lib/providers/device-provider.d.ts

@@ -0,0 +1,246 @@
+import { FcrBeautyOptions, FcrCameraTrack, FcrLoopbackTrack, FcrMicrophoneTrack, FcrScreenTrack } from 'fcr-core/lib/media-control/type';
+import { FcrDeviceInfo } from 'fcr-core/lib/type';
+import { FcrAiDenoiseLevel, FcrCapability, FcrDesktopMediaControl } from 'fcr-core';
+import { AgoraRtcDisplayInfo, AgoraRtcWindowInfo } from 'agora-rte-sdk/lib/core/rtc/type';
+import { VirtualBackground } from '../modules/device-pretest/assets/virtual-backdound-resources';
+import { FcrUIVideoEffectType, FcrUIBeautyKey, FcrUIConnectType, FcrUIResource, FcrUIDeviceItem, FcrUIDeviceObserver, FcrUIMediaConfig } from '../type';
+import { FcrUIEventProvider } from './event-provider';
+import { BeautyKey, DeviceItem } from '../modules/setting/store';
+export declare const DEFAULT_DEVICE_ID = "default";
+export interface FcrUIDeviceProvider {
+    get cameraId(): string;
+    get microphoneId(): string;
+    get speakerId(): string;
+    get currentDeviceId(): {
+        cameraDeviceId: string;
+        microphoneDeviceId: string;
+        speakerDeviceId: string;
+    };
+    get cameraTrack(): FcrCameraTrack;
+    get microphoneTrack(): FcrMicrophoneTrack;
+    get screenTrack(): FcrCameraTrack | null;
+    get cameraEnabled(): boolean;
+    get microphoneEnabled(): boolean;
+    get isMainRoomAudioOff(): boolean;
+    get isLocalMirrorEnabled(): boolean;
+    get isLocalEditBeautyOptions(): boolean;
+    get beautyOptions(): FcrBeautyOptions;
+    get enableBeauty(): boolean;
+    get virtualBackgroundName(): string;
+    get cameraList(): FcrDeviceInfo[];
+    get microphoneList(): FcrDeviceInfo[];
+    get speakerList(): FcrDeviceInfo[];
+    get speakerVolume(): number;
+    get isAudioConnected(): boolean;
+    get virtualBackgroundList(): VirtualBackground[];
+    get microphoneVolumeLevel(): number;
+    get showForceOpenEffectDialog(): boolean;
+    get speakerVolumeLevel(): number;
+    get cameraDeviceList(): DeviceItem[];
+    get speakerDeviceList(): DeviceItem[];
+    get microphoneDeviceList(): DeviceItem[];
+    get speakerDetecting(): boolean;
+    get microphoneDetecting(): boolean;
+    get showCameraPreview(): boolean;
+    get soundEffectList(): Map<string, Record<string, string>>;
+    get beautyKey(): FcrUIBeautyKey;
+    get microphoneVolume(): number;
+    get currentIsMirror(): boolean;
+    get defaultMirror(): boolean;
+    get connectType(): FcrUIConnectType;
+    setMicrophoneVolume(value: number): void;
+    enableAudioHiFiMode(enable: boolean): void;
+    enableAudioEchoCancellation(enable: boolean): void;
+    enableAudioStereo(enable: boolean): void;
+    setNoiseLevel(level: FcrAiDenoiseLevel): void;
+    startOrStopCamera(enable: boolean): void;
+    setConnectType(type: FcrUIConnectType): void;
+    getScreenTrack(id: string): FcrScreenTrack;
+    checkLoopbackDevice(): Promise<number>;
+    getLoopbackTrack(id: string): FcrLoopbackTrack;
+    isCapabilitySupported(type: FcrCapability): boolean;
+    getWindowList(): Promise<AgoraRtcWindowInfo[]>;
+    getDisplayList(): Promise<AgoraRtcDisplayInfo[]>;
+    stopAudioByComputer(): void;
+    ifAccessMicrophone(): Promise<boolean>;
+    ifAccessCamera(): Promise<boolean>;
+    ifNeedExecuteAutoConnectAudio(): boolean;
+    ifNeedExecuteConnectAudioOption(): boolean;
+    connectAudio(includeMicrophone: boolean): void;
+    disconnectAudio(): void;
+    ifNeedExecuteOpenCamera(): boolean;
+    setCameraId(cameraId: string): void;
+    setMicrophoneId(microphoneId: string): void;
+    setSpeakerId(speakerId: string): void;
+    actionsBeforeJoin(): void;
+    joinAudioByComputer(): Promise<void>;
+    downloadUiResources(uiResource?: FcrUIResource): void;
+    setMicrophoneEnabled(enable: boolean): void;
+    setCameraEnabled(enable: boolean): void;
+    startPlayLocalVideo(view: HTMLElement, isMirror?: boolean): void;
+    stopPlayLocalVideo(view: HTMLElement): void;
+    addObserver(observer: FcrUIDeviceObserver): void;
+    removeObserver(observer: FcrUIDeviceObserver): void;
+    setVideoOrientation(): void;
+    removeObserver(observer: FcrUIDeviceObserver): void;
+    setAudioConnected(enable: boolean): void;
+    setMainRoomAudioOff(enable: boolean): void;
+    setBeautyOptions(beautyOption: Partial<FcrBeautyOptions>): void;
+    enableBeautyEffect(enable: boolean): void;
+    toggleLocalMirrorPreview(enable: boolean): void;
+    toggleLocalMirror(enable: boolean): void;
+    enableVirtualBackground(enable: boolean, source?: VirtualBackground): void;
+    setEditBeautyKey(key: BeautyKey): void;
+    handleForceOpenVideoEffect(): void;
+    handleCancelForceOpenVideoEffect(): void;
+    stopMicrophoneTest(): void;
+    startMicrophoneTest(): void;
+    stopSpeakerTest(): void;
+    startSpeakerTest(): void;
+    setSpeakerVolume(value: number): void;
+    setSelectedSpeakerVolume(volume: number): void;
+    handleRealCameraEnabledChanged(enable: boolean): void;
+    handleCameraChanged(enable: boolean): void;
+    resetMirror(): void;
+}
+export declare class FcrUIDeviceProviderImpl implements FcrUIDeviceProvider {
+    private _eventProvider;
+    private _mediaControl;
+    private _mediaConfig;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _observable;
+    private _listeners;
+    private _hasExecutedOpenCamera;
+    private _hasExecutedConnectAudio;
+    private _isAudioConnected;
+    private _cameraVideoTrack?;
+    private _microphoneAudioTrack?;
+    private _localVideoViewSet;
+    private _videoRotation;
+    private _playAudioTimer?;
+    private _isForceEnableBeauty;
+    private _isForceEnableVirtualBackground;
+    private _lastEnableVideoEffectType;
+    private _microphoneObserver;
+    private _defaultMirror;
+    private _volumeIndicationInterval;
+    private _microponeInitCount;
+    private _speakerInitCount;
+    private accessor _microphoneDeviceId;
+    private accessor _speakerDeviceId;
+    accessor currentIsMirror: boolean;
+    accessor showForceOpenEffectDialog: boolean;
+    accessor cameraId: string;
+    accessor microphoneId: string;
+    accessor speakerId: string;
+    accessor cameraEnabled: boolean;
+    accessor showCameraPreview: boolean;
+    accessor microphoneEnabled: boolean;
+    accessor cameraList: FcrDeviceInfo[];
+    accessor microphoneList: FcrDeviceInfo[];
+    accessor microphoneVolumeLevel: number;
+    accessor speakerList: FcrDeviceInfo[];
+    accessor isLocalMirrorEnabled: boolean;
+    accessor isLocalEditBeautyOptions: boolean;
+    accessor speakerVolumeLevel: number;
+    accessor speakerVolume: number;
+    accessor microphoneVolume: number;
+    accessor virtualBackgroundName: string;
+    accessor enableBeauty: boolean;
+    accessor beautyKey: FcrUIBeautyKey;
+    accessor beautyOptions: FcrBeautyOptions;
+    accessor virtualBackgroundList: VirtualBackground[];
+    accessor soundEffectList: Map<string, Record<string, string>>;
+    accessor microphoneDetecting: boolean;
+    accessor speakerDetecting: boolean;
+    accessor connectType: FcrUIConnectType;
+    accessor isAudioConnected: boolean;
+    accessor isMainRoomAudioOff: boolean;
+    toggleCameraVideoOrientation(): void;
+    ifAccessMicrophone(): Promise<boolean>;
+    ifAccessCamera(): Promise<boolean>;
+    ifNeedExecuteAutoConnectAudio(): boolean;
+    ifNeedExecuteConnectAudioOption(): boolean;
+    ifNeedExecuteOpenCamera(): boolean;
+    connectAudio(includeMicrophone: boolean): void;
+    disconnectAudio(): void;
+    get defaultMirror(): boolean;
+    get followSystemMicrophoneDevice(): boolean;
+    get followSystemSpeakerDevice(): boolean;
+    get cameraDeviceList(): FcrUIDeviceItem[];
+    get microphoneDeviceList(): FcrUIDeviceItem[];
+    get speakerDeviceList(): FcrUIDeviceItem[];
+    get lastEnableVideoEffectType(): FcrUIVideoEffectType;
+    set lastEnableVideoEffectType(type: FcrUIVideoEffectType);
+    get currentDeviceId(): {
+        cameraDeviceId: string;
+        microphoneDeviceId: string;
+        speakerDeviceId: string;
+    };
+    constructor(_eventProvider: FcrUIEventProvider, _mediaControl: FcrDesktopMediaControl, _mediaConfig: FcrUIMediaConfig);
+    getCameraTrack(deviceId: string): FcrCameraTrack;
+    getMicrophoneTrack(deviceId: string): FcrMicrophoneTrack;
+    getScreenTrack(id: string): FcrScreenTrack;
+    getLoopbackTrack(id: string): FcrLoopbackTrack;
+    checkLoopbackDevice(): Promise<number>;
+    isCapabilitySupported(type: FcrCapability): boolean;
+    getWindowList(): Promise<AgoraRtcWindowInfo[]>;
+    getDisplayList(): Promise<AgoraRtcDisplayInfo[]>;
+    get screenTrack(): FcrCameraTrack | null;
+    get cameraTrack(): FcrCameraTrack;
+    get microphoneTrack(): FcrMicrophoneTrack;
+    setSelectedSpeakerVolume(volume: number): void;
+    init(): Promise<void>;
+    addObserver(observer: FcrUIDeviceObserver): void;
+    removeObserver(observer: FcrUIDeviceObserver): void;
+    startPlayLocalVideo(view: HTMLElement, isMirror?: boolean): void;
+    stopPlayLocalVideo(view: HTMLElement): void;
+    startSpeakerTest(): void;
+    stopSpeakerTest(): void;
+    setCurrentIsMirror(isMirror: boolean): void;
+    toggleLocalMirrorPreview(mirror: boolean): void;
+    setBeautyOptions(beautyOption: Partial<FcrBeautyOptions>): void;
+    handleCancelForceOpenVideoEffect(): void;
+    handleForceOpenVideoEffect(): void;
+    setVideoOrientation(): void;
+    setCameraEnabled(enable: boolean): void;
+    setMicrophoneEnabled(enable: boolean): void;
+    toggleLocalMirror(enable: boolean): void;
+    resetMirror(): void;
+    startMicrophoneTest(): void;
+    stopMicrophoneTest(): void;
+    enableVirtualBackground(enable: boolean, source?: VirtualBackground): void;
+    setEditBeautyKey(key: FcrUIBeautyKey): void;
+    enableBeautyEffect(enable: boolean): void;
+    enableAudioHiFiMode(enable: boolean): void;
+    enableAudioEchoCancellation(enable: boolean): void;
+    enableAudioStereo(enable: boolean): void;
+    setNoiseLevel(level: FcrAiDenoiseLevel): void;
+    setCameraId(cameraId: string): void;
+    setSpeakerId(speakerId: string): Promise<void>;
+    setMicrophoneId(microphoneId: string): Promise<void>;
+    setSpeakerVolume(value: number): void;
+    setMicrophoneVolume(value: number): void;
+    actionsBeforeJoin(): void;
+    startOrStopCamera(enable: boolean): void;
+    setShowCameraPreview(enable: boolean): void;
+    handleRealCameraEnabledChanged(realEnable: boolean): void;
+    handleCameraChanged(enabled: boolean): void;
+    downloadUiResources(uiResource?: FcrUIResource): Promise<void>;
+    release(): void;
+    joinAudioByComputer(): Promise<void>;
+    stopAudioByComputer(): void;
+    private _fileToUiData;
+    setConnectType(connectType: FcrUIConnectType): void;
+    private _fetchZipAndUnzip;
+    private _updateVirtualBackgroundList;
+    private _handleSpeakerTestVolumeIndicationUpdated;
+    private _handleSpeakerVolumeUpdated;
+    private _handleMicrophoneVolumeIndicationUpdated;
+    private _handleCameraChanged;
+    private _handleCameraListUpdated;
+    private _handleMicrophoneListUpdated;
+    private _handleSpeakerListUpdated;
+    setAudioConnected(enable: boolean): void;
+    setMainRoomAudioOff(enable: boolean): void;
+}