fcr-ui-scene 1.0.20 → 3.1.0-1

package/lib/electron/main.js

@@ -0,0 +1,63 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hookWindow = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/web.timers.js");
+var _window = require("./window");
+var _screenshot = require("./plugins/screenshot");
+var hookWindow = exports.hookWindow = function hookWindow(mainWindow) {
+  mainWindow.webContents.addListener('did-start-loading', function () {
+    console.log('main window is gone, close all windows');
+    (0, _window.closeAllWindows)();
+    (0, _window.clearAllRendererWindows)();
+  });
+  mainWindow.webContents.addListener('did-create-window', function (window, details) {
+    console.log('browser window is opened, frameName:', details.frameName);
+    (0, _window.putRendererWindow)(details.frameName, window);
+    window.webContents.addListener('destroyed', function () {
+      console.log('browser window is destroyed, frameName:', details.frameName);
+      (0, _window.deleteRendererWindow)(details.frameName);
+    });
+
+    // prevent the close event to keep the window alive and renderer process will take charge of when to close the window
+    // renderer process will receive the will-close event, do some clean up and then call window.close() to close the window
+    window.addListener('close', function (event) {
+      event.preventDefault();
+      console.log("Window [".concat(window.title, ":").concat(window.id, "] is closed by shortcut CMD + W, send 'will-close' event to that window"));
+      window.emit('will-close');
+    });
+    attachEventOnMethod(window, 'hide', 'CALL_HIDE');
+    attachEventOnMethod(window, 'show', 'CALL_SHOW');
+  });
+  mainWindow.webContents.addListener('render-process-gone', function (event, details) {
+    console.log('main window render-process-gone, details', details);
+    console.log('will reload main window');
+    (0, _window.closeAllWindows)();
+    (0, _window.clearAllRendererWindows)();
+    setTimeout(function () {
+      console.log('reload main window...');
+      mainWindow.reload();
+    }, 1000);
+  });
+  (0, _screenshot.listenScreenshot)(mainWindow);
+};
+var attachEventOnMethod = function attachEventOnMethod(browserWindow, method, action) {
+  var func = browserWindow[method];
+  if (typeof func === 'function') {
+    // @ts-ignore
+    browserWindow[method] = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      // @ts-ignore
+      func.apply(this, args);
+      this.webContents.send('custom-event', {
+        action: action
+      });
+    };
+  }
+};

package/lib/electron/plugins/screenshot.d.ts

@@ -0,0 +1,2 @@
+import { BrowserWindow } from 'electron';
+export declare const listenScreenshot: (window: BrowserWindow) => void;

package/lib/electron/plugins/screenshot.js

@@ -0,0 +1,49 @@
+"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.listenScreenshot = void 0;
+var _electron = require("electron");
+var _electronScreenshots = _interopRequireDefault(require("electron-screenshots"));
+var listenScreenshot = exports.listenScreenshot = function listenScreenshot(window) {
+  var shortcutCapture = new _electronScreenshots["default"]();
+  var isCapturing = false,
+    module = '';
+  var stopScreen = function stopScreen() {
+    window.show();
+    isCapturing = false;
+  };
+  shortcutCapture.on('ok', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('finish', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('cancel', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('save', function () {
+    stopScreen();
+  });
+  var showScreenShot = function showScreenShot() {
+    if (shortcutCapture) {
+      shortcutCapture.startCapture();
+    }
+  };
+  _electron.ipcMain.addListener('short-cut-capture', function (_, event, payload) {
+    if (!isCapturing) {
+      isCapturing = true;
+      var hideWindow = false;
+      hideWindow = payload.hideWindow;
+      module = payload.module;
+      hideWindow && window.hide();
+      if (!shortcutCapture) {
+        shortcutCapture = new _electronScreenshots["default"]();
+      }
+      showScreenShot();
+    }
+  });
+};

package/lib/electron/preload.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _injections = require("./injections");
+window.runtime = {
+  open: _injections.open,
+  close: _injections.close,
+  openRendererWindow: _injections.openRendererWindow,
+  closeRendererWindow: _injections.closeRendererWindow,
+  sendEvent: _injections.sendEvent,
+  addEventListener: _injections.addEventListener,
+  removeEventListener: _injections.removeEventListener,
+  getBrowserWindowById: _injections.getBrowserWindowById,
+  captureScreen: _injections.captureScreen,
+  browserWindow: _injections.browserWindow,
+  setFragmentOptions: _injections.setFragmentOptions,
+  openLinkInDefaultBrowser: _injections.openLinkInDefaultBrowser,
+  openDirectory: _injections.openDirectory,
+  showItemInFolder: _injections.showItemInFolder,
+  screen: _injections.screen,
+  launch: _injections.launch,
+  setAlwaysOnTop: _injections.setAlwaysOnTop,
+  quitApp: _injections.quitApp,
+  getLaunchOptions: _injections.getLaunchOptions,
+  getSystemMemorySize: _injections.getSystemMemorySize,
+  getSystemCpuInfo: _injections.getSystemCpuInfo,
+  getNetworkType: _injections.getNetworkType,
+  getAssetUrl: _injections.getAssetUrl,
+  getRendererProcessUsage: _injections.getRendererProcessUsage,
+  setFragmentBaseUrl: _injections.setFragmentBaseUrl,
+  getVirtualBgResource: _injections.getVirtualBgResource,
+  fileToBase64: _injections.fileToBase64,
+  registerListenerReady: _injections.registerListenerReady,
+  releaseSubAllWindowRefs: _injections.releaseSubAllWindowRefs,
+  getMediaSourceIdList: _injections.getMediaSourceIdList
+};

package/lib/electron/tools.d.ts

@@ -0,0 +1,5 @@
+export declare function getProcessIds(processName: string): Promise<string[]>;
+export declare function getCpuUsage(): Promise<{
+    coreCount: number;
+    totalUsage: number;
+}>;

package/lib/electron/tools.js

@@ -0,0 +1,57 @@
+"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.getCpuUsage = getCpuUsage;
+exports.getProcessIds = getProcessIds;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.reduce.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.number.to-fixed.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _systeminformation = _interopRequireDefault(require("systeminformation"));
+function getProcessIds(processName) {
+  return new Promise(function (resolve, reject) {
+    _systeminformation["default"].processes().then(function (processes) {
+      var appProcess = processes.list.filter(function (process) {
+        return process.name.includes(processName);
+      });
+      var processIds = appProcess.map(function (item) {
+        return String(item.pid);
+      });
+      console.log("Process IDs for ".concat(processName, ":"), processIds);
+      resolve(processIds);
+    })["catch"](function (err) {
+      return reject(err);
+    });
+  });
+}
+function getCpuUsage() {
+  return new Promise(function (resolve, reject) {
+    _systeminformation["default"].currentLoad().then(function (data) {
+      var total = data.cpus.reduce(function (prev, curr) {
+        return prev + curr.load;
+      }, 0);
+      console.log("Total CPU Usage: ".concat(data.currentLoad.toFixed(2), "%, total: ").concat(total, ", average: ").concat(total / data.cpus.length));
+      data.cpus.forEach(function (cpu, index) {
+        console.log("Core ".concat(index, " - CPU Usage: ").concat(cpu.load.toFixed(2), "%"));
+      });
+      resolve({
+        coreCount: data.cpus.length,
+        totalUsage: total
+      });
+    })["catch"](function (err) {
+      return reject(err);
+    });
+  });
+}

package/lib/electron/window.d.ts

@@ -0,0 +1,12 @@
+import Electron, { BrowserWindow } from 'electron';
+export declare const windowOptionsMap: Record<string, Electron.BrowserWindowConstructorOptions>;
+export declare const webPreferencesMap: Record<string, Electron.WebPreferences>;
+export declare const open: (entryPath: string, dialogId?: string) => void;
+export declare const close: (entryPath: string, dialogId?: string) => void;
+export declare const getWindowKeyById: (windowId: number) => string;
+export declare const closeAllWindows: () => void;
+export declare const putRendererWindow: (entryPath: string, browserWindow: Electron.BrowserWindow) => void;
+export declare const deleteRendererWindow: (entryPath: string) => void;
+export declare const getRendererWindow: (entryPath: string) => Electron.BrowserWindow;
+export declare const clearAllRendererWindows: () => void;
+export declare const setFragmentBaseUrl: (_isDev: boolean, _baseUrl: string) => void;

package/lib/electron/window.js

@@ -0,0 +1,107 @@
+"use strict";
+
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/es.object.define-properties.js");
+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.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.windowOptionsMap = exports.webPreferencesMap = exports.setFragmentBaseUrl = exports.putRendererWindow = exports.open = exports.getWindowKeyById = exports.getRendererWindow = exports.deleteRendererWindow = exports.closeAllWindows = exports.close = exports.clearAllRendererWindows = void 0;
+require("core-js/modules/es.array.concat.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _electron = require("electron");
+var _defaultOptions = require("./default-options");
+var _process$env$ELECTRON;
+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 windowOptionsMap = exports.windowOptionsMap = {};
+var webPreferencesMap = exports.webPreferencesMap = {};
+var windows = {};
+var rendererWindows = {};
+var windowKeyById = {};
+var isDev = process.env.DEV === 'true';
+var baseUrl = (_process$env$ELECTRON = process.env.ELECTRON_START_URL) !== null && _process$env$ELECTRON !== void 0 ? _process$env$ELECTRON : "http://localhost:3000";
+var loadFragment = function loadFragment(browserWindow, path) {
+  var url = isDev ? "".concat(baseUrl, "/").concat(path, ".html") : "dist/".concat(path, ".html");
+  console.log('loadFragment', url);
+  if (isDev) {
+    return browserWindow.loadURL(url);
+  } else {
+    return browserWindow.loadFile(url);
+  }
+};
+var open = exports.open = function open(entryPath, dialogId) {
+  var _windowOptionsMap$ent;
+  var key = entryPath + (dialogId ? dialogId : '');
+  var browserWindow = windows[key];
+  if (!browserWindow) {
+    browserWindow = new _electron.BrowserWindow(_objectSpread(_objectSpread(_objectSpread({}, _defaultOptions.defaultWindowOptions), windowOptionsMap[entryPath]), {}, {
+      webPreferences: _objectSpread(_objectSpread({}, _defaultOptions.defaultWebPreferences), webPreferencesMap[entryPath])
+    }));
+    var windowId = browserWindow.id;
+    browserWindow.addListener('closed', function () {
+      delete windows[key];
+      delete windowKeyById[windowId];
+    });
+    browserWindow.webContents.addListener('render-process-gone', function (event, arg) {
+      console.log('browserWindow render-process-gone', arg);
+    });
+    require('@electron/remote/main').enable(browserWindow.webContents);
+    loadFragment(browserWindow, entryPath);
+    windows[key] = browserWindow;
+    windowKeyById[windowId] = entryPath;
+  }
+  if ((_windowOptionsMap$ent = windowOptionsMap[entryPath].show) !== null && _windowOptionsMap$ent !== void 0 ? _windowOptionsMap$ent : true) {
+    browserWindow.show();
+  }
+};
+var close = exports.close = function close(entryPath, dialogId) {
+  var key = entryPath + (dialogId ? dialogId : '');
+  if (key in windows) {
+    var browserWindow = windows[key];
+    if (browserWindow) {
+      browserWindow.close();
+      delete windows[key];
+      delete windowKeyById[browserWindow.id];
+    }
+  }
+};
+var getWindowKeyById = exports.getWindowKeyById = function getWindowKeyById(windowId) {
+  return windowKeyById[windowId];
+};
+var closeAllWindows = exports.closeAllWindows = function closeAllWindows() {
+  for (var key in windows) {
+    windows[key].destroy();
+  }
+  windows = {};
+  windowKeyById = {};
+};
+var putRendererWindow = exports.putRendererWindow = function putRendererWindow(entryPath, browserWindow) {
+  rendererWindows[entryPath] = browserWindow;
+};
+var deleteRendererWindow = exports.deleteRendererWindow = function deleteRendererWindow(entryPath) {
+  delete rendererWindows[entryPath];
+};
+var getRendererWindow = exports.getRendererWindow = function getRendererWindow(entryPath) {
+  return rendererWindows[entryPath];
+};
+var clearAllRendererWindows = exports.clearAllRendererWindows = function clearAllRendererWindows() {
+  for (var key in rendererWindows) {
+    rendererWindows[key].emit('will-close');
+    rendererWindows[key].destroy();
+  }
+  rendererWindows = {};
+};
+var setFragmentBaseUrl = exports.setFragmentBaseUrl = function setFragmentBaseUrl(_isDev, _baseUrl) {
+  isDev = _isDev;
+  baseUrl = _baseUrl;
+};

package/lib/fragments/base.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class BaseFragment implements Fragment {
+    protected runtime: Runtime;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    constructor(runtime: Runtime);
+    abstract get name(): string;
+    abstract get component(): JSX.Element;
+    protected sendEvent(event: RendererCustomEvent): void;
+    protected onEvent(event: RendererCustomEvent): void;
+    private _onLoad;
+}

package/lib/fragments/base.js

@@ -0,0 +1,44 @@
+"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.BaseFragment = void 0;
+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 _i18n = require("agora-ui-foundation/lib/i18n");
+var _tools = require("../utilities/tools");
+var _logger = require("agora-foundation/lib/logger");
+var BaseFragment = exports.BaseFragment = /*#__PURE__*/function () {
+  function BaseFragment(runtime) {
+    (0, _classCallCheck2["default"])(this, BaseFragment);
+    (0, _defineProperty2["default"])(this, "logger", (0, _logger.getLogger)());
+    this.runtime = runtime;
+    this._onLoad();
+  }
+  return (0, _createClass2["default"])(BaseFragment, [{
+    key: "sendEvent",
+    value: function sendEvent(event) {
+      this.runtime.sendEvent(event);
+    }
+  }, {
+    key: "onEvent",
+    value: function onEvent(event) {}
+  }, {
+    key: "_onLoad",
+    value: function _onLoad() {
+      var _this = this;
+      var language = (0, _tools.getLanguage)();
+      if (language) {
+        this.logger.info('set language to:', language);
+        (0, _i18n.changeLanguage)(language);
+      }
+      this.runtime.addEventListener(function (_, event) {
+        _this.onEvent(event);
+      });
+    }
+  }]);
+}();

package/lib/fragments/control-bar/cloud-recording-buttons.d.ts

@@ -0,0 +1 @@
+export declare const CloudRecordingButtons: () => import("react/jsx-runtime").JSX.Element;

package/lib/fragments/control-bar/cloud-recording-buttons.js

@@ -0,0 +1,67 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CloudRecordingButtons = void 0;
+var _mobxReact = require("mobx-react");
+var _react = require("react");
+var _type = require("agora-edu-core/lib/type");
+var _icon = require("agora-ui-foundation/lib/components/icon");
+var _type2 = require("agora-ui-foundation/lib/components/icon/type");
+var _tooltip = require("agora-ui-foundation/lib/components/tooltip");
+var _context = require("./context");
+var _stopRecordDialog = require("../../modules/action-bar/record/stop-record-dialog");
+var _i18n = require("agora-ui-foundation/lib/i18n");
+var _jsxRuntime = require("react/jsx-runtime");
+var CloudRecordingButtons = exports.CloudRecordingButtons = (0, _mobxReact.observer)(function () {
+  var _useContext = (0, _react.useContext)(_context.StoreContext),
+    cloudRecordingState = _useContext.cloudRecordingState,
+    pauseCloudRecording = _useContext.pauseCloudRecording,
+    resumeCloudRecording = _useContext.resumeCloudRecording,
+    stopCloudRecording = _useContext.stopCloudRecording;
+  var transI18n = (0, _i18n.useI18n)();
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    className: "fcr-control-bar-cloud-recording-buttons",
+    children: [cloudRecordingState === _type.FcrRecordingState.Paused ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_tooltip.FcrToolTip, {
+      content: transI18n('fmt_record_button_Cloudrecording_restore'),
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("button", {
+        onClick: resumeCloudRecording,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_icon.FcrIcon, {
+          type: _type2.FcrIconType.FCR_RECORDING_PLAY2,
+          size: 32,
+          colors: {
+            iconPrimary: 'var(--fcr_ui_scene_ramp_brand6)'
+          }
+        })
+      })
+    }) : /*#__PURE__*/(0, _jsxRuntime.jsx)(_tooltip.FcrToolTip, {
+      content: transI18n('fmt_settings_options_pausecloudrecording'),
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)("button", {
+        onClick: pauseCloudRecording,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_icon.FcrIcon, {
+          type: _type2.FcrIconType.FCR_PAUSE2,
+          size: 32,
+          colors: {
+            iconPrimary: 'var(--fcr_ui_scene_ramp_purple6)'
+          }
+        })
+      })
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_stopRecordDialog.StopCloudRecording, {
+      stopCloudRecording: stopCloudRecording,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_tooltip.FcrToolTip, {
+        content: transI18n('fmt_record_button_Cloudrecording_stop'),
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)("button", {
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_icon.FcrIcon, {
+            type: _type2.FcrIconType.FCR_STOP3,
+            size: 32,
+            colors: {
+              iconPrimary: 'var(--fcr_ui_scene_ramp_red6)'
+            }
+          })
+        })
+      })
+    })]
+  });
+});

package/lib/fragments/control-bar/context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import ControlBarStore from './control-bar-store';
+export declare const StoreContext: import("react").Context<ControlBarStore>;

package/lib/fragments/control-bar/context.js

@@ -0,0 +1,9 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StoreContext = void 0;
+var _react = require("react");
+var StoreContext = exports.StoreContext = /*#__PURE__*/(0, _react.createContext)(null);

package/lib/fragments/control-bar/control-bar-store.d.ts

@@ -0,0 +1,152 @@
+import { RendererEventAction } from '../../utilities/constant';
+import { AgoraRtcScreenCaptureType, AgoraRtcWindowInfo } from 'agora-rte-sdk/lib/core/rtc/type';
+import { AudioProcessingChannel } from 'agora-ui-foundation/lib/components/room-screen-share-state-bar/share-audio';
+import { FcrRecordingState, FcrUserRole, FcrLiveStreamingState } from 'agora-edu-core/lib/type';
+import { ConnectType } from '../../modules/action-bar/type';
+export default class ControlBarStore {
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _screenBounds;
+    accessor shareWithAudio: boolean;
+    accessor shareAudioProcessingChannel: AudioProcessingChannel;
+    accessor currentShareId: string;
+    accessor currentShareType: AgoraRtcScreenCaptureType;
+    accessor isMuteAudio: boolean;
+    accessor isMuteVideo: boolean;
+    accessor currentCameraId: string;
+    accessor currentMicrophoneId: string;
+    accessor currentSpeakerId: string;
+    accessor cameraList: any[];
+    accessor microphoneList: any[];
+    accessor speakerList: any[];
+    accessor localAudioVolume: number;
+    accessor connectType: ConnectType;
+    accessor cloudRecordingState: FcrRecordingState;
+    accessor localUserRole: FcrUserRole;
+    accessor allowChangeSelfName: boolean;
+    accessor allowChat: boolean;
+    accessor allowJoinWithMuteAudio: boolean;
+    accessor allowShareScreen: boolean;
+    accessor allowUnmuteSelfVideo: boolean;
+    accessor allowUnmuteSelfAudio: boolean;
+    accessor isLockRoomEnabled: boolean;
+    accessor isWaitingRoomEnabled: boolean;
+    accessor showSecurity: boolean;
+    accessor isHost: boolean;
+    accessor hasEnableStartScreenSharePermission: boolean;
+    accessor hasPermissionToControlAllowSendAll: boolean;
+    accessor hasEnableStartAudioPermission: boolean;
+    accessor hasEnableChangeNamePermission: boolean;
+    accessor hasEnableStartVideoPermission: boolean;
+    accessor hasLockRoomPermission: boolean;
+    accessor roomDuration: number;
+    accessor startTime: number;
+    accessor videoSteamingUrl: string;
+    accessor videoStreamingKey: string;
+    accessor playUrl: string;
+    accessor isStartError: boolean;
+    accessor liveStreamingState: FcrLiveStreamingState;
+    accessor hasStartCloudRecordingPermission: boolean;
+    accessor hasGetLiveStreamingUrlPermission: boolean;
+    accessor hasStopLiveStreamingPermission: boolean;
+    accessor hasStartLiveStreamingPermission: boolean;
+    accessor allApplicationWindows: AgoraRtcWindowInfo[];
+    accessor phoneMicEnabled: boolean;
+    constructor();
+    initControlBar(payload: any): void;
+    private _setControlBarWindowBounds;
+    get hasSecurityPermission(): boolean;
+    updateCurrentShareContent(payload: {
+        id: string;
+        type: AgoraRtcScreenCaptureType;
+        withAudio: boolean;
+    }): void;
+    updateAllApplicationList(allApplicationWindows: AgoraRtcWindowInfo[]): void;
+    get screenBounds(): {
+        width: number;
+        height: number;
+        availTop: number;
+    };
+    setLiveStreamingInfo(data: {
+        videoSteamingUrl: string;
+        videoStreamingKey: string;
+        playUrl: string;
+        isStartError: boolean;
+    }): void;
+    setLiveStreamingState(liveStreamingState: FcrLiveStreamingState): void;
+    setStartTime(startTime: any): void;
+    setRoomDuration(duration: number): void;
+    setStartScreenSharePermission(hasPermission: boolean): void;
+    setPermissionToControlAllowSendAll(hasPermission: boolean): void;
+    setStartAudioPermission(hasPermission: boolean): void;
+    setChangeNamePermission(hasPermission: boolean): void;
+    setStartVideoPermission(hasPermission: boolean): void;
+    setLockRoomPermission(hasPermission: boolean): void;
+    setCloudRecordingState(state: FcrRecordingState): void;
+    setApplicationWindows(windows: AgoraRtcWindowInfo[]): void;
+    setLocalUserRole(role: FcrUserRole): void;
+    setShareWithAudioState(withAudio: boolean): void;
+    setShareWithAudioStateOnly(withAudio: boolean): void;
+    createNewShare(): void;
+    handlerStopShare(): void;
+    setShareAudioProcessingChannel(target: AudioProcessingChannel): void;
+    muteLocalAudio(mute: boolean): void;
+    setCurrentMicrophoneId(deviceId: string): void;
+    setCurrentSpeakerId(deviceId: string): void;
+    setMicrophoneList(list: any[]): void;
+    setSpeakerList(list: any[]): void;
+    setLocalAudioState(): void;
+    setConnectType(type: ConnectType): void;
+    setPhoneMicEnabled(value: boolean): void;
+    getCurrentWorkArea(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        displayId: number;
+        availTop: number;
+    };
+    handlerOpenAudioSetting(): void;
+    handlerMicrophoneDeviceChange(value: any): void;
+    handlerSpeakerDeviceChange(value: string): void;
+    muteLocalVideo(mute: boolean): void;
+    setLocalAudioVolume(volume: number): void;
+    setCurrentCameraId(deviceId: string): void;
+    setCameraList(list: any[]): void;
+    setLocalVideoState(): void;
+    handlerCameraDeviceChange(value: string): void;
+    handlerOpenVirtualBackground(): void;
+    handlerOpenVideoFilter(): void;
+    handlerOpenVideoSetting(): void;
+    setIsHost(isHost: boolean): void;
+    setShowSecurity(show: boolean): void;
+    setAllowChangeSelfName(allow: boolean): void;
+    updateAllowChangeSelfName(allow: boolean): void;
+    setAllowChat(allow: boolean): void;
+    updateAllowChat(allow: boolean): void;
+    setAllowJoinWithMuteAudio(allow: boolean): void;
+    updateAllowJoinWithMuteAudio(allow: boolean): void;
+    setAllowShareScreen(allow: boolean): void;
+    updateAllowShareScreen(allow: boolean): void;
+    setAllowUnmuteSelfVideo(allow: boolean): void;
+    updateAllowUnmuteSelfVideo(allow: boolean): void;
+    setAllowUnmuteSelfAudio(allow: boolean): void;
+    updateAllowUnmuteSelfAudio(allow: boolean): void;
+    setLockRoomEnabled(lock: boolean): void;
+    updateLockRoomEnabled(lock: boolean): void;
+    setWaitingRoomEnabled(allow: boolean): void;
+    setHasStartCloudRecordingPermission(allow: boolean): void;
+    setHasGetLiveStreamingUrlPermission(hasGetLiveStreamingUrlPermission: boolean): void;
+    setHasStopLiveStreamingPermission(hasStopLiveStreamingPermission: boolean): void;
+    setHasStartLiveStreamingPermission(hasStartLiveStreamingPermission: boolean): void;
+    updateWaitingRoomEnabled(allow: boolean): void;
+    handleMoreClick(actionKey: RendererEventAction): void;
+    startCloudRecording(): void;
+    pauseCloudRecording(): void;
+    resumeCloudRecording(): void;
+    stopCloudRecording(): void;
+    getCoordinate(offsetWidth: number, offsetHeight: number): {
+        x: number;
+        y: number;
+    };
+    showToast(params: any): void;
+}