fcr-ui-scene 3.8.1-beta → 3.8.2

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

@@ -0,0 +1,2148 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.to-primitive.js";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.is-array.js";
+import "core-js/modules/es.date.to-primitive.js";
+import "core-js/modules/es.function.bind.js";
+import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.object.create.js";
+import "core-js/modules/es.object.define-property.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/esnext.function.metadata.js";
+import "core-js/modules/esnext.symbol.metadata.js";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _FcrUIDeviceProviderImpl;
+var _initProto, _init__microphoneEnabled, _init__isMicrophoneWorking, _init__microphoneDevice, _init__microphone, _init__speakerDevice, _init__speaker, _init__cameraDevice, _init_currentIsMirror, _init_showForceOpenEffectDialog, _init_cameraEnabled, _init_showCameraPreview, _init_cameraList, _init_microphoneList, _init_microphoneVolumeLevel, _init_speakerList, _init_isLocalMirrorEnabled, _init_isLocalEditBeautyOptions, _init_speakerVolumeLevel, _init_speakerVolume, _init_microphoneVolume, _init_virtualBackgroundName, _init_enableBeauty, _init_beautyKey, _init_beautyOptions, _init_virtualBackgroundList, _init_microphoneDetecting, _init_speakerDetecting, _init_connectType, _init_isMainRoomAudioOff, _startPlayLocalVideoDecs, _stopPlayLocalVideoDecs, _startSpeakerTestDecs, _stopSpeakerTestDecs, _setCurrentIsMirrorDecs, _toggleLocalMirrorPreviewDecs, _setBeautyOptionsDecs, _handleCancelForceOpenVideoEffectDecs, _handleForceOpenVideoEffectDecs, _setCameraEnabledDecs, _handleCameraEnabledChangedDecs, _setMicrophoneEnabledDecs, _toggleLocalMirrorDecs, _resetMirrorDecs, _startMicrophoneTestDecs, _stopMicrophoneTestDecs, _enableVirtualBackgroundDecs, _setEditBeautyKeyDecs, _enableBeautyEffectDecs, _setCameraIdDecs, _setMainRoomAudioOffDecs, _setSpeakerIdDecs, _setMicrophoneIdDecs, _setSpeakerVolumeDecs, _setMicrophoneVolumeDecs, _startOrStopCameraDecs, _setShowCameraPreviewDecs, _loadUiResourcesDecs, _setConnectTypeDecs, _toggleLocalCameraPreviewDecs, _getLoopbackDeviceIdDecs, _initDeviceListDecs, _handleMicrophoneAudioTrackDecs, _handleMicrophoneStateUpdatedDecs, _handleMicrophoneEnabledChangedDecs, _handleCameraVideoTrackDecs, _handleSpeakerDetectingChangedDecs, _stopSelectedSpeakerTestDecs, _handleMicrophoneDetectingChangedDecs, _stopMicrophoneTestDecs2, _updateVirtualBackgroundListDecs, _handleSystemSelectedSpeakerChangedDecs, _handleSystemSelectedMicrophoneChangedDecs, _correctSystemSelectedMicrophoneDeviceIdDecs, _handleSelectedSpeakerVolumeUpdatedDecs, _handleSpeakerTestVolumeIndicationUpdatedDecs, _handleMicrophoneVolumeIndicationUpdatedDecs, _handleSpeakerAddedDecs, _handleSpeakerRemovedDecs, _handleSpeakerListUpdatedDecs, _getMicrophoneListDecs, _getSpeakerListDecs, _formatDeviceListDecs, _loadBuiltinResourcesDecs, _ref;
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.array.reduce.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.some.js";
+import "core-js/modules/es.array.sort.js";
+import "core-js/modules/es.array.unshift.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.assign.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.promise.all-settled.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.weak-map.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/esnext.iterator.reduce.js";
+import "core-js/modules/esnext.iterator.some.js";
+import "core-js/modules/esnext.map.delete-all.js";
+import "core-js/modules/esnext.map.emplace.js";
+import "core-js/modules/esnext.map.every.js";
+import "core-js/modules/esnext.map.filter.js";
+import "core-js/modules/esnext.map.find.js";
+import "core-js/modules/esnext.map.find-key.js";
+import "core-js/modules/esnext.map.includes.js";
+import "core-js/modules/esnext.map.key-of.js";
+import "core-js/modules/esnext.map.map-keys.js";
+import "core-js/modules/esnext.map.map-values.js";
+import "core-js/modules/esnext.map.merge.js";
+import "core-js/modules/esnext.map.reduce.js";
+import "core-js/modules/esnext.map.some.js";
+import "core-js/modules/esnext.map.update.js";
+import "core-js/modules/esnext.set.add-all.js";
+import "core-js/modules/esnext.set.delete-all.js";
+import "core-js/modules/esnext.set.difference.v2.js";
+import "core-js/modules/esnext.set.difference.js";
+import "core-js/modules/esnext.set.every.js";
+import "core-js/modules/esnext.set.filter.js";
+import "core-js/modules/esnext.set.find.js";
+import "core-js/modules/esnext.set.intersection.v2.js";
+import "core-js/modules/esnext.set.intersection.js";
+import "core-js/modules/esnext.set.is-disjoint-from.v2.js";
+import "core-js/modules/esnext.set.is-disjoint-from.js";
+import "core-js/modules/esnext.set.is-subset-of.v2.js";
+import "core-js/modules/esnext.set.is-subset-of.js";
+import "core-js/modules/esnext.set.is-superset-of.v2.js";
+import "core-js/modules/esnext.set.is-superset-of.js";
+import "core-js/modules/esnext.set.join.js";
+import "core-js/modules/esnext.set.map.js";
+import "core-js/modules/esnext.set.reduce.js";
+import "core-js/modules/esnext.set.some.js";
+import "core-js/modules/esnext.set.symmetric-difference.v2.js";
+import "core-js/modules/esnext.set.symmetric-difference.js";
+import "core-js/modules/esnext.set.union.v2.js";
+import "core-js/modules/esnext.set.union.js";
+import "core-js/modules/esnext.weak-map.delete-all.js";
+import "core-js/modules/esnext.weak-map.emplace.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/web.timers.js";
+import "core-js/modules/web.url.js";
+import "core-js/modules/web.url.to-json.js";
+import "core-js/modules/web.url-search-params.js";
+import "core-js/modules/web.url-search-params.delete.js";
+import "core-js/modules/web.url-search-params.has.js";
+import "core-js/modules/web.url-search-params.size.js";
+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"); }
+function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function set(e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O["static"] = l, O["private"] = f, f ? 2 === o ? k = function k(e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function k(e) { return e[n]; }, (o < 2 || 4 === o) && (F = function F(e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == _typeof(P) && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol["for"]("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol["for"]("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function s(t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, 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 _setFunctionName(e, t, n) { "symbol" == _typeof(t) && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
+function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? _typeof(e) : "null")); return e; }
+import { AgoraObservable, bound, jsonstring } from 'fcr-core/lib/imports';
+import { FcrMediaSourceState } from 'fcr-core/lib/type';
+import { isElectron } from 'agora-foundation/lib/utilities/env';
+import { FcrVideoRenderMode } from 'fcr-core';
+import { FcrVideoOrientation } from 'fcr-core/lib/type';
+import { DEFAULT_BEAUTY_VALUE } from 'agora-ui-foundation/lib/components/local-video-player';
+import { transI18n } from 'agora-ui-foundation/lib/i18n';
+import { observable, reaction, runInAction, action, computed } from 'mobx';
+import { VirtualOption } from '../modules/device-pretest/assets/virtual-backdound-resources';
+import { FcrUIVideoEffectType, FcrUIConnectType, FcrUIAiDenoiseLevel, FcrUIMicrophoneState } from '../type';
+import { convertToFixedNumber, isPngOrJpg, getFileNameWithoutExtension, isMp4, isMp3OrWav, matchVirtualSoundCardPattern, isZipUrl, isMp3OrWavUrl } from '../utilities/tools';
+import { createLogger } from '../utilities/logger';
+import clone from 'lodash/clone';
+// device id for default device (follow system)
+export var DEFAULT_DEVICE_ID = 'default';
+var getDeviceVolumeLevel = function getDeviceVolumeLevel(volume) {
+  return Math.floor(volume / 255 * 100);
+};
+var _A = /*#__PURE__*/new WeakMap();
+var _B = /*#__PURE__*/new WeakMap();
+var _C = /*#__PURE__*/new WeakMap();
+var _D = /*#__PURE__*/new WeakMap();
+var _E = /*#__PURE__*/new WeakMap();
+var _F = /*#__PURE__*/new WeakMap();
+var _G = /*#__PURE__*/new WeakMap();
+var _H = /*#__PURE__*/new WeakMap();
+var _I = /*#__PURE__*/new WeakMap();
+var _J = /*#__PURE__*/new WeakMap();
+var _K = /*#__PURE__*/new WeakMap();
+var _L = /*#__PURE__*/new WeakMap();
+var _M = /*#__PURE__*/new WeakMap();
+var _N = /*#__PURE__*/new WeakMap();
+var _O = /*#__PURE__*/new WeakMap();
+var _P = /*#__PURE__*/new WeakMap();
+var _Q = /*#__PURE__*/new WeakMap();
+var _R = /*#__PURE__*/new WeakMap();
+var _S = /*#__PURE__*/new WeakMap();
+var _T = /*#__PURE__*/new WeakMap();
+var _U = /*#__PURE__*/new WeakMap();
+var _V = /*#__PURE__*/new WeakMap();
+var _W = /*#__PURE__*/new WeakMap();
+var _X = /*#__PURE__*/new WeakMap();
+var _Y = /*#__PURE__*/new WeakMap();
+var _Z = /*#__PURE__*/new WeakMap();
+var _a = /*#__PURE__*/new WeakMap();
+var _b = /*#__PURE__*/new WeakMap();
+var _c = /*#__PURE__*/new WeakMap();
+_ref = (_startPlayLocalVideoDecs = [action, action.bound], _stopPlayLocalVideoDecs = [action, action.bound], _startSpeakerTestDecs = [action, action.bound], _stopSpeakerTestDecs = [action, action.bound], _setCurrentIsMirrorDecs = [action, action.bound], _toggleLocalMirrorPreviewDecs = [action, action.bound], _setBeautyOptionsDecs = [action, action.bound], _handleCancelForceOpenVideoEffectDecs = [action, action.bound], _handleForceOpenVideoEffectDecs = [action, action.bound], _setCameraEnabledDecs = [action, action.bound], _handleCameraEnabledChangedDecs = [action, action.bound], _setMicrophoneEnabledDecs = [action, action.bound], _toggleLocalMirrorDecs = [action, action.bound], _resetMirrorDecs = [action, action.bound], _startMicrophoneTestDecs = [action, action.bound], _stopMicrophoneTestDecs = [action, action.bound], _enableVirtualBackgroundDecs = [action, action.bound], _setEditBeautyKeyDecs = [action, action.bound], _enableBeautyEffectDecs = [action, action.bound], _setCameraIdDecs = [action, action.bound], _setMainRoomAudioOffDecs = [action, action.bound], _setSpeakerIdDecs = [action, action.bound], _setMicrophoneIdDecs = [action, action.bound], _setSpeakerVolumeDecs = [action, action.bound], _setMicrophoneVolumeDecs = [action, action.bound], _startOrStopCameraDecs = [action, action.bound], _setShowCameraPreviewDecs = [action, action.bound], _loadUiResourcesDecs = [action, action.bound], _setConnectTypeDecs = [action, action.bound], _toggleLocalCameraPreviewDecs = [action, action.bound], _getLoopbackDeviceIdDecs = [action, action.bound], _initDeviceListDecs = [action, action.bound], _handleMicrophoneAudioTrackDecs = [action, action.bound], _handleMicrophoneStateUpdatedDecs = [action, action.bound], _handleMicrophoneEnabledChangedDecs = [action, action.bound], _handleCameraVideoTrackDecs = [action, action.bound], _handleSpeakerDetectingChangedDecs = [action, action.bound], _stopSelectedSpeakerTestDecs = [action, action.bound], _handleMicrophoneDetectingChangedDecs = [action, action.bound], _stopMicrophoneTestDecs2 = [action, action.bound], _updateVirtualBackgroundListDecs = [action, action.bound], _handleSystemSelectedSpeakerChangedDecs = [action, action.bound], _handleSystemSelectedMicrophoneChangedDecs = [action, action.bound], _correctSystemSelectedMicrophoneDeviceIdDecs = [action, action.bound], _handleSelectedSpeakerVolumeUpdatedDecs = [action, action.bound], _handleSpeakerTestVolumeIndicationUpdatedDecs = [action, action.bound], _handleMicrophoneVolumeIndicationUpdatedDecs = [action, action.bound], _handleSpeakerAddedDecs = [action, action.bound], _handleSpeakerRemovedDecs = [action, action.bound], _handleSpeakerListUpdatedDecs = [action, action.bound], _getMicrophoneListDecs = [action, action.bound], _getSpeakerListDecs = [action, action.bound], _formatDeviceListDecs = [action, action.bound], _loadBuiltinResourcesDecs = [action, action.bound], "logger");
+export var FcrUIDeviceProviderImpl = /*#__PURE__*/function () {
+  function FcrUIDeviceProviderImpl(_renderer, _facilityProvider, _messageProvider, _mediaControl, _sharedSettingDataSource) {
+    var _this = this;
+    _classCallCheck(this, FcrUIDeviceProviderImpl);
+    _defineProperty(this, _ref, (_initProto(this), createLogger({
+      prefix: 'FcrUIDeviceProviderImpl'
+    })));
+    _defineProperty(this, "_observable", new AgoraObservable());
+    _defineProperty(this, "_disposer", []);
+    _defineProperty(this, "_hasExecutedOpenCamera", false);
+    _defineProperty(this, "_hasExecutedConnectAudio", false);
+    _defineProperty(this, "_isAudioConnected", false);
+    _defineProperty(this, "_cameraVideoTrack", null);
+    _defineProperty(this, "_microphoneAudioTrack", null);
+    _defineProperty(this, "_localVideoViewSet", new Set());
+    _defineProperty(this, "_videoRotation", FcrVideoOrientation.VIDEO_ORIENTATION_0);
+    _defineProperty(this, "_released", false);
+    // 强制开启美颜
+    _defineProperty(this, "_isForceEnableBeauty", false);
+    // 强制开启虚拟背景
+    _defineProperty(this, "_isForceEnableVirtualBackground", false);
+    // 上次操作特效的类型
+    _defineProperty(this, "_lastEnableVideoEffectType", FcrUIVideoEffectType.NONE);
+    // microphone observer
+    _defineProperty(this, "_microphoneObserver", {
+      onVolumeIndicationUpdated: this._handleMicrophoneVolumeIndicationUpdated,
+      onMicrophoneStateUpdated: this._handleMicrophoneStateUpdated
+    });
+    _defineProperty(this, "_mediaControlObserver", {
+      onCameraAdded: this._handleCameraAdded,
+      onCameraRemoved: this._handleCameraRemoved,
+      onMicrophoneAdded: this._handleMicrophoneAdded,
+      onMicrophoneRemoved: this._handleMicrophoneRemoved,
+      onSpeakerAdded: this._handleSpeakerAdded,
+      onSpeakerRemoved: this._handleSpeakerRemoved,
+      onSpeakerTestVolumeIndicationUpdated: this._handleSpeakerTestVolumeIndicationUpdated,
+      onSelectedSpeakerVolumeUpdated: this._handleSelectedSpeakerVolumeUpdated,
+      onSystemSelectedSpeakerChanged: this._handleSystemSelectedSpeakerChanged,
+      onSystemSelectedMicrophoneChanged: this._handleSystemSelectedMicrophoneChanged
+    });
+    _defineProperty(this, "_defaultMirror", true);
+    _defineProperty(this, "_volumeIndicationInterval", 200);
+    _defineProperty(this, "_soundEffectPlayUrlMap", new Map());
+    _defineProperty(this, "_soundEffectFilePathMap", new Map());
+    _classPrivateFieldInitSpec(this, _A, _init__microphoneEnabled(this, false));
+    _classPrivateFieldInitSpec(this, _B, _init__isMicrophoneWorking(this, false));
+    _classPrivateFieldInitSpec(this, _C, _init__microphoneDevice(this, {
+      id: null,
+      name: null,
+      productId: '',
+      vendorId: ''
+    }));
+    _classPrivateFieldInitSpec(this, _D, _init__microphone(this, {
+      id: DEFAULT_DEVICE_ID
+    }));
+    _classPrivateFieldInitSpec(this, _E, _init__speakerDevice(this, {
+      id: null,
+      name: null,
+      productId: '',
+      vendorId: ''
+    }));
+    _classPrivateFieldInitSpec(this, _F, _init__speaker(this, {
+      id: DEFAULT_DEVICE_ID
+    }));
+    _classPrivateFieldInitSpec(this, _G, _init__cameraDevice(this, {
+      id: null
+    }));
+    // 是否开启镜像
+    _classPrivateFieldInitSpec(this, _H, _init_currentIsMirror(this, true));
+    // 是否展示展示强制开启特效弹窗
+    _classPrivateFieldInitSpec(this, _I, _init_showForceOpenEffectDialog(this, false));
+    _classPrivateFieldInitSpec(this, _J, _init_cameraEnabled(this, false));
+    _classPrivateFieldInitSpec(this, _K, _init_showCameraPreview(this, false));
+    // @observable accessor microphoneEnabled = false;
+    _classPrivateFieldInitSpec(this, _L, _init_cameraList(this, []));
+    _classPrivateFieldInitSpec(this, _M, _init_microphoneList(this, []));
+    _classPrivateFieldInitSpec(this, _N, _init_microphoneVolumeLevel(this, 0));
+    _classPrivateFieldInitSpec(this, _O, _init_speakerList(this, []));
+    _classPrivateFieldInitSpec(this, _P, _init_isLocalMirrorEnabled(this, false));
+    _classPrivateFieldInitSpec(this, _Q, _init_isLocalEditBeautyOptions(this, false));
+    _classPrivateFieldInitSpec(this, _R, _init_speakerVolumeLevel(this, 0));
+    _classPrivateFieldInitSpec(this, _S, _init_speakerVolume(this, 0));
+    _classPrivateFieldInitSpec(this, _T, _init_microphoneVolume(this, 100));
+    _classPrivateFieldInitSpec(this, _U, _init_virtualBackgroundName(this, 'None'));
+    _classPrivateFieldInitSpec(this, _V, _init_enableBeauty(this, false));
+    _classPrivateFieldInitSpec(this, _W, _init_beautyKey(this, 'none'));
+    _classPrivateFieldInitSpec(this, _X, _init_beautyOptions(this, {
+      lighteningContrastLevel: 0,
+      lighteningLevel: DEFAULT_BEAUTY_VALUE,
+      smoothnessLevel: DEFAULT_BEAUTY_VALUE,
+      sharpnessLevel: DEFAULT_BEAUTY_VALUE,
+      rednessLevel: DEFAULT_BEAUTY_VALUE
+    }));
+    _classPrivateFieldInitSpec(this, _Y, _init_virtualBackgroundList(this, []));
+    _classPrivateFieldInitSpec(this, _Z, _init_microphoneDetecting(this, false));
+    _classPrivateFieldInitSpec(this, _a, _init_speakerDetecting(this, false));
+    _classPrivateFieldInitSpec(this, _b, _init_connectType(this, FcrUIConnectType.NONE));
+    _classPrivateFieldInitSpec(this, _c, _init_isMainRoomAudioOff(this, false));
+    this._renderer = _renderer;
+    this._facilityProvider = _facilityProvider;
+    this._messageProvider = _messageProvider;
+    this._mediaControl = _mediaControl;
+    this._sharedSettingDataSource = _sharedSettingDataSource;
+    this._disposer.push(reaction(function () {
+      return _this.cameraEnabled;
+    }, this._handleCameraEnabledChanged), reaction(function () {
+      return _this._cameraDevice;
+    }, this._handleCameraDeviceIdChanged), reaction(function () {
+      return _this._microphoneEnabled;
+    }, this._handleMicrophoneEnabledChanged), reaction(function () {
+      return _this._microphone;
+    }, this._handleMicrophoneIdChanged), reaction(function () {
+      return _this._microphoneDevice;
+    }, this._handleMicrophoneDeviceIdChanged), reaction(function () {
+      return _this._speaker;
+    }, this._handleSpeakerIdChanged), reaction(function () {
+      return _this._speakerDevice;
+    }, this._handleSpeakerDeviceIdChanged), reaction(function () {
+      return _this.speakerDetecting;
+    }, this._handleSpeakerDetectingChanged), reaction(function () {
+      return _this.microphoneDetecting;
+    }, this._handleMicrophoneDetectingChanged));
+    this._mediaControl.addObserver(this._mediaControlObserver);
+    this._initDeviceList();
+    runInAction(function () {
+      _this.speakerVolume = _this._mediaControl.getSelectedSpeakerVolume();
+    });
+  }
+  return _createClass(FcrUIDeviceProviderImpl, [{
+    key: "_microphoneEnabled",
+    get: function get() {
+      return _classPrivateFieldGet(_A, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_A, this, v);
+    }
+  }, {
+    key: "_isMicrophoneWorking",
+    get: function get() {
+      return _classPrivateFieldGet(_B, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_B, this, v);
+    }
+  }, {
+    key: "_microphoneDevice",
+    get: function get() {
+      return _classPrivateFieldGet(_C, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_C, this, v);
+    }
+  }, {
+    key: "_microphone",
+    get: function get() {
+      return _classPrivateFieldGet(_D, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_D, this, v);
+    }
+  }, {
+    key: "_speakerDevice",
+    get: function get() {
+      return _classPrivateFieldGet(_E, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_E, this, v);
+    }
+  }, {
+    key: "_speaker",
+    get: function get() {
+      return _classPrivateFieldGet(_F, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_F, this, v);
+    }
+  }, {
+    key: "_cameraDevice",
+    get: function get() {
+      return _classPrivateFieldGet(_G, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_G, this, v);
+    }
+  }, {
+    key: "currentIsMirror",
+    get: function get() {
+      return _classPrivateFieldGet(_H, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_H, this, v);
+    }
+  }, {
+    key: "showForceOpenEffectDialog",
+    get: function get() {
+      return _classPrivateFieldGet(_I, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_I, this, v);
+    }
+  }, {
+    key: "cameraEnabled",
+    get: function get() {
+      return _classPrivateFieldGet(_J, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_J, this, v);
+    }
+  }, {
+    key: "showCameraPreview",
+    get: function get() {
+      return _classPrivateFieldGet(_K, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_K, this, v);
+    }
+  }, {
+    key: "cameraList",
+    get: function get() {
+      return _classPrivateFieldGet(_L, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_L, this, v);
+    }
+  }, {
+    key: "microphoneList",
+    get: function get() {
+      return _classPrivateFieldGet(_M, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_M, this, v);
+    }
+  }, {
+    key: "microphoneVolumeLevel",
+    get: function get() {
+      return _classPrivateFieldGet(_N, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_N, this, v);
+    }
+  }, {
+    key: "speakerList",
+    get: function get() {
+      return _classPrivateFieldGet(_O, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_O, this, v);
+    }
+  }, {
+    key: "isLocalMirrorEnabled",
+    get: function get() {
+      return _classPrivateFieldGet(_P, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_P, this, v);
+    }
+  }, {
+    key: "isLocalEditBeautyOptions",
+    get: function get() {
+      return _classPrivateFieldGet(_Q, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_Q, this, v);
+    }
+  }, {
+    key: "speakerVolumeLevel",
+    get: function get() {
+      return _classPrivateFieldGet(_R, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_R, this, v);
+    }
+  }, {
+    key: "speakerVolume",
+    get: function get() {
+      return _classPrivateFieldGet(_S, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_S, this, v);
+    }
+  }, {
+    key: "microphoneVolume",
+    get: function get() {
+      return _classPrivateFieldGet(_T, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_T, this, v);
+    }
+  }, {
+    key: "virtualBackgroundName",
+    get: function get() {
+      return _classPrivateFieldGet(_U, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_U, this, v);
+    }
+  }, {
+    key: "enableBeauty",
+    get: function get() {
+      return _classPrivateFieldGet(_V, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_V, this, v);
+    }
+  }, {
+    key: "beautyKey",
+    get: function get() {
+      return _classPrivateFieldGet(_W, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_W, this, v);
+    }
+  }, {
+    key: "beautyOptions",
+    get: function get() {
+      return _classPrivateFieldGet(_X, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_X, this, v);
+    }
+  }, {
+    key: "virtualBackgroundList",
+    get: function get() {
+      return _classPrivateFieldGet(_Y, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_Y, this, v);
+    }
+  }, {
+    key: "microphoneDetecting",
+    get: function get() {
+      return _classPrivateFieldGet(_Z, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_Z, this, v);
+    }
+  }, {
+    key: "speakerDetecting",
+    get: function get() {
+      return _classPrivateFieldGet(_a, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_a, this, v);
+    }
+  }, {
+    key: "connectType",
+    get: function get() {
+      return _classPrivateFieldGet(_b, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_b, this, v);
+    }
+  }, {
+    key: "isMainRoomAudioOff",
+    get: function get() {
+      return _classPrivateFieldGet(_c, this);
+    },
+    set: function set(v) {
+      _classPrivateFieldSet(_c, this, v);
+    }
+  }, {
+    key: "ifAccessMicrophone",
+    value: function () {
+      var _ifAccessMicrophone = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var hasSystemPermission;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              hasSystemPermission = true;
+              if (!isElectron()) {
+                _context.next = 2;
+                break;
+              }
+              _context.next = 1;
+              return this._facilityProvider.checkMicrophonePermission();
+            case 1:
+              hasSystemPermission = _context.sent;
+            case 2:
+              return _context.abrupt("return", hasSystemPermission);
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function ifAccessMicrophone() {
+        return _ifAccessMicrophone.apply(this, arguments);
+      }
+      return ifAccessMicrophone;
+    }()
+  }, {
+    key: "ifAccessCamera",
+    value: function () {
+      var _ifAccessCamera = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var hasSystemPermission;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              hasSystemPermission = true;
+              if (!isElectron()) {
+                _context2.next = 2;
+                break;
+              }
+              _context2.next = 1;
+              return this._facilityProvider.checkCameraPermission();
+            case 1:
+              hasSystemPermission = _context2.sent;
+            case 2:
+              return _context2.abrupt("return", hasSystemPermission);
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function ifAccessCamera() {
+        return _ifAccessCamera.apply(this, arguments);
+      }
+      return ifAccessCamera;
+    }()
+  }, {
+    key: "ifNeedExecuteAutoConnectAudio",
+    value: function ifNeedExecuteAutoConnectAudio() {
+      return this._sharedSettingDataSource.media.autoConnectAudio && !this._hasExecutedConnectAudio;
+    }
+  }, {
+    key: "ifNeedExecuteConnectAudioOption",
+    value: function ifNeedExecuteConnectAudioOption() {
+      return !this._sharedSettingDataSource.media.autoConnectAudio && !this._hasExecutedConnectAudio;
+    }
+  }, {
+    key: "ifNeedExecuteOpenCamera",
+    value: function ifNeedExecuteOpenCamera() {
+      return !this._hasExecutedOpenCamera && !this._sharedSettingDataSource.media.cameraExpectedOff;
+    }
+  }, {
+    key: "connectAudio",
+    value: function connectAudio(includeMicrophone) {
+      if (includeMicrophone) {
+        var dontNeedOpenMicrophone = !this._hasExecutedConnectAudio && this._sharedSettingDataSource.media.microphoneExpectedOff;
+        if (!dontNeedOpenMicrophone) {
+          this.setMicrophoneEnabled(true);
+        }
+      }
+      if (this.microphoneList.length > 0) {
+        this._messageProvider.showToast({
+          type: 'normal',
+          message: transI18n('fmt_gateway_tips_nodata')
+        });
+      } else {
+        this._messageProvider.showToast({
+          type: 'normal',
+          message: transI18n('fmt_toolbar_label_nodevice')
+        });
+      }
+      this._hasExecutedConnectAudio = true;
+      // this._mediaControl.adjustOutputVolume(100);
+
+      this._isAudioConnected = true;
+      this.setConnectType(FcrUIConnectType.COMPUTER);
+      this._observable.notifyObservers('onAudioConnected');
+    }
+  }, {
+    key: "disconnectAudio",
+    value: function disconnectAudio() {
+      this._hasExecutedConnectAudio = true;
+      this._isAudioConnected = false;
+      this.setMicrophoneEnabled(false);
+      // this._mediaControl.adjustOutputVolume(0);
+      this.setConnectType(FcrUIConnectType.NONE);
+      this._observable.notifyObservers('onAudioDisconnected');
+    }
+  }, {
+    key: "cameraId",
+    get: function get() {
+      return this._cameraDevice.id || '';
+    }
+  }, {
+    key: "speakerId",
+    get: function get() {
+      return this._speaker.id;
+    }
+  }, {
+    key: "microphoneId",
+    get: function get() {
+      return this._microphone.id;
+    }
+  }, {
+    key: "defaultMirror",
+    get: function get() {
+      return this._defaultMirror;
+    }
+  }, {
+    key: "followSystemMicrophoneDevice",
+    get: function get() {
+      return this._microphone.id === DEFAULT_DEVICE_ID;
+    }
+  }, {
+    key: "followSystemSpeakerDevice",
+    get: function get() {
+      return this._speaker.id === DEFAULT_DEVICE_ID;
+    }
+  }, {
+    key: "lastEnableVideoEffectType",
+    get: function get() {
+      return this._lastEnableVideoEffectType;
+    },
+    set: function set(type) {
+      this._lastEnableVideoEffectType = type;
+    }
+  }, {
+    key: "currentDeviceId",
+    get: function get() {
+      return {
+        cameraDeviceId: this._cameraDevice.id || '',
+        microphoneDeviceId: this._microphoneDevice.id || '',
+        speakerDeviceId: this._speakerDevice.id || ''
+      };
+    }
+  }, {
+    key: "currentDeviceName",
+    get: function get() {
+      return {
+        microphoneDeviceName: this._microphoneDevice.name || '',
+        speakerDeviceName: this._speakerDevice.name || ''
+      };
+    }
+  }, {
+    key: "isAudioConnected",
+    get: function get() {
+      return this._isAudioConnected;
+    }
+  }, {
+    key: "shouldEnableMicBeforeSession",
+    get: function get() {
+      return !this._sharedSettingDataSource.media.microphoneExpectedOff && this._sharedSettingDataSource.media.autoConnectAudio;
+    }
+  }, {
+    key: "microphoneEnabled",
+    get: function get() {
+      return this._microphoneEnabled && !this.speakerDetecting && this._isMicrophoneWorking;
+    }
+  }, {
+    key: "microphoneState",
+    get: function get() {
+      if (this.speakerDetecting) {
+        return FcrUIMicrophoneState.MUTE;
+      }
+      if (this._microphoneEnabled && this._isMicrophoneWorking) {
+        return FcrUIMicrophoneState.UNMUTE;
+      }
+      if (this._microphoneEnabled && !this._isMicrophoneWorking) {
+        return FcrUIMicrophoneState.OPENING;
+      }
+      if (!this._microphoneEnabled) {
+        return FcrUIMicrophoneState.MUTE;
+      }
+      return FcrUIMicrophoneState.MUTE;
+    }
+  }, {
+    key: "soundEffectPlayUrlMap",
+    get: function get() {
+      return this._soundEffectPlayUrlMap;
+    }
+  }, {
+    key: "soundEffectFilePathMap",
+    get: function get() {
+      return this._soundEffectFilePathMap;
+    }
+  }, {
+    key: "resetDevice",
+    value: function resetDevice() {
+      this._hasExecutedOpenCamera = false;
+      this._hasExecutedConnectAudio = false;
+      this._isAudioConnected = false;
+      this.setCameraEnabled(false);
+      this.setMicrophoneEnabled(false);
+      this.setConnectType(FcrUIConnectType.NONE);
+      this._observable.notifyObservers('onAudioDisconnected');
+    }
+  }, {
+    key: "release",
+    value: function release() {
+      var _this$_cameraVideoTra, _this$_microphoneAudi;
+      this._released = true;
+      this._mediaControl.removeObserver(this._mediaControlObserver);
+      this._toggleLocalCameraPreview(false);
+      this._localVideoViewSet.clear();
+      (_this$_cameraVideoTra = this._cameraVideoTrack) === null || _this$_cameraVideoTra === void 0 || _this$_cameraVideoTra.stop();
+      this._cameraVideoTrack = null;
+      this._stopSelectedSpeakerTest();
+      this._stopMicrophoneTest();
+      (_this$_microphoneAudi = this._microphoneAudioTrack) === null || _this$_microphoneAudi === void 0 || _this$_microphoneAudi.stop();
+      this._microphoneAudioTrack = null;
+      this._isMicrophoneWorking = false;
+      this._disposer.forEach(function (disposer) {
+        return disposer();
+      });
+      this._disposer = [];
+    }
+  }, {
+    key: "getScreenTrack",
+    value: function getScreenTrack(id) {
+      return this._mediaControl.getScreenTrack(id);
+    }
+  }, {
+    key: "getLoopbackTrack",
+    value: function getLoopbackTrack(id) {
+      return this._mediaControl.getLoopbackTrack(id);
+    }
+  }, {
+    key: "isCapabilitySupported",
+    value: function isCapabilitySupported(type) {
+      return this._mediaControl.isCapabilitySupported(type);
+    }
+  }, {
+    key: "getWindowList",
+    value: function getWindowList() {
+      return this._mediaControl.getWindowList();
+    }
+  }, {
+    key: "getDisplayList",
+    value: function getDisplayList() {
+      return this._mediaControl.getDisplayList();
+    }
+  }, {
+    key: "cameraTrack",
+    get: function get() {
+      return this._cameraVideoTrack;
+    }
+  }, {
+    key: "microphoneTrack",
+    get: function get() {
+      return this._microphoneAudioTrack;
+    }
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._observable.removeObserver(observer);
+    }
+  }, {
+    key: "startPlayLocalVideo",
+    value: function startPlayLocalVideo(view) {
+      var isMirror = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.currentIsMirror;
+      if (!this._cameraVideoTrack || !view) return;
+      this._localVideoViewSet.add(view);
+      this._cameraVideoTrack.startPreview({
+        renderMode: FcrVideoRenderMode.HIDDEN,
+        isMirror: isMirror
+      }, view);
+      this.currentIsMirror = isMirror;
+    }
+  }, {
+    key: "stopPlayLocalVideo",
+    value: function stopPlayLocalVideo(view) {
+      var _this$_cameraVideoTra2;
+      if (!view) return;
+      this._localVideoViewSet["delete"](view);
+      (_this$_cameraVideoTra2 = this._cameraVideoTrack) === null || _this$_cameraVideoTra2 === void 0 || _this$_cameraVideoTra2.stopPreview(view);
+    }
+  }, {
+    key: "startSpeakerTest",
+    value: function startSpeakerTest() {
+      this.speakerDetecting = true;
+    }
+  }, {
+    key: "stopSpeakerTest",
+    value: function stopSpeakerTest() {
+      this.speakerDetecting = false;
+    }
+  }, {
+    key: "setCurrentIsMirror",
+    value: function setCurrentIsMirror(isMirror) {
+      this.currentIsMirror = isMirror;
+    }
+  }, {
+    key: "toggleLocalMirrorPreview",
+    value: function toggleLocalMirrorPreview(mirror) {
+      var _this2 = this;
+      this.setCurrentIsMirror(mirror);
+      this._localVideoViewSet.forEach(function (view) {
+        var _this2$_cameraVideoTr, _this2$_cameraVideoTr2;
+        (_this2$_cameraVideoTr = _this2._cameraVideoTrack) === null || _this2$_cameraVideoTr === void 0 || _this2$_cameraVideoTr.stopPreview(view);
+        (_this2$_cameraVideoTr2 = _this2._cameraVideoTrack) === null || _this2$_cameraVideoTr2 === void 0 || _this2$_cameraVideoTr2.startPreview({
+          renderMode: FcrVideoRenderMode.HIDDEN,
+          isMirror: mirror
+        }, view);
+      });
+    }
+  }, {
+    key: "setBeautyOptions",
+    value: function setBeautyOptions(beautyOption) {
+      Object.assign(this.beautyOptions, beautyOption);
+      if (!this._cameraVideoTrack) return;
+      this._cameraVideoTrack.getVideoEffectEnhancer().setBeautyOptions({
+        lighteningContrastLevel: convertToFixedNumber(this.beautyOptions.lighteningContrastLevel),
+        lighteningLevel: convertToFixedNumber(this.beautyOptions.lighteningLevel),
+        smoothnessLevel: convertToFixedNumber(this.beautyOptions.smoothnessLevel),
+        sharpnessLevel: convertToFixedNumber(this.beautyOptions.sharpnessLevel),
+        rednessLevel: convertToFixedNumber(this.beautyOptions.rednessLevel)
+      });
+    }
+  }, {
+    key: "handleCancelForceOpenVideoEffect",
+    value: function handleCancelForceOpenVideoEffect() {
+      this.showForceOpenEffectDialog = false;
+    }
+  }, {
+    key: "handleForceOpenVideoEffect",
+    value: function handleForceOpenVideoEffect() {
+      var _this3 = this;
+      var reset = function reset() {
+        _this3.lastEnableVideoEffectType = FcrUIVideoEffectType.NONE;
+        _this3.showForceOpenEffectDialog = false;
+      };
+      if (this.lastEnableVideoEffectType === FcrUIVideoEffectType.BEAUTY) {
+        this._isForceEnableBeauty = true;
+        this.enableBeautyEffect(true);
+        reset();
+        return;
+      }
+      if (this.lastEnableVideoEffectType === FcrUIVideoEffectType.VIRTUAL_BACKGROUND) {
+        this._isForceEnableVirtualBackground = true;
+        this.enableVirtualBackground(true);
+        reset();
+        return;
+      }
+    }
+  }, {
+    key: "setVideoOrientation",
+    value: function setVideoOrientation() {
+      var _this$_cameraVideoTra3;
+      if (this._videoRotation === FcrVideoOrientation.VIDEO_ORIENTATION_270) {
+        this._videoRotation = FcrVideoOrientation.VIDEO_ORIENTATION_0;
+      } else {
+        this._videoRotation = this._videoRotation + 1;
+      }
+      (_this$_cameraVideoTra3 = this._cameraVideoTrack) === null || _this$_cameraVideoTra3 === void 0 || _this$_cameraVideoTra3.setVideoOrientation(this._videoRotation);
+    }
+  }, {
+    key: "setCameraEnabled",
+    value: function setCameraEnabled(enable) {
+      this.cameraEnabled = enable;
+    }
+  }, {
+    key: "_handleCameraEnabledChanged",
+    value: function _handleCameraEnabledChanged() {
+      if (this.cameraEnabled) {
+        this._hasExecutedOpenCamera = true;
+      }
+      this._handleCameraVideoTrack();
+      this.setShowCameraPreview(this.cameraEnabled);
+    }
+  }, {
+    key: "setMicrophoneEnabled",
+    value: function setMicrophoneEnabled(enable) {
+      this._microphoneEnabled = enable;
+    }
+  }, {
+    key: "toggleLocalMirror",
+    value: function toggleLocalMirror(enable) {
+      this._defaultMirror = enable;
+      this.isLocalMirrorEnabled = enable;
+      this.toggleLocalMirrorPreview(enable);
+    }
+  }, {
+    key: "resetMirror",
+    value: function resetMirror() {
+      this.isLocalMirrorEnabled = false;
+      this.setCurrentIsMirror(false);
+    }
+  }, {
+    key: "startMicrophoneTest",
+    value: function startMicrophoneTest() {
+      this.microphoneDetecting = true;
+    }
+  }, {
+    key: "stopMicrophoneTest",
+    value: function stopMicrophoneTest() {
+      this.microphoneDetecting = false;
+    }
+  }, {
+    key: "enableVirtualBackground",
+    value: function enableVirtualBackground(enable, source) {
+      if (!this._cameraVideoTrack) return;
+      if (!enable) {
+        this.virtualBackgroundName = 'None';
+      } else {
+        if (source) {
+          this.virtualBackgroundName = source.name;
+        }
+      }
+      var videoEffectEnhancer = this._cameraVideoTrack.getVideoEffectEnhancer();
+      if (source) {
+        videoEffectEnhancer.setVirtualBackgroundOptions({
+          source: source === null || source === void 0 ? void 0 : source.path,
+          type: source === null || source === void 0 ? void 0 : source.type
+        });
+      }
+      if (!enable) {
+        this._isForceEnableVirtualBackground = false;
+        videoEffectEnhancer.disableVirtualBackground();
+      } else {
+        var isSatisfyVirtualBackgroundRequirements = videoEffectEnhancer.checkSatisfyVirtualBackgroundRequirements() || this._isForceEnableVirtualBackground;
+        if (isSatisfyVirtualBackgroundRequirements) {
+          videoEffectEnhancer.enableVirtualBackground();
+        } else {
+          this.showForceOpenEffectDialog = true;
+          this.lastEnableVideoEffectType = FcrUIVideoEffectType.VIRTUAL_BACKGROUND;
+        }
+      }
+    }
+  }, {
+    key: "setEditBeautyKey",
+    value: function setEditBeautyKey(key) {
+      this.isLocalEditBeautyOptions = key !== 'none';
+      this.beautyKey = key;
+    }
+  }, {
+    key: "enableBeautyEffect",
+    value: function enableBeautyEffect(enable) {
+      if (!this._cameraVideoTrack) return;
+      var videoEffectEnhancer = this._cameraVideoTrack.getVideoEffectEnhancer();
+      if (enable) {
+        var isSatisfyBeautyRequirements = videoEffectEnhancer.checkSatisfyBeautyRequirements() || this._isForceEnableBeauty;
+        1;
+        if (isSatisfyBeautyRequirements) {
+          this.enableBeauty = true;
+          this.setBeautyOptions(this.beautyOptions);
+          videoEffectEnhancer.enableBeauty();
+        } else {
+          this.showForceOpenEffectDialog = true;
+          this.enableBeauty = false;
+          this.lastEnableVideoEffectType = FcrUIVideoEffectType.BEAUTY;
+        }
+      } else {
+        this.enableBeauty = false;
+        this.setEditBeautyKey('none');
+        this._isForceEnableBeauty = false;
+        videoEffectEnhancer.disableBeauty();
+      }
+    }
+
+    // 高保真
+  }, {
+    key: "enableAudioHiFiMode",
+    value: function enableAudioHiFiMode(enable) {
+      if (!this._microphoneAudioTrack) return;
+      if (enable) {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().enableHiFiMode();
+        return;
+      } else {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().disableHiFiMode();
+      }
+    }
+
+    // 回声消除
+  }, {
+    key: "enableAudioEchoCancellation",
+    value: function enableAudioEchoCancellation(enable) {
+      if (!this._microphoneAudioTrack) return;
+      if (enable) {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().enableEchoCancellation();
+      } else {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().disableEchoCancellation();
+      }
+    }
+
+    // 立体声
+  }, {
+    key: "enableAudioStereo",
+    value: function enableAudioStereo(enable) {
+      if (!this._microphoneAudioTrack) return;
+      if (enable) {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().enableStereoMode();
+      } else {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().disableStereoMode();
+      }
+    }
+
+    // 噪音抑制等级
+  }, {
+    key: "setNoiseLevel",
+    value: function setNoiseLevel(level) {
+      if (!this._microphoneAudioTrack) return;
+      if (level === FcrUIAiDenoiseLevel.CLOSE) {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().disableAiDenoiser();
+      } else {
+        this._microphoneAudioTrack.getAudioEffectEnhancer().enableAiDenoiser();
+        this._microphoneAudioTrack.getAudioEffectEnhancer().setAiDenoiseLevel(level);
+      }
+    }
+  }, {
+    key: "setCameraId",
+    value: function setCameraId(cameraId) {
+      this._cameraDevice = {
+        id: cameraId
+      };
+    }
+  }, {
+    key: "setMainRoomAudioOff",
+    value: function setMainRoomAudioOff(enable) {
+      this.isMainRoomAudioOff = enable;
+    }
+  }, {
+    key: "setSpeakerId",
+    value: function setSpeakerId(speakerId) {
+      this._speaker = {
+        id: speakerId
+      };
+    }
+  }, {
+    key: "setMicrophoneId",
+    value: function setMicrophoneId(microphoneId) {
+      this._microphone = {
+        id: microphoneId
+      };
+    }
+  }, {
+    key: "setSpeakerVolume",
+    value: function setSpeakerVolume(value) {
+      this.speakerVolume = value;
+      this._mediaControl.setSelectedSpeakerVolume(value);
+      this._observable.notifyObservers('onSpeakerVolumeChanged', value);
+    }
+  }, {
+    key: "setMicrophoneVolume",
+    value: function setMicrophoneVolume(value) {
+      var _this$_microphoneAudi2;
+      this.microphoneVolume = value;
+      (_this$_microphoneAudi2 = this._microphoneAudioTrack) === null || _this$_microphoneAudi2 === void 0 || _this$_microphoneAudi2.adjustVolume(value);
+    }
+  }, {
+    key: "startOrStopCamera",
+    value: function startOrStopCamera(enable) {
+      this._handleCameraVideoTrack(enable);
+    }
+  }, {
+    key: "setShowCameraPreview",
+    value: function setShowCameraPreview(enable) {
+      this.showCameraPreview = enable;
+    }
+  }, {
+    key: "loadUiResources",
+    value: function () {
+      var _loadUiResources = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(uiResource) {
+        var _this4 = this;
+        var _uiResource$virtualBa, _uiResource$virtualBa2, _uiResource$soundEffe, images, videos, soundEffectAudios, _soundEffectPlayUrlMap, newList, imageInfoList, videoInfoList, _uiResource$virtualBa3, _uiResource$virtualBa4, _uiResource$soundEffe2, _images, _videos, _soundEffectAudios, handleVideoAndImageResourceReady, handleAudioZipResourceReady, handleAudioResourceReady;
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (isElectron()) {
+                _context3.next = 1;
+                break;
+              }
+              images = (uiResource === null || uiResource === void 0 || (_uiResource$virtualBa = uiResource.virtualBackgroundImages) === null || _uiResource$virtualBa === void 0 ? void 0 : _uiResource$virtualBa.filter(function (url) {
+                return isPngOrJpg(url);
+              })) || [];
+              videos = (uiResource === null || uiResource === void 0 || (_uiResource$virtualBa2 = uiResource.virtualBackgroundVideos) === null || _uiResource$virtualBa2 === void 0 ? void 0 : _uiResource$virtualBa2.filter(function (url) {
+                return isMp4(url);
+              })) || [];
+              soundEffectAudios = (_uiResource$soundEffe = uiResource === null || uiResource === void 0 ? void 0 : uiResource.soundEffectAudios) !== null && _uiResource$soundEffe !== void 0 ? _uiResource$soundEffe : {};
+              _soundEffectPlayUrlMap = new Map();
+              Object.keys(soundEffectAudios).forEach(function (key) {
+                var url = soundEffectAudios[key];
+                if (url && isMp3OrWav(url)) {
+                  _soundEffectPlayUrlMap.set(key, url);
+                }
+              });
+              newList = this.virtualBackgroundList.slice();
+              imageInfoList = images.map(function (url) {
+                return {
+                  url: url,
+                  name: getFileNameWithoutExtension(url),
+                  path: url,
+                  type: VirtualOption.IMG
+                };
+              }) || [];
+              newList = newList.concat(imageInfoList);
+              videoInfoList = videos.map(function (url) {
+                return {
+                  url: url,
+                  name: getFileNameWithoutExtension(url),
+                  path: url,
+                  type: VirtualOption.VIDEO
+                };
+              }) || [];
+              newList = newList.concat(videoInfoList);
+              runInAction(function () {
+                _this4._updateVirtualBackgroundList(newList);
+                _this4._soundEffectPlayUrlMap = _soundEffectPlayUrlMap;
+              });
+              _context3.next = 3;
+              break;
+            case 1:
+              _context3.next = 2;
+              return this._loadBuiltinResources();
+            case 2:
+              _images = (uiResource === null || uiResource === void 0 || (_uiResource$virtualBa3 = uiResource.virtualBackgroundImages) === null || _uiResource$virtualBa3 === void 0 ? void 0 : _uiResource$virtualBa3.filter(function (url) {
+                return isZipUrl(url);
+              })) || [];
+              _videos = (uiResource === null || uiResource === void 0 || (_uiResource$virtualBa4 = uiResource.virtualBackgroundVideos) === null || _uiResource$virtualBa4 === void 0 ? void 0 : _uiResource$virtualBa4.filter(function (url) {
+                return isZipUrl(url);
+              })) || [];
+              _soundEffectAudios = (_uiResource$soundEffe2 = uiResource === null || uiResource === void 0 ? void 0 : uiResource.soundEffectAudios) !== null && _uiResource$soundEffe2 !== void 0 ? _uiResource$soundEffe2 : {};
+              handleVideoAndImageResourceReady = function handleVideoAndImageResourceReady(filePathList, type) {
+                var list = _this4.virtualBackgroundList.slice();
+                var resourceType = type === 'image' ? VirtualOption.IMG : VirtualOption.VIDEO;
+                list = filePathList.map(function (resource) {
+                  return {
+                    name: getFileNameWithoutExtension(resource),
+                    path: resource,
+                    type: resourceType,
+                    url: URL.createObjectURL(_this4._renderer.fileToBlob(resource, type))
+                  };
+                });
+                var newList = _this4.virtualBackgroundList.concat(list);
+                _this4._updateVirtualBackgroundList(newList);
+              };
+              handleAudioZipResourceReady = function handleAudioZipResourceReady(effectName) {
+                return function (filePathList) {
+                  if (filePathList.length > 0) {
+                    var firstAudioFilePath = filePathList[0];
+                    runInAction(function () {
+                      _this4._soundEffectFilePathMap.set(effectName, firstAudioFilePath);
+                      _this4._soundEffectPlayUrlMap.set(effectName, URL.createObjectURL(_this4._renderer.fileToBlob(firstAudioFilePath, 'audio')));
+                    });
+                  }
+                };
+              };
+              handleAudioResourceReady = function handleAudioResourceReady(effectName) {
+                return function (filePath) {
+                  runInAction(function () {
+                    _this4._soundEffectFilePathMap.set(effectName, filePath);
+                    _this4._soundEffectPlayUrlMap.set(effectName, URL.createObjectURL(_this4._renderer.fileToBlob(filePath, 'audio')));
+                  });
+                };
+              };
+              this.loadZipResources(_images, 'image', handleVideoAndImageResourceReady);
+              this.loadZipResources(_videos, 'video', handleVideoAndImageResourceReady);
+              Object.keys(_soundEffectAudios).forEach(function (key) {
+                var effectName = key;
+                var url = _soundEffectAudios[effectName];
+                if (url && isZipUrl(url)) {
+                  _this4.loadZipResources([url], 'audio', handleAudioZipResourceReady(effectName))["catch"](function (e) {
+                    _this4.logger.error(e);
+                  });
+                }
+                if (url && isMp3OrWavUrl(url)) {
+                  _this4.loadFileResources(url, 'audio', handleAudioResourceReady(effectName))["catch"](function (e) {
+                    _this4.logger.error(e);
+                  });
+                }
+              });
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function loadUiResources(_x) {
+        return _loadUiResources.apply(this, arguments);
+      }
+      return loadUiResources;
+    }()
+  }, {
+    key: "loadZipResources",
+    value: function () {
+      var _loadZipResources = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(zipUrls, type, callback) {
+        var _this5 = this;
+        var ps;
+        return _regeneratorRuntime.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              ps = zipUrls.map(/*#__PURE__*/function () {
+                var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(url) {
+                  var filePathList;
+                  return _regeneratorRuntime.wrap(function (_context4) {
+                    while (1) switch (_context4.prev = _context4.next) {
+                      case 0:
+                        _context4.next = 1;
+                        return _this5._renderer.downloadAndExtractResourceFileFromZip(url, type);
+                      case 1:
+                        filePathList = _context4.sent;
+                        callback(filePathList, type);
+                      case 2:
+                      case "end":
+                        return _context4.stop();
+                    }
+                  }, _callee4);
+                }));
+                return function (_x5) {
+                  return _ref2.apply(this, arguments);
+                };
+              }());
+              _context5.next = 1;
+              return Promise.allSettled(ps);
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function loadZipResources(_x2, _x3, _x4) {
+        return _loadZipResources.apply(this, arguments);
+      }
+      return loadZipResources;
+    }()
+  }, {
+    key: "loadFileResources",
+    value: function () {
+      var _loadFileResources = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(fileUrl, type, callback) {
+        var filePath;
+        return _regeneratorRuntime.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 1;
+              return this._renderer.downloadResourceFile(fileUrl, type);
+            case 1:
+              filePath = _context6.sent;
+              callback(filePath);
+            case 2:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function loadFileResources(_x6, _x7, _x8) {
+        return _loadFileResources.apply(this, arguments);
+      }
+      return loadFileResources;
+    }()
+  }, {
+    key: "toggleAGC",
+    value: function toggleAGC(enable) {
+      if (!this._microphoneAudioTrack) return;
+      if (enable) {
+        return this._microphoneAudioTrack.getAudioEffectEnhancer().enableAGC();
+      } else {
+        return this._microphoneAudioTrack.getAudioEffectEnhancer().disableAGC();
+      }
+    }
+  }, {
+    key: "setConnectType",
+    value: function setConnectType(connectType) {
+      this.connectType = connectType;
+    }
+  }, {
+    key: "toggleLocalCameraPreview",
+    value: function toggleLocalCameraPreview(enabled) {
+      return this._toggleLocalCameraPreview(enabled);
+    }
+  }, {
+    key: "getLoopbackDeviceId",
+    value: function getLoopbackDeviceId() {
+      if (isElectron()) {
+        var loopbackList = this._mediaControl.getLoopbackList();
+        if (loopbackList.length > 0) {
+          return loopbackList[0].deviceId;
+        }
+        return null;
+      } else {
+        return 'default';
+      }
+    }
+  }, {
+    key: "_initDeviceList",
+    value: function _initDeviceList() {
+      var _this6 = this;
+      // this.toggleAGC(true);
+      Promise.all([this._mediaControl.getCameraList().then(function (list) {
+        if (_this6._released) return;
+        _this6.cameraList = list;
+        _this6.logger.info("[FcrDeviceStore] init camera list: ".concat(jsonstring(list)));
+        if (_this6.cameraList.length > 0) {
+          var defaultCameraDeviceId = _this6.cameraList[0].deviceId;
+          _this6.logger.info('[FcrDeviceStore] select default camera id:', defaultCameraDeviceId);
+          _this6.setCameraId(defaultCameraDeviceId);
+        }
+      }), this._getMicrophoneList().then(/*#__PURE__*/function () {
+        var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(microphoneList) {
+          return _regeneratorRuntime.wrap(function (_context7) {
+            while (1) switch (_context7.prev = _context7.next) {
+              case 0:
+                if (!_this6._released) {
+                  _context7.next = 1;
+                  break;
+                }
+                return _context7.abrupt("return");
+              case 1:
+                _this6.microphoneList = microphoneList;
+                _this6.logger.info("[FcrDeviceStore] init microphone list: ".concat(jsonstring(microphoneList)));
+                if (_this6.microphoneList.length > 0) {
+                  // 默认跟随系统
+                  _this6.setMicrophoneId(DEFAULT_DEVICE_ID);
+                }
+              case 2:
+              case "end":
+                return _context7.stop();
+            }
+          }, _callee7);
+        }));
+        return function (_x9) {
+          return _ref3.apply(this, arguments);
+        };
+      }()), this._getSpeakerList().then(/*#__PURE__*/function () {
+        var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8(speakerList) {
+          return _regeneratorRuntime.wrap(function (_context8) {
+            while (1) switch (_context8.prev = _context8.next) {
+              case 0:
+                if (!_this6._released) {
+                  _context8.next = 1;
+                  break;
+                }
+                return _context8.abrupt("return");
+              case 1:
+                _this6.speakerList = speakerList;
+                _this6.logger.info("[FcrDeviceStore] init speaker list: ".concat(jsonstring(speakerList)));
+                if (_this6.speakerList.length > 0) {
+                  // 默认跟随系统
+                  _this6.setSpeakerId(DEFAULT_DEVICE_ID);
+                }
+              case 2:
+              case "end":
+                return _context8.stop();
+            }
+          }, _callee8);
+        }));
+        return function (_x0) {
+          return _ref4.apply(this, arguments);
+        };
+      }())]);
+    }
+  }, {
+    key: "_handleMicrophoneAudioTrack",
+    value: function _handleMicrophoneAudioTrack() {
+      if (!this._microphoneAudioTrack) {
+        this.logger.warn('microphone audio track is not set');
+        return;
+      }
+      if (this._microphoneEnabled) {
+        this._microphoneAudioTrack.start();
+      } else {
+        this._isMicrophoneWorking = false;
+        this._microphoneAudioTrack.stop();
+        this.microphoneVolumeLevel = 0;
+      }
+    }
+  }, {
+    key: "_handleMicrophoneStateUpdated",
+    value: function _handleMicrophoneStateUpdated(deviceId, state) {
+      this._isMicrophoneWorking = this._microphoneDevice.id === deviceId && state === FcrMediaSourceState.OPEN;
+    }
+  }, {
+    key: "_handleMicrophoneEnabledChanged",
+    value: function _handleMicrophoneEnabledChanged() {
+      this._handleMicrophoneAudioTrack();
+    }
+  }, {
+    key: "_handleCameraVideoTrack",
+    value: function _handleCameraVideoTrack() {
+      var enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.cameraEnabled;
+      var cameraTrack = this._cameraVideoTrack;
+      if (!cameraTrack) {
+        this.logger.warn('camera video track is not set');
+        return;
+      }
+      if (enable) {
+        cameraTrack.start();
+      } else {
+        this._toggleLocalCameraPreview(enable);
+        cameraTrack.stop();
+      }
+    }
+  }, {
+    key: "_handleCameraDeviceIdChanged",
+    value: function _handleCameraDeviceIdChanged() {
+      if (!this._cameraDevice.id) {
+        this.logger.warn('camera id is not set');
+        return;
+      } else {
+        var _this$_cameraVideoTra4, _this$_cameraVideoTra5;
+        (_this$_cameraVideoTra4 = this._cameraVideoTrack) === null || _this$_cameraVideoTra4 === void 0 || _this$_cameraVideoTra4.stopTest();
+        (_this$_cameraVideoTra5 = this._cameraVideoTrack) === null || _this$_cameraVideoTra5 === void 0 || _this$_cameraVideoTra5.stop();
+        this._cameraVideoTrack = this._mediaControl.getCameraTrack(this._cameraDevice.id);
+        this._handleCameraVideoTrack();
+        if (this.showCameraPreview) {
+          this.logger.debug("start camera video track showCameraPreview:".concat(this.showCameraPreview, ",cameraEnabled:").concat(this.cameraEnabled));
+          this._cameraVideoTrack.start();
+        }
+        this._observable.notifyObservers('onCameraChanged', this._cameraDevice.id);
+      }
+      this._toggleLocalCameraPreview(this.showCameraPreview);
+    }
+  }, {
+    key: "_handleSpeakerDetectingChanged",
+    value: function _handleSpeakerDetectingChanged() {
+      var _this7 = this;
+      if (this._microphoneEnabled) {
+        if (this.speakerDetecting) {
+          var _this$_microphoneAudi3;
+          (_this$_microphoneAudi3 = this._microphoneAudioTrack) === null || _this$_microphoneAudi3 === void 0 || _this$_microphoneAudi3.stop();
+        } else {
+          var _this$_microphoneAudi4;
+          (_this$_microphoneAudi4 = this._microphoneAudioTrack) === null || _this$_microphoneAudi4 === void 0 || _this$_microphoneAudi4.start();
+        }
+      }
+      if (this.speakerDetecting) {
+        var startSelectedSpeakerTest = function startSelectedSpeakerTest() {
+          var soundUrl = isElectron() ? _this7._soundEffectFilePathMap.get('speakerTest') : _this7._soundEffectPlayUrlMap.get('speakerTest');
+          if (!soundUrl) {
+            _this7.logger.error('speakerTest soundUrl is not set');
+            return;
+          }
+          _this7._mediaControl.startSelectedSpeakerTest(soundUrl, _this7._volumeIndicationInterval);
+        };
+        startSelectedSpeakerTest();
+        var sleep = 3000;
+        this._playAudioTimer && clearInterval(this._playAudioTimer);
+        this._playAudioTimer = setInterval(function () {
+          startSelectedSpeakerTest();
+        }, sleep);
+      } else {
+        this._stopSelectedSpeakerTest();
+      }
+    }
+  }, {
+    key: "_stopSelectedSpeakerTest",
+    value: function _stopSelectedSpeakerTest() {
+      this._playAudioTimer && clearInterval(this._playAudioTimer);
+      this._mediaControl.stopSelectedSpeakerTest();
+      this.speakerVolumeLevel = 0;
+    }
+  }, {
+    key: "_handleMicrophoneDetectingChanged",
+    value: function _handleMicrophoneDetectingChanged() {
+      if (this.microphoneDetecting) {
+        var _this$_microphoneAudi5;
+        (_this$_microphoneAudi5 = this._microphoneAudioTrack) === null || _this$_microphoneAudi5 === void 0 || _this$_microphoneAudi5.startTest(this._volumeIndicationInterval);
+      } else {
+        this._stopMicrophoneTest();
+      }
+    }
+  }, {
+    key: "_stopMicrophoneTest",
+    value: function _stopMicrophoneTest() {
+      var _this$_microphoneAudi6;
+      (_this$_microphoneAudi6 = this._microphoneAudioTrack) === null || _this$_microphoneAudi6 === void 0 || _this$_microphoneAudi6.stopTest();
+      this.microphoneVolumeLevel = 0;
+    }
+  }, {
+    key: "_handleMicrophoneIdChanged",
+    value: function () {
+      var _handleMicrophoneIdChanged2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+        var _this8 = this;
+        var _this$microphoneList$, _this$microphoneList$2, _this$microphoneList$3, name, productId, vendorId;
+        return _regeneratorRuntime.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              if (!this.followSystemMicrophoneDevice) {
+                name = ((_this$microphoneList$ = this.microphoneList.find(function (item) {
+                  return item.deviceId === _this8._microphone.id;
+                })) === null || _this$microphoneList$ === void 0 ? void 0 : _this$microphoneList$.deviceName) || null;
+                productId = ((_this$microphoneList$2 = this.microphoneList.find(function (item) {
+                  return item.deviceId === _this8._microphone.id;
+                })) === null || _this$microphoneList$2 === void 0 ? void 0 : _this$microphoneList$2.productId) || null;
+                vendorId = ((_this$microphoneList$3 = this.microphoneList.find(function (item) {
+                  return item.deviceId === _this8._microphone.id;
+                })) === null || _this$microphoneList$3 === void 0 ? void 0 : _this$microphoneList$3.vendorId) || null;
+                this._microphoneDevice = {
+                  id: this._microphone.id,
+                  name: name,
+                  productId: productId,
+                  vendorId: vendorId
+                };
+              } else {
+                this._correctSystemSelectedMicrophoneDeviceId();
+              }
+              this._mediaControl.observeSystemSelectedMicrophoneChanged(this.followSystemMicrophoneDevice);
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function _handleMicrophoneIdChanged() {
+        return _handleMicrophoneIdChanged2.apply(this, arguments);
+      }
+      return _handleMicrophoneIdChanged;
+    }()
+  }, {
+    key: "_handleMicrophoneDeviceIdChanged",
+    value: function _handleMicrophoneDeviceIdChanged() {
+      if (!this._microphoneDevice.id) {
+        this.logger.debug('setSelectedMicrophone failed');
+        this._microphone.id = DEFAULT_DEVICE_ID;
+      } else {
+        var _this$_microphoneAudi7, _this$_microphoneAudi8;
+        this._isMicrophoneWorking = false;
+        (_this$_microphoneAudi7 = this._microphoneAudioTrack) === null || _this$_microphoneAudi7 === void 0 || _this$_microphoneAudi7.removeObserver(this._microphoneObserver);
+        (_this$_microphoneAudi8 = this._microphoneAudioTrack) === null || _this$_microphoneAudi8 === void 0 || _this$_microphoneAudi8.stop();
+        this._microphoneAudioTrack = this._mediaControl.getMicrophoneTrack(this._microphoneDevice.id);
+        this._microphoneAudioTrack.addObserver(this._microphoneObserver);
+        this._handleMicrophoneAudioTrack();
+        this._observable.notifyObservers('onMicrophoneChanged', this._microphoneDevice.id, this._microphoneDevice.productId, this._microphoneDevice.vendorId);
+        this.setNoiseLevel(this._sharedSettingDataSource.setting.noiseReduce);
+      }
+    }
+  }, {
+    key: "_handleSpeakerDeviceIdChanged",
+    value: function _handleSpeakerDeviceIdChanged() {
+      if (!this._speakerDevice.id) {
+        this.logger.debug('setSelectedSpeaker failed');
+        this._speaker.id = DEFAULT_DEVICE_ID;
+      } else {
+        this.logger.info("_handleSpeakerDeviceIdChanged  deviceName:".concat(this._speakerDevice.name, ", deviceId: ").concat(this._speakerDevice.id));
+        this._mediaControl.setSelectedSpeaker(this._speakerDevice.id);
+        this._observable.notifyObservers('onSpeakerChanged', this._speakerDevice.id, this._speakerDevice.productId, this._speakerDevice.vendorId);
+      }
+    }
+  }, {
+    key: "_handleSpeakerIdChanged",
+    value: function () {
+      var _handleSpeakerIdChanged2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+        var _this9 = this;
+        var _this$speakerList$fin, _this$speakerList$fin2, _this$speakerList$fin3, name, productId, vendorId;
+        return _regeneratorRuntime.wrap(function (_context0) {
+          while (1) switch (_context0.prev = _context0.next) {
+            case 0:
+              if (!this.followSystemSpeakerDevice) {
+                name = ((_this$speakerList$fin = this.speakerList.find(function (item) {
+                  return item.deviceId === _this9._speaker.id;
+                })) === null || _this$speakerList$fin === void 0 ? void 0 : _this$speakerList$fin.deviceName) || null;
+                productId = ((_this$speakerList$fin2 = this.speakerList.find(function (item) {
+                  return item.deviceId === _this9._speaker.id;
+                })) === null || _this$speakerList$fin2 === void 0 ? void 0 : _this$speakerList$fin2.productId) || null;
+                vendorId = ((_this$speakerList$fin3 = this.speakerList.find(function (item) {
+                  return item.deviceId === _this9._speaker.id;
+                })) === null || _this$speakerList$fin3 === void 0 ? void 0 : _this$speakerList$fin3.vendorId) || null;
+                this._speakerDevice = {
+                  id: this._speaker.id,
+                  name: name,
+                  productId: productId,
+                  vendorId: vendorId
+                };
+              } else {
+                this._correctSystemSpeakerDeviceId();
+              }
+              this._mediaControl.observeSystemSelectedSpeakerChanged(this.followSystemSpeakerDevice);
+            case 1:
+            case "end":
+              return _context0.stop();
+          }
+        }, _callee0, this);
+      }));
+      function _handleSpeakerIdChanged() {
+        return _handleSpeakerIdChanged2.apply(this, arguments);
+      }
+      return _handleSpeakerIdChanged;
+    }()
+  }, {
+    key: "_updateVirtualBackgroundList",
+    value: function _updateVirtualBackgroundList(list) {
+      // 按照 mp4 和 png/jpg 分类, mp4 在前
+      this.virtualBackgroundList = list.sort(function (a, b) {
+        if (a.type === VirtualOption.VIDEO && b.type === VirtualOption.IMG) {
+          return -1;
+        }
+        if (a.type === VirtualOption.IMG && b.type === VirtualOption.VIDEO) {
+          return 1;
+        }
+        return 0;
+      });
+    }
+  }, {
+    key: "_handleSystemSelectedSpeakerChanged",
+    value: function _handleSystemSelectedSpeakerChanged(speaker) {
+      this._correctSystemSpeakerDeviceId();
+    }
+  }, {
+    key: "_correctSystemSpeakerDeviceId",
+    value: function () {
+      var _correctSystemSpeakerDeviceId2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1() {
+        var defaultDevice;
+        return _regeneratorRuntime.wrap(function (_context1) {
+          while (1) switch (_context1.prev = _context1.next) {
+            case 0:
+              _context1.next = 1;
+              return this._mediaControl.getSystemSelectedSpeaker();
+            case 1:
+              defaultDevice = _context1.sent;
+              if (!(defaultDevice === undefined)) {
+                _context1.next = 2;
+                break;
+              }
+              this.logger.error('get system selected speaker device failed');
+              return _context1.abrupt("return");
+            case 2:
+              this.logger.debug("system selected speaker changed : ".concat(defaultDevice.deviceName));
+              this._observable.notifyObservers('onSystemSelectedDeviceChanged', defaultDevice);
+              this._speakerDevice = {
+                id: defaultDevice.deviceId,
+                name: defaultDevice.deviceName,
+                productId: defaultDevice.productId || null,
+                vendorId: defaultDevice.vendorId || null
+              };
+            case 3:
+            case "end":
+              return _context1.stop();
+          }
+        }, _callee1, this);
+      }));
+      function _correctSystemSpeakerDeviceId() {
+        return _correctSystemSpeakerDeviceId2.apply(this, arguments);
+      }
+      return _correctSystemSpeakerDeviceId;
+    }()
+  }, {
+    key: "_handleSystemSelectedMicrophoneChanged",
+    value: function _handleSystemSelectedMicrophoneChanged(microphone) {
+      this._correctSystemSelectedMicrophoneDeviceId();
+    }
+  }, {
+    key: "_correctSystemSelectedMicrophoneDeviceId",
+    value: function () {
+      var _correctSystemSelectedMicrophoneDeviceId2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+        var defaultDevice;
+        return _regeneratorRuntime.wrap(function (_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              _context10.next = 1;
+              return this._mediaControl.getSystemSelectedMicrophone();
+            case 1:
+              defaultDevice = _context10.sent;
+              if (!(defaultDevice === undefined)) {
+                _context10.next = 2;
+                break;
+              }
+              this.logger.error('get system selected speaker device failed');
+              return _context10.abrupt("return");
+            case 2:
+              this._observable.notifyObservers('onSystemSelectedDeviceChanged', defaultDevice);
+              this.logger.debug("system selected microphone changed : ".concat(defaultDevice.deviceName));
+              this._microphoneDevice = {
+                id: defaultDevice.deviceId,
+                name: defaultDevice.deviceName,
+                productId: defaultDevice.productId || null,
+                vendorId: defaultDevice.vendorId || null
+              };
+            case 3:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function _correctSystemSelectedMicrophoneDeviceId() {
+        return _correctSystemSelectedMicrophoneDeviceId2.apply(this, arguments);
+      }
+      return _correctSystemSelectedMicrophoneDeviceId;
+    }()
+  }, {
+    key: "_handleSelectedSpeakerVolumeUpdated",
+    value: function _handleSelectedSpeakerVolumeUpdated(volume) {
+      this.speakerVolume = volume;
+    }
+  }, {
+    key: "_handleSpeakerTestVolumeIndicationUpdated",
+    value: function _handleSpeakerTestVolumeIndicationUpdated(volume) {
+      this.speakerVolumeLevel = getDeviceVolumeLevel(volume);
+    }
+  }, {
+    key: "_handleMicrophoneVolumeIndicationUpdated",
+    value: function _handleMicrophoneVolumeIndicationUpdated(_, volume) {
+      this.microphoneVolumeLevel = getDeviceVolumeLevel(volume);
+    }
+  }, {
+    key: "_toggleLocalCameraPreview",
+    value: function _toggleLocalCameraPreview(enabled) {
+      var _this0 = this;
+      var localVideoViewSet = this._localVideoViewSet;
+      var cameraTrack = this._cameraVideoTrack;
+      if (!cameraTrack) {
+        this.logger.warn('camera video track is not set');
+        return;
+      }
+      if (!enabled) {
+        localVideoViewSet.forEach(function (view) {
+          cameraTrack.stopPreview(view);
+        });
+      }
+      if (enabled) {
+        localVideoViewSet.forEach(function (view) {
+          cameraTrack.startPreview({
+            renderMode: FcrVideoRenderMode.HIDDEN,
+            isMirror: _this0.currentIsMirror
+          }, view);
+        });
+      }
+    }
+  }, {
+    key: "_handleCameraAdded",
+    value: function _handleCameraAdded() {
+      this._handleCameraListUpdated();
+    }
+  }, {
+    key: "_handleCameraRemoved",
+    value: function () {
+      var _handleCameraRemoved2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+        var _this1 = this;
+        var currentDeviceExist, defaultDeviceId;
+        return _regeneratorRuntime.wrap(function (_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.next = 1;
+              return this._handleCameraListUpdated();
+            case 1:
+              currentDeviceExist = this.cameraList.some(function (_ref5) {
+                var deviceId = _ref5.deviceId;
+                return _this1._cameraDevice.id === deviceId;
+              });
+              if (!currentDeviceExist) {
+                this.logger.info('[FcrDeviceStore] current speaker does not exist in speaker list, switch to follow system');
+                defaultDeviceId = this.cameraList.length > 0 ? this.cameraList[0].deviceId : '';
+                this.setCameraId(defaultDeviceId);
+                if (this.cameraEnabled) {
+                  this.setCameraEnabled(false);
+                }
+              }
+            case 2:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function _handleCameraRemoved() {
+        return _handleCameraRemoved2.apply(this, arguments);
+      }
+      return _handleCameraRemoved;
+    }()
+  }, {
+    key: "_handleCameraListUpdated",
+    value: function () {
+      var _handleCameraListUpdated2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+        var cameraList;
+        return _regeneratorRuntime.wrap(function (_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              _context12.next = 1;
+              return this._mediaControl.getCameraList();
+            case 1:
+              cameraList = _context12.sent;
+              this.cameraList = cameraList;
+              this._observable.notifyObservers('onCameraListUpdated', this.cameraList);
+            case 2:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function _handleCameraListUpdated() {
+        return _handleCameraListUpdated2.apply(this, arguments);
+      }
+      return _handleCameraListUpdated;
+    }()
+  }, {
+    key: "_handleMicrophoneAdded",
+    value: function _handleMicrophoneAdded() {
+      this._handleMicrophoneListUpdated();
+    }
+  }, {
+    key: "_handleMicrophoneRemoved",
+    value: function () {
+      var _handleMicrophoneRemoved2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
+        var _this10 = this;
+        var currentDeviceExist;
+        return _regeneratorRuntime.wrap(function (_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              _context13.next = 1;
+              return this._handleMicrophoneListUpdated();
+            case 1:
+              currentDeviceExist = this.microphoneList.find(function (item) {
+                return item.deviceId === _this10._microphoneDevice.id;
+              });
+              if (!currentDeviceExist) {
+                this.logger.info('[FcrDeviceStore] current microphone does not exist in microphone list, switch to follow system');
+                this.setMicrophoneId(DEFAULT_DEVICE_ID);
+              }
+            case 2:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function _handleMicrophoneRemoved() {
+        return _handleMicrophoneRemoved2.apply(this, arguments);
+      }
+      return _handleMicrophoneRemoved;
+    }()
+  }, {
+    key: "_handleMicrophoneListUpdated",
+    value: function () {
+      var _handleMicrophoneListUpdated2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
+        var microphoneList;
+        return _regeneratorRuntime.wrap(function (_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              _context14.next = 1;
+              return this._getMicrophoneList();
+            case 1:
+              microphoneList = _context14.sent;
+              this.microphoneList = microphoneList;
+              this._observable.notifyObservers('onMicrophoneListUpdated', this.microphoneList);
+            case 2:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function _handleMicrophoneListUpdated() {
+        return _handleMicrophoneListUpdated2.apply(this, arguments);
+      }
+      return _handleMicrophoneListUpdated;
+    }()
+  }, {
+    key: "_handleSpeakerAdded",
+    value: function _handleSpeakerAdded() {
+      this._handleSpeakerListUpdated();
+    }
+  }, {
+    key: "_handleSpeakerRemoved",
+    value: function () {
+      var _handleSpeakerRemoved2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
+        var _this11 = this;
+        var currentDeviceExist;
+        return _regeneratorRuntime.wrap(function (_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              _context15.next = 1;
+              return this._handleSpeakerListUpdated();
+            case 1:
+              // 如何设备移除了，应该切到跟随系统
+              currentDeviceExist = this.speakerList.find(function (item) {
+                return item.deviceId === _this11._speakerDevice.id;
+              });
+              if (!currentDeviceExist) {
+                this.logger.info('[FcrDeviceStore] current speaker does not exist in speaker list, switch to follow system');
+                this.setSpeakerId(DEFAULT_DEVICE_ID);
+              }
+            case 2:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function _handleSpeakerRemoved() {
+        return _handleSpeakerRemoved2.apply(this, arguments);
+      }
+      return _handleSpeakerRemoved;
+    }()
+  }, {
+    key: "_handleSpeakerListUpdated",
+    value: function () {
+      var _handleSpeakerListUpdated2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
+        var speakerList;
+        return _regeneratorRuntime.wrap(function (_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              _context16.next = 1;
+              return this._getSpeakerList();
+            case 1:
+              speakerList = _context16.sent;
+              this.speakerList = speakerList;
+              this._observable.notifyObservers('onSpeakerListUpdated', this.speakerList);
+            case 2:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function _handleSpeakerListUpdated() {
+        return _handleSpeakerListUpdated2.apply(this, arguments);
+      }
+      return _handleSpeakerListUpdated;
+    }()
+  }, {
+    key: "_getMicrophoneList",
+    value: function () {
+      var _getMicrophoneList2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
+        var systemSelectedMicrophone, deviceList, formatDeviceList;
+        return _regeneratorRuntime.wrap(function (_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              _context17.next = 1;
+              return this._mediaControl.getSystemSelectedMicrophone();
+            case 1:
+              systemSelectedMicrophone = _context17.sent;
+              _context17.next = 2;
+              return this._mediaControl.getMicrophoneList();
+            case 2:
+              deviceList = _context17.sent;
+              formatDeviceList = this._formatDeviceList(deviceList, systemSelectedMicrophone);
+              return _context17.abrupt("return", formatDeviceList);
+            case 3:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this);
+      }));
+      function _getMicrophoneList() {
+        return _getMicrophoneList2.apply(this, arguments);
+      }
+      return _getMicrophoneList;
+    }()
+  }, {
+    key: "_getSpeakerList",
+    value: function () {
+      var _getSpeakerList2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+        var systemSelectedSpeaker, deviceList, formatDeviceList;
+        return _regeneratorRuntime.wrap(function (_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              _context18.next = 1;
+              return this._mediaControl.getSystemSelectedSpeaker();
+            case 1:
+              systemSelectedSpeaker = _context18.sent;
+              _context18.next = 2;
+              return this._mediaControl.getSpeakerList();
+            case 2:
+              deviceList = _context18.sent;
+              formatDeviceList = this._formatDeviceList(deviceList, systemSelectedSpeaker);
+              return _context18.abrupt("return", formatDeviceList);
+            case 3:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function _getSpeakerList() {
+        return _getSpeakerList2.apply(this, arguments);
+      }
+      return _getSpeakerList;
+    }()
+  }, {
+    key: "_formatDeviceList",
+    value: function _formatDeviceList(deviceList, systemSelectedDevice) {
+      var defaultDeviceName = transI18n('fmt_device_label_speaker_follow_system', {
+        reason1: transI18n('fmt_device_label_speaker_default')
+      });
+      var formatDeviceList = deviceList.reduce(function (deviceList, deviceInfo) {
+        deviceInfo = clone(deviceInfo);
+        var results = /^default \((.*)\)$/.exec(deviceInfo.deviceName);
+        if (results && results.length > 1) {
+          deviceInfo.deviceName = results[1];
+        }
+        var isNotVirtualSoundCard = !matchVirtualSoundCardPattern(deviceInfo.deviceName);
+        if (isNotVirtualSoundCard) {
+          if (deviceInfo.deviceId === DEFAULT_DEVICE_ID) {
+            deviceInfo.deviceName = defaultDeviceName;
+          }
+          deviceList.push(deviceInfo);
+        }
+        return deviceList;
+      }, []);
+      var defaultIdDevice = formatDeviceList.find(function (item) {
+        return item.deviceId === DEFAULT_DEVICE_ID;
+      });
+
+      // 设备列表中没有默认设备，但是系统默认设备存在
+      if (!defaultIdDevice && systemSelectedDevice !== null && systemSelectedDevice !== void 0 && systemSelectedDevice.deviceName) {
+        formatDeviceList.unshift({
+          deviceId: DEFAULT_DEVICE_ID,
+          deviceName: defaultDeviceName
+        });
+      } else {
+        formatDeviceList.sort(function (a, b) {
+          if (a.deviceId === DEFAULT_DEVICE_ID) return -1;
+          if (b.deviceId === DEFAULT_DEVICE_ID) return 1;
+          return 0;
+        });
+      }
+      return formatDeviceList;
+    }
+  }, {
+    key: "_loadBuiltinResources",
+    value: function () {
+      var _loadBuiltinResources2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
+        var _this12 = this;
+        var _yield$this$_renderer, _yield$this$_renderer2, virtualBackgroundImages, _yield$this$_renderer3, virtualBackgroundVideos, _yield$this$_renderer4, soundEffectAudios, newVirtualBackgroundList, images, videos, soundEffectPlayUrlMap, soundEffectFilePathMap;
+        return _regeneratorRuntime.wrap(function (_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              _context19.next = 1;
+              return this._renderer.loadBuiltinResources();
+            case 1:
+              _yield$this$_renderer = _context19.sent;
+              _yield$this$_renderer2 = _yield$this$_renderer.virtualBackgroundImages;
+              virtualBackgroundImages = _yield$this$_renderer2 === void 0 ? [] : _yield$this$_renderer2;
+              _yield$this$_renderer3 = _yield$this$_renderer.virtualBackgroundVideos;
+              virtualBackgroundVideos = _yield$this$_renderer3 === void 0 ? [] : _yield$this$_renderer3;
+              _yield$this$_renderer4 = _yield$this$_renderer.soundEffectAudios;
+              soundEffectAudios = _yield$this$_renderer4 === void 0 ? {} : _yield$this$_renderer4;
+              newVirtualBackgroundList = this.virtualBackgroundList.slice();
+              images = virtualBackgroundImages.map(function (item) {
+                return {
+                  name: getFileNameWithoutExtension(item),
+                  path: item,
+                  type: VirtualOption.IMG,
+                  url: URL.createObjectURL(_this12._renderer.fileToBlob(item, 'image'))
+                };
+              });
+              videos = virtualBackgroundVideos.map(function (item) {
+                return {
+                  name: getFileNameWithoutExtension(item),
+                  path: item,
+                  type: VirtualOption.VIDEO,
+                  url: URL.createObjectURL(_this12._renderer.fileToBlob(item, 'video'))
+                };
+              });
+              soundEffectPlayUrlMap = new Map();
+              soundEffectFilePathMap = new Map();
+              Object.keys(soundEffectAudios).forEach(function (key) {
+                var effectName = key;
+                var filePath = soundEffectAudios[effectName];
+                soundEffectPlayUrlMap.set(effectName, URL.createObjectURL(_this12._renderer.fileToBlob(filePath, 'audio')));
+                soundEffectFilePathMap.set(effectName, filePath);
+              });
+              this.logger.info('load builtin image ui resources:', jsonstring(images));
+              this.logger.info('load builtin video ui resources:', jsonstring(videos));
+              this.logger.info('load builtin sound ui resources:', jsonstring(soundEffectPlayUrlMap));
+              newVirtualBackgroundList = newVirtualBackgroundList.concat(images);
+              newVirtualBackgroundList = newVirtualBackgroundList.concat(videos);
+              runInAction(function () {
+                _this12._updateVirtualBackgroundList(newVirtualBackgroundList);
+                _this12._soundEffectFilePathMap = soundEffectFilePathMap;
+                _this12._soundEffectPlayUrlMap = soundEffectPlayUrlMap;
+              });
+            case 2:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this);
+      }));
+      function _loadBuiltinResources() {
+        return _loadBuiltinResources2.apply(this, arguments);
+      }
+      return _loadBuiltinResources;
+    }()
+  }]);
+}();
+_FcrUIDeviceProviderImpl = FcrUIDeviceProviderImpl;
+var _applyDecs$e = _applyDecs(_FcrUIDeviceProviderImpl, [[observable, 1, "_microphoneEnabled"], [observable, 1, "_isMicrophoneWorking"], [observable, 1, "_microphoneDevice"], [observable, 1, "_microphone"], [observable, 1, "_speakerDevice"], [observable, 1, "_speaker"], [observable, 1, "_cameraDevice"], [observable, 1, "currentIsMirror"], [observable, 1, "showForceOpenEffectDialog"], [observable, 1, "cameraEnabled"], [observable, 1, "showCameraPreview"], [observable, 1, "cameraList"], [observable, 1, "microphoneList"], [observable, 1, "microphoneVolumeLevel"], [observable, 1, "speakerList"], [observable, 1, "isLocalMirrorEnabled"], [observable, 1, "isLocalEditBeautyOptions"], [observable, 1, "speakerVolumeLevel"], [observable, 1, "speakerVolume"], [observable, 1, "microphoneVolume"], [observable, 1, "virtualBackgroundName"], [observable, 1, "enableBeauty"], [observable, 1, "beautyKey"], [observable, 1, "beautyOptions"], [observable, 1, "virtualBackgroundList"], [observable, 1, "microphoneDetecting"], [observable, 1, "speakerDetecting"], [observable, 1, "connectType"], [observable, 1, "isMainRoomAudioOff"], [bound, 2, "connectAudio"], [bound, 2, "disconnectAudio"], [computed, 3, "microphoneEnabled"], [computed, 3, "microphoneState"], [_startPlayLocalVideoDecs, 18, "startPlayLocalVideo"], [_stopPlayLocalVideoDecs, 18, "stopPlayLocalVideo"], [_startSpeakerTestDecs, 18, "startSpeakerTest"], [_stopSpeakerTestDecs, 18, "stopSpeakerTest"], [_setCurrentIsMirrorDecs, 18, "setCurrentIsMirror"], [_toggleLocalMirrorPreviewDecs, 18, "toggleLocalMirrorPreview"], [_setBeautyOptionsDecs, 18, "setBeautyOptions"], [_handleCancelForceOpenVideoEffectDecs, 18, "handleCancelForceOpenVideoEffect"], [_handleForceOpenVideoEffectDecs, 18, "handleForceOpenVideoEffect"], [bound, 2, "setVideoOrientation"], [_setCameraEnabledDecs, 18, "setCameraEnabled"], [_handleCameraEnabledChangedDecs, 18, "_handleCameraEnabledChanged"], [_setMicrophoneEnabledDecs, 18, "setMicrophoneEnabled"], [_toggleLocalMirrorDecs, 18, "toggleLocalMirror"], [_resetMirrorDecs, 18, "resetMirror"], [_startMicrophoneTestDecs, 18, "startMicrophoneTest"], [_stopMicrophoneTestDecs, 18, "stopMicrophoneTest"], [_enableVirtualBackgroundDecs, 18, "enableVirtualBackground"], [_setEditBeautyKeyDecs, 18, "setEditBeautyKey"], [_enableBeautyEffectDecs, 18, "enableBeautyEffect"], [_setCameraIdDecs, 18, "setCameraId"], [_setMainRoomAudioOffDecs, 18, "setMainRoomAudioOff"], [_setSpeakerIdDecs, 18, "setSpeakerId"], [_setMicrophoneIdDecs, 18, "setMicrophoneId"], [_setSpeakerVolumeDecs, 18, "setSpeakerVolume"], [_setMicrophoneVolumeDecs, 18, "setMicrophoneVolume"], [_startOrStopCameraDecs, 18, "startOrStopCamera"], [_setShowCameraPreviewDecs, 18, "setShowCameraPreview"], [_loadUiResourcesDecs, 18, "loadUiResources"], [bound, 2, "loadZipResources"], [bound, 2, "loadFileResources"], [bound, 2, "toggleAGC"], [_setConnectTypeDecs, 18, "setConnectType"], [_toggleLocalCameraPreviewDecs, 18, "toggleLocalCameraPreview"], [_getLoopbackDeviceIdDecs, 18, "getLoopbackDeviceId"], [_initDeviceListDecs, 18, "_initDeviceList"], [_handleMicrophoneAudioTrackDecs, 18, "_handleMicrophoneAudioTrack"], [_handleMicrophoneStateUpdatedDecs, 18, "_handleMicrophoneStateUpdated"], [_handleMicrophoneEnabledChangedDecs, 18, "_handleMicrophoneEnabledChanged"], [_handleCameraVideoTrackDecs, 18, "_handleCameraVideoTrack"], [bound, 2, "_handleCameraDeviceIdChanged"], [_handleSpeakerDetectingChangedDecs, 18, "_handleSpeakerDetectingChanged"], [_stopSelectedSpeakerTestDecs, 18, "_stopSelectedSpeakerTest"], [_handleMicrophoneDetectingChangedDecs, 18, "_handleMicrophoneDetectingChanged"], [_stopMicrophoneTestDecs2, 18, "_stopMicrophoneTest"], [bound, 2, "_handleMicrophoneIdChanged"], [bound, 2, "_handleMicrophoneDeviceIdChanged"], [bound, 2, "_handleSpeakerDeviceIdChanged"], [bound, 2, "_handleSpeakerIdChanged"], [_updateVirtualBackgroundListDecs, 18, "_updateVirtualBackgroundList"], [_handleSystemSelectedSpeakerChangedDecs, 18, "_handleSystemSelectedSpeakerChanged"], [_handleSystemSelectedMicrophoneChangedDecs, 18, "_handleSystemSelectedMicrophoneChanged"], [_correctSystemSelectedMicrophoneDeviceIdDecs, 18, "_correctSystemSelectedMicrophoneDeviceId"], [_handleSelectedSpeakerVolumeUpdatedDecs, 18, "_handleSelectedSpeakerVolumeUpdated"], [_handleSpeakerTestVolumeIndicationUpdatedDecs, 18, "_handleSpeakerTestVolumeIndicationUpdated"], [_handleMicrophoneVolumeIndicationUpdatedDecs, 18, "_handleMicrophoneVolumeIndicationUpdated"], [bound, 2, "_toggleLocalCameraPreview"], [bound, 2, "_handleCameraAdded"], [bound, 2, "_handleCameraRemoved"], [bound, 2, "_handleCameraListUpdated"], [bound, 2, "_handleMicrophoneAdded"], [bound, 2, "_handleMicrophoneRemoved"], [bound, 2, "_handleMicrophoneListUpdated"], [_handleSpeakerAddedDecs, 18, "_handleSpeakerAdded"], [_handleSpeakerRemovedDecs, 18, "_handleSpeakerRemoved"], [_handleSpeakerListUpdatedDecs, 18, "_handleSpeakerListUpdated"], [_getMicrophoneListDecs, 18, "_getMicrophoneList"], [_getSpeakerListDecs, 18, "_getSpeakerList"], [_formatDeviceListDecs, 18, "_formatDeviceList"], [_loadBuiltinResourcesDecs, 18, "_loadBuiltinResources"]], []).e;
+var _applyDecs$e2 = _slicedToArray(_applyDecs$e, 30);
+_init__microphoneEnabled = _applyDecs$e2[0];
+_init__isMicrophoneWorking = _applyDecs$e2[1];
+_init__microphoneDevice = _applyDecs$e2[2];
+_init__microphone = _applyDecs$e2[3];
+_init__speakerDevice = _applyDecs$e2[4];
+_init__speaker = _applyDecs$e2[5];
+_init__cameraDevice = _applyDecs$e2[6];
+_init_currentIsMirror = _applyDecs$e2[7];
+_init_showForceOpenEffectDialog = _applyDecs$e2[8];
+_init_cameraEnabled = _applyDecs$e2[9];
+_init_showCameraPreview = _applyDecs$e2[10];
+_init_cameraList = _applyDecs$e2[11];
+_init_microphoneList = _applyDecs$e2[12];
+_init_microphoneVolumeLevel = _applyDecs$e2[13];
+_init_speakerList = _applyDecs$e2[14];
+_init_isLocalMirrorEnabled = _applyDecs$e2[15];
+_init_isLocalEditBeautyOptions = _applyDecs$e2[16];
+_init_speakerVolumeLevel = _applyDecs$e2[17];
+_init_speakerVolume = _applyDecs$e2[18];
+_init_microphoneVolume = _applyDecs$e2[19];
+_init_virtualBackgroundName = _applyDecs$e2[20];
+_init_enableBeauty = _applyDecs$e2[21];
+_init_beautyKey = _applyDecs$e2[22];
+_init_beautyOptions = _applyDecs$e2[23];
+_init_virtualBackgroundList = _applyDecs$e2[24];
+_init_microphoneDetecting = _applyDecs$e2[25];
+_init_speakerDetecting = _applyDecs$e2[26];
+_init_connectType = _applyDecs$e2[27];
+_init_isMainRoomAudioOff = _applyDecs$e2[28];
+_initProto = _applyDecs$e2[29];
+_applyDecs$e;