fcr-ui-scene 3.7.4 → 3.7.6

package/lib/providers/screen-share/stream-state-sync.js

@@ -0,0 +1,217 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIScreenStreamSync = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.timers.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _type = require("fcr-core/lib/type");
+var _objectManager = require("../../object-manager");
+var _logger = require("../../utilities/logger");
+var FcrUIScreenStreamSync = exports.FcrUIScreenStreamSync = /*#__PURE__*/function () {
+  function FcrUIScreenStreamSync(objectManager) {
+    var _this = this;
+    (0, _classCallCheck2["default"])(this, FcrUIScreenStreamSync);
+    (0, _defineProperty2["default"])(this, "logger", (0, _logger.createLogger)({
+      prefix: 'FcrUIScreenStreamSync'
+    }));
+    // 我的屏幕共享流id
+    (0, _defineProperty2["default"])(this, "_myCurrentScreenShareStreamId", null);
+    (0, _defineProperty2["default"])(this, "_released", false);
+    var sharedConfigDataSource = objectManager.getObject(_objectManager.FcrUIObjectKeys.S_SHARED_CONFIG_DATA_SOURCE);
+    var roomProvider = objectManager.getObject(_objectManager.FcrUIObjectKeys.P_ROOM_PROVIDER);
+    var userId = sharedConfigDataSource.creatorConfig.userId;
+    this._sharingControl = roomProvider.currentRoomControl.getSharingControl();
+    this._streamControl = roomProvider.currentRoomControl.getStreamControl();
+    this._sharingControl.addObserver({
+      onScreenSharingUpdated: function onScreenSharingUpdated(streamInfo, state) {
+        if (state === _type.FcrScreenSharingState.END) {
+          if ((streamInfo === null || streamInfo === void 0 ? void 0 : streamInfo.owner.userId) === userId) {
+            _this._myCurrentScreenShareStreamId = null;
+          }
+        } else {
+          // get screen stream
+          // check if it's my screen stream
+          // set my current screen share stream id
+          if ((streamInfo === null || streamInfo === void 0 ? void 0 : streamInfo.owner.userId) === userId) {
+            _this._myCurrentScreenShareStreamId = streamInfo.streamId;
+          }
+        }
+      }
+    });
+  }
+  return (0, _createClass2["default"])(FcrUIScreenStreamSync, [{
+    key: "release",
+    value: function release() {
+      this._released = true;
+    }
+  }, {
+    key: "checkIfMyScreenShareStreamExists",
+    value: function checkIfMyScreenShareStreamExists() {
+      return this._myCurrentScreenShareStreamId;
+    }
+  }, {
+    key: "startScreenStream",
+    value: function () {
+      var _startScreenStream = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(createConfig, encoderConfig) {
+        var streamId, screenStreamId, _t;
+        return _regenerator["default"].wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              streamId = this._myCurrentScreenShareStreamId;
+              if (!streamId) {
+                _context.next = 1;
+                break;
+              }
+              throw new Error("there's already a screen share stream owned by me");
+            case 1:
+              _context.prev = 1;
+              _context.next = 2;
+              return this._sharingControl.startScreenSharing(createConfig, encoderConfig.dimensions);
+            case 2:
+              screenStreamId = _context.sent;
+              this._streamControl.setVideoEncoderConfig(screenStreamId, encoderConfig, _type.FcrVideoStreamType.HIGH_STREAM);
+              _context.next = 4;
+              break;
+            case 3:
+              _context.prev = 3;
+              _t = _context["catch"](1);
+              throw new Error("failed to start screen share stream, error: ".concat(_t));
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[1, 3]]);
+      }));
+      function startScreenStream(_x, _x2) {
+        return _startScreenStream.apply(this, arguments);
+      }
+      return startScreenStream;
+    }()
+  }, {
+    key: "stopScreenStream",
+    value: function () {
+      var _stopScreenStream = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        var _t2;
+        return _regenerator["default"].wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (this._myCurrentScreenShareStreamId) {
+                _context2.next = 1;
+                break;
+              }
+              this.logger.warn('no screen share stream owned by me, cannot stop screen share stream');
+              return _context2.abrupt("return");
+            case 1:
+              if (!true) {
+                _context2.next = 8;
+                break;
+              }
+              if (!this._released) {
+                _context2.next = 2;
+                break;
+              }
+              return _context2.abrupt("return");
+            case 2:
+              _context2.prev = 2;
+              _context2.next = 3;
+              return this._sharingControl.stop();
+            case 3:
+              return _context2.abrupt("continue", 8);
+            case 4:
+              _context2.prev = 4;
+              _t2 = _context2["catch"](2);
+              this.logger.error("failed to stop screen share stream, error: ".concat(_t2, ", retry in 1000ms"), _t2);
+              _context2.next = 5;
+              return new Promise(function (resolve) {
+                return setTimeout(resolve, 1000);
+              });
+            case 5:
+              _context2.prev = 5;
+              if (this._myCurrentScreenShareStreamId) {
+                _context2.next = 6;
+                break;
+              }
+              return _context2.abrupt("continue", 8);
+            case 6:
+              return _context2.finish(5);
+            case 7:
+              _context2.next = 1;
+              break;
+            case 8:
+              this._myCurrentScreenShareStreamId = null;
+            case 9:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[2, 4, 5, 7]]);
+      }));
+      function stopScreenStream() {
+        return _stopScreenStream.apply(this, arguments);
+      }
+      return stopScreenStream;
+    }()
+  }, {
+    key: "updateStream",
+    value: function () {
+      var _updateStream = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref) {
+        var videoSourceId, audioPublishPrivilege, videoPublishPrivilege, privilege;
+        return _regenerator["default"].wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              videoSourceId = _ref.videoSourceId, audioPublishPrivilege = _ref.audioPublishPrivilege, videoPublishPrivilege = _ref.videoPublishPrivilege;
+              if (this._myCurrentScreenShareStreamId) {
+                _context3.next = 1;
+                break;
+              }
+              throw new Error('no screen share stream owned by me, cannot update stream');
+            case 1:
+              if (!videoSourceId) {
+                _context3.next = 2;
+                break;
+              }
+              _context3.next = 2;
+              return this._streamControl.bindLocalStreams([{
+                streamId: this._myCurrentScreenShareStreamId,
+                videoSourceId: videoSourceId
+              }]);
+            case 2:
+              privilege = {
+                audioPrivilege: audioPublishPrivilege || _type.FcrStreamPrivilegeOperation.NOOPERATION,
+                videoPrivilege: videoPublishPrivilege || _type.FcrStreamPrivilegeOperation.NOOPERATION
+              };
+              if (!(audioPublishPrivilege !== _type.FcrStreamPrivilegeOperation.NOOPERATION || videoPublishPrivilege !== _type.FcrStreamPrivilegeOperation.NOOPERATION)) {
+                _context3.next = 3;
+                break;
+              }
+              _context3.next = 3;
+              return this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, this._myCurrentScreenShareStreamId, privilege));
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function updateStream(_x3) {
+        return _updateStream.apply(this, arguments);
+      }
+      return updateStream;
+    }()
+  }, {
+    key: "isLocalScreenStreamCreated",
+    value: function isLocalScreenStreamCreated() {
+      return this._myCurrentScreenShareStreamId !== null;
+    }
+  }]);
+}();

package/lib/providers/screen-share/struct.d.ts

@@ -0,0 +1,46 @@
+export declare enum FcrUIScreenShareErrorCode {
+    /**
+     * 当前已经在共享了，不能开启共享
+     */
+    CONFLICT = 1,
+    /**
+     * 无法创建视频流
+     */
+    CANNOT_CREATE_STREAM = 2,
+    /**
+     * 无法更新视频流
+     */
+    CANNOT_UPDATE_STREAM = 3,
+    /**
+     * 无法开始屏幕采集
+     */
+    CANNOT_START_SCREEN_CAPTURE = 4,
+    /**
+     * 无发流权限
+     */
+    NO_PUBLISH_PRIVILIGE = 5,
+    /**
+     * 无屏幕采集权限
+     */
+    NO_SCREEN_RECORDING_PERMISSION = 6,
+    /**
+     * 网络未连接
+     */
+    NETWORK_DISCONNECTED = 7
+}
+export declare enum FcrUIAudioShareErrorCode {
+    /**
+     * 无法更新音频流
+     */
+    CANNOT_UPDATE_STREAM = 0
+}
+export declare enum FcrUIScreenShareStopReason {
+    /**
+     * 正常停止
+     */
+    NORMAL_STOP = 1,
+    /**
+     * 被其他用户停止
+     */
+    STOPPED_BY_OTHER = 3
+}

package/lib/providers/screen-share/struct.js

@@ -0,0 +1,56 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIScreenShareStopReason = exports.FcrUIScreenShareErrorCode = exports.FcrUIAudioShareErrorCode = void 0;
+var FcrUIScreenShareErrorCode = exports.FcrUIScreenShareErrorCode = /*#__PURE__*/function (FcrUIScreenShareErrorCode) {
+  /**
+   * 当前已经在共享了，不能开启共享
+   */
+  FcrUIScreenShareErrorCode[FcrUIScreenShareErrorCode["CONFLICT"] = 1] = "CONFLICT";
+  /**
+   * 无法创建视频流
+   */
+  FcrUIScreenShareErrorCode[FcrUIScreenShareErrorCode["CANNOT_CREATE_STREAM"] = 2] = "CANNOT_CREATE_STREAM";
+  /**
+   * 无法更新视频流
+   */
+  FcrUIScreenShareErrorCode[FcrUIScreenShareErrorCode["CANNOT_UPDATE_STREAM"] = 3] = "CANNOT_UPDATE_STREAM";
+  /**
+   * 无法开始屏幕采集
+   */
+  FcrUIScreenShareErrorCode[FcrUIScreenShareErrorCode["CANNOT_START_SCREEN_CAPTURE"] = 4] = "CANNOT_START_SCREEN_CAPTURE";
+  /**
+   * 无发流权限
+   */
+  FcrUIScreenShareErrorCode[FcrUIScreenShareErrorCode["NO_PUBLISH_PRIVILIGE"] = 5] = "NO_PUBLISH_PRIVILIGE";
+  /**
+   * 无屏幕采集权限
+   */
+  FcrUIScreenShareErrorCode[FcrUIScreenShareErrorCode["NO_SCREEN_RECORDING_PERMISSION"] = 6] = "NO_SCREEN_RECORDING_PERMISSION";
+  /**
+   * 网络未连接
+   */
+  FcrUIScreenShareErrorCode[FcrUIScreenShareErrorCode["NETWORK_DISCONNECTED"] = 7] = "NETWORK_DISCONNECTED";
+  return FcrUIScreenShareErrorCode;
+}({});
+var FcrUIAudioShareErrorCode = exports.FcrUIAudioShareErrorCode = /*#__PURE__*/function (FcrUIAudioShareErrorCode) {
+  /**
+   * 无法更新音频流
+   */
+  FcrUIAudioShareErrorCode[FcrUIAudioShareErrorCode["CANNOT_UPDATE_STREAM"] = 0] = "CANNOT_UPDATE_STREAM";
+  return FcrUIAudioShareErrorCode;
+}({});
+var FcrUIScreenShareStopReason = exports.FcrUIScreenShareStopReason = /*#__PURE__*/function (FcrUIScreenShareStopReason) {
+  /**
+   * 正常停止
+   */
+  FcrUIScreenShareStopReason[FcrUIScreenShareStopReason["NORMAL_STOP"] = 1] = "NORMAL_STOP";
+  /**
+   * 被其他用户停止
+   */
+  FcrUIScreenShareStopReason[FcrUIScreenShareStopReason["STOPPED_BY_OTHER"] = 3] = "STOPPED_BY_OTHER";
+  return FcrUIScreenShareStopReason;
+}({});

package/lib/providers/screen-share/type.d.ts

@@ -0,0 +1,170 @@
+import { FcrStreamPrivilegeOperation } from 'fcr-core';
+import { FcrScreenCaptureType, FcrUserInfo } from 'fcr-core/lib/type';
+import { FcrUIAudioShareErrorCode, FcrUIScreenShareErrorCode, FcrUIScreenShareStopReason } from './struct';
+import { FcrScreenTrack } from 'fcr-core/lib/media-control/type';
+export interface FcrUIScreenShareWindowInfo {
+    id: string;
+    title: string;
+    image: Uint8Array;
+    imageWidth: number;
+    imageHeight: number;
+    bounds: FcrUI.FcrUIRectangle;
+}
+export interface FcrUIScreenShareDisplayInfo {
+    id: string;
+    title: string;
+    image: Uint8Array;
+    imageWidth: number;
+    imageHeight: number;
+    bounds: FcrUI.FcrUIRectangle;
+}
+export interface FcrUIScreenShareStartParams {
+    videoSourceId: string;
+    captureType: FcrScreenCaptureType;
+    excludeWindows?: string[];
+}
+export interface FcrUIScreenShareReplaceParams extends FcrUIScreenShareStartParams {
+}
+export interface FcrUIScreenStreamUpdateParams {
+    videoSourceId?: string;
+    videoPublishPrivilege?: FcrStreamPrivilegeOperation;
+    audioPublishPrivilege?: FcrStreamPrivilegeOperation;
+}
+export interface FcrUIScreenShareObserver {
+    /**
+     * 屏幕共享准备开始
+     */
+    onPrepreScreenCapture?(): void;
+    /**
+     * 屏幕共享开始
+     * @returns
+     */
+    onScreenShareStarted?: (screenTrack: FcrScreenTrack) => void;
+    /**
+     * 屏幕共享停止
+     * @returns
+     */
+    onScreenShareStopped?: (reason: FcrUIScreenShareStopReason, operator: FcrUserInfo) => void;
+    /**
+     * 屏幕共享源被替换
+     * @returns
+     */
+    onShareSourceReplaced?: (screenTrack: FcrScreenTrack) => void;
+    /**
+     * 屏幕共享错误发生
+     * @param error
+     * @returns
+     */
+    onScreenShareErrorOccurred?: (code: FcrUIScreenShareErrorCode) => void;
+    /**
+     * 音频共享错误发生
+     * @param code
+     * @returns
+     */
+    onAudioShareErrorOccurred?: (code: FcrUIAudioShareErrorCode) => void;
+}
+export interface FcrUIScreenShareProvider {
+    /**
+     * 获取当前选中的共享区域边界信息，
+     * 共享屏幕时为屏幕边界的信息
+     * 共享窗口时为窗口边界的信息
+     * @returns 当前选中的共享区域的位置和尺寸信息
+     */
+    get selectionBounds(): FcrUI.FcrUIRectangle;
+    /**
+     * 当前共享源所在的窗口边界信息
+     * 例如：
+     * 共享某个显示器时，返回该显示器的边界信息
+     * 共享某个应用窗口时，返回该应用窗所在屏幕的边界信息
+     * @returns 屏幕边界信息
+     */
+    get sharingDisplayBounds(): FcrUI.FcrUIRectangle;
+    /**
+     * 是否正在共享音频
+     */
+    get isSharingWithAudio(): boolean;
+    /**
+     * 是否正在以流畅模式进行屏幕共享
+     */
+    get isSharingInSmoothMode(): boolean;
+    /**
+     * 是否正在以立体声模式共享音频
+     */
+    get isSharingInStereoAudioMode(): boolean;
+    /**
+     * 当前屏幕共享的用户信息
+     */
+    get sharingUser(): FcrUserInfo;
+    /**
+     * 获取当前屏幕共享流的唯一标识符
+     * @returns 当前屏幕共享流的唯一标识符
+     */
+    get shareStreamId(): string;
+    /**
+     * 远端用户正在屏幕共享
+     */
+    get isRemoteUserScreenSharing(): boolean;
+    /**
+     * 本地用户正在屏幕共享
+     */
+    get isLocalUserScreenSharing(): boolean;
+    /**
+     * 开始屏幕共享
+     */
+    startShare(params: FcrUIScreenShareStartParams): Promise<void>;
+    /**
+     * 停止屏幕共享
+     */
+    stopShare(): Promise<void>;
+    /**
+     * 替换屏幕共享
+     */
+    replaceShare(params: FcrUIScreenShareReplaceParams): Promise<void>;
+    /**
+     * 启用屏幕共享音频，仅在屏幕共享时可启用
+     */
+    enableScreenShareAudio(): void;
+    /**
+     * 禁用屏幕共享音频
+     */
+    disableScreenShareAudio(): void;
+    /**
+     * 启用流畅优先模式
+     */
+    enableSmoothMode(): void;
+    /**
+     * 禁用流畅优先模式
+     */
+    disableSmoothMode(): void;
+    /**
+     * 启用立体声模式
+     */
+    enableStereoAudioMode(): void;
+    /**
+     * 禁用立体声模式
+     */
+    disableStereoAudioMode(): void;
+    /**
+     * 获取可共享的显示器列表
+     */
+    getDisplayList(): Promise<FcrUIScreenShareDisplayInfo[]>;
+    /**
+     * 获取可共享的窗口列表
+     */
+    getWindowList(): Promise<FcrUIScreenShareWindowInfo[]>;
+    /**
+     * 设置选中的共享源边界信息
+     * @param source
+     */
+    setSelectionBounds(bounds: FcrUI.FcrUIRectangle): void;
+    /**
+     *
+     * @param observer
+     */
+    addObserver(observer: FcrUIScreenShareObserver): void;
+    /**
+     *
+     * @param observer
+     */
+    removeObserver(observer: FcrUIScreenShareObserver): void;
+}

package/lib/providers/screen-share/type.js

@@ -0,0 +1,6 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -1,6 +1,7 @@
 import { FcrCoreEngine } from 'fcr-core';
 import { FcrPeerSessionParams, FcrPeerSession } from 'fcr-core/lib/peer-session/type';
 import { FcrSessionResponse } from 'fcr-core/lib/type';
+import { FcrUIManagedObject } from '../object-manager';
 export interface FcrUISessionObserver {
     /**
      * 收到点对点会话
@@ -44,9 +45,10 @@ export interface FcrUISessionProvider {
     addObserver(observer: FcrUISessionObserver): void;
     removeObserver(observer: FcrUISessionObserver): void;
 }
-export declare class FcrUISessionProviderImpl implements FcrUISessionProvider {
+export declare class FcrUISessionProviderImpl implements FcrUISessionProvider, FcrUIManagedObject {
     private _peerSessionControl;
     constructor(engine: FcrCoreEngine);
+    release(): void;
     startPeerSession(params: FcrPeerSessionParams): Promise<string>;
     stopPeerSession(sessionId: string): void;
     acceptPeerSession(session: FcrPeerSession, cause?: Record<string, unknown>): Promise<void>;

package/lib/providers/session-provider.js

@@ -8,13 +8,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.FcrUISessionProviderImpl = void 0;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _base = require("../base");
 var FcrUISessionProviderImpl = exports.FcrUISessionProviderImpl = /*#__PURE__*/function () {
   function FcrUISessionProviderImpl(engine) {
     (0, _classCallCheck2["default"])(this, FcrUISessionProviderImpl);
     this._peerSessionControl = engine.getPeerSessionControl();
   }
   return (0, _createClass2["default"])(FcrUISessionProviderImpl, [{
+    key: "release",
+    value: function release() {}
+  }, {
     key: "startPeerSession",
     value: function startPeerSession(params) {
       return this._peerSessionControl.startPeerSession(params);
@@ -45,5 +47,4 @@ var FcrUISessionProviderImpl = exports.FcrUISessionProviderImpl = /*#__PURE__*/f
       this._peerSessionControl.removeObserver(observer);
     }
   }]);
-}();
-(0, _base.registerDependency)('sessionProvider');
+}();

package/lib/providers/setting-storage/provider.base.d.ts

@@ -0,0 +1,9 @@
+import { FcrUISettingConfig } from '../../type';
+import { FcrUIManagedObject } from '../../object-manager';
+import { FcrUIUserSettingStorageProvider } from './type';
+export declare const settingConfigStorageKey = "fcr-ui-setting-config";
+export declare abstract class FcrUIUserSettingStorageProviderBase implements FcrUIUserSettingStorageProvider, FcrUIManagedObject {
+    abstract release(): void;
+    abstract write(value: Partial<FcrUISettingConfig>): number;
+    abstract read(): FcrUISettingConfig | null;
+}

package/lib/providers/setting-storage/provider.base.js

@@ -0,0 +1,14 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.settingConfigStorageKey = exports.FcrUIUserSettingStorageProviderBase = void 0;
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var settingConfigStorageKey = exports.settingConfigStorageKey = 'fcr-ui-setting-config';
+var FcrUIUserSettingStorageProviderBase = exports.FcrUIUserSettingStorageProviderBase = /*#__PURE__*/(0, _createClass2["default"])(function FcrUIUserSettingStorageProviderBase() {
+  (0, _classCallCheck2["default"])(this, FcrUIUserSettingStorageProviderBase);
+});

package/lib/providers/setting-storage/provider.browser.d.ts

@@ -0,0 +1,7 @@
+import { FcrUISettingConfig } from '../../type';
+import { FcrUIUserSettingStorageProviderBase } from './provider.base';
+export declare class FcrUIBrowserUserSettingStorageProviderImpl extends FcrUIUserSettingStorageProviderBase {
+    release(): void;
+    write(value: Partial<FcrUISettingConfig>): number;
+    read(): any;
+}

package/lib/providers/{user-setting-storage-provider.js → setting-storage/provider.browser.js}

@@ -9,6 +9,7 @@ require("core-js/modules/es.object.define-property.js");
 require("core-js/modules/es.object.get-own-property-descriptor.js");
 require("core-js/modules/es.object.get-own-property-descriptors.js");
 require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.reflect.construct.js");
 require("core-js/modules/esnext.iterator.constructor.js");
 require("core-js/modules/esnext.iterator.filter.js");
 require("core-js/modules/esnext.iterator.for-each.js");
@@ -17,49 +18,47 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.settingConfigStorageKey = exports.FcrUIUserSettingStorageProviderImpl = void 0;
+exports.FcrUIBrowserUserSettingStorageProviderImpl = void 0;
 require("core-js/modules/es.date.to-json.js");
 require("core-js/modules/es.json.stringify.js");
 require("core-js/modules/es.object.keys.js");
 require("core-js/modules/esnext.json.parse.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _base = require("../base");
-var _env = require("agora-foundation/lib/utilities/env");
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _constant = require("../../utilities/constant");
+var _provider = require("./provider.base");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var settingConfigStorageKey = exports.settingConfigStorageKey = 'fcr-ui-setting-config';
-var FcrUIUserSettingStorageProviderImpl = exports.FcrUIUserSettingStorageProviderImpl = /*#__PURE__*/function () {
-  function FcrUIUserSettingStorageProviderImpl() {
-    (0, _classCallCheck2["default"])(this, FcrUIUserSettingStorageProviderImpl);
-    (0, _defineProperty2["default"])(this, "_isElectron", false);
-    this._isElectron = (0, _env.isElectron)();
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var FcrUIBrowserUserSettingStorageProviderImpl = exports.FcrUIBrowserUserSettingStorageProviderImpl = /*#__PURE__*/function (_FcrUIUserSettingStor) {
+  function FcrUIBrowserUserSettingStorageProviderImpl() {
+    (0, _classCallCheck2["default"])(this, FcrUIBrowserUserSettingStorageProviderImpl);
+    return _callSuper(this, FcrUIBrowserUserSettingStorageProviderImpl, arguments);
   }
-  return (0, _createClass2["default"])(FcrUIUserSettingStorageProviderImpl, [{
+  (0, _inherits2["default"])(FcrUIBrowserUserSettingStorageProviderImpl, _FcrUIUserSettingStor);
+  return (0, _createClass2["default"])(FcrUIBrowserUserSettingStorageProviderImpl, [{
+    key: "release",
+    value: function release() {}
+  }, {
     key: "write",
     value: function write(value) {
       var userSetting = this.read();
       if (userSetting) {
         value = _objectSpread(_objectSpread({}, userSetting), value);
       }
-      if (this._isElectron) {
-        window.runtime.setUserSettingData(value);
-      } else {
-        localStorage.setItem(settingConfigStorageKey, JSON.stringify(value));
-      }
+      localStorage.setItem(_constant.SETTING_CONFIG_STORAGE_KEY, JSON.stringify(value));
       return 1;
     }
   }, {
     key: "read",
     value: function read() {
-      if (this._isElectron) {
-        return window.runtime.getUserSettingData();
-      } else {
-        var getItem = localStorage.getItem(settingConfigStorageKey);
-        return getItem ? JSON.parse(getItem) : null;
-      }
+      var getItem = localStorage.getItem(_constant.SETTING_CONFIG_STORAGE_KEY);
+      return getItem ? JSON.parse(getItem) : null;
     }
   }]);
-}();
-(0, _base.registerDependency)('userSettingStorageProvider');
+}(_provider.FcrUIUserSettingStorageProviderBase);

package/lib/providers/setting-storage/provider.electron.d.ts

@@ -0,0 +1,10 @@
+import { FcrUISettingConfig } from '../../type';
+import { FcrUIUserSettingStorageProviderBase } from './provider.base';
+import { FcrUIElectronProviderConstructorArgs } from './type';
+export declare class FcrUIElectronUserSettingStorageProviderImpl extends FcrUIUserSettingStorageProviderBase {
+    private _renderer;
+    constructor(args: FcrUIElectronProviderConstructorArgs);
+    release(): void;
+    write(value: Partial<FcrUISettingConfig>): number;
+    read(): FcrUISettingConfig | null;
+}