fcr-ui-scene 3.7.7-rc.1 → 3.7.8

package/lib/modules/action-bar/index.dev.js

@@ -0,0 +1,94 @@
+// import { FcrActionBarUIModule } from '.';
+// import ReactDOM from 'react-dom';
+// import { hot } from 'react-hot-loader/root';
+
+// import { FcrStreamLatencyLevel, FcrUISceneConfig, FcrUserRole } from '../../type';
+// import { PropsWithChildren } from 'react';
+// import { useUnmount } from '../../utilities/hooks';
+// import { FcrSecurityStore } from '../../common/security-store';
+// import { FcrDeviceStreamStore } from '../../common/device-stream-store';
+// import { FcrUIEventStore } from '../../common/event-control';
+// import { FcrDeviceStore } from '../../common/device-store';
+// import { FcrRoomStore } from '../../common/room-control';
+
+// const App = hot(() => null);
+
+// ReactDOM.render(<App />, document.querySelector('#root')!);
+
+// const Layout: React.FC<PropsWithChildren<{}>> = (props) => (
+//   <div style={{ height: '100vh', background: '#E3E7EF' }}>
+//     <div style={{ position: 'absolute', left: '5vw', bottom: '50px', width: '90vw' }}>
+//       {props.children}
+//     </div>
+//   </div>
+// );
+
+// window.__DEV_ENGINE_IS_READY__.then(async () => {
+//   const engine = window.__DEV_ENGINE__;
+//   const roomId = window.__DEV_ROOM_ID__;
+
+//   await engine.login();
+
+//   const roomControl = engine.createMainRoomControl(roomId);
+
+//   const userRole = FcrUserRole.HOST;
+
+//   const userName = 'host-user';
+
+//   await roomControl.join({
+//     userRole,
+//     userName,
+//     roomToken: window.__DEV_USER_TOKEN__,
+//     streamLatency: FcrStreamLatencyLevel.ULTRA_LOW,
+//     createStreamConfigs: [],
+//   });
+
+//   const userControl = roomControl.getUserControl();
+
+//   const uiEventStore = new FcrUIEventStore();
+//   const securityStore = new FcrSecurityStore(
+//     roomControl.getPrivilegeControl(),
+//     roomControl.getUserControl(),
+//     roomControl.getStreamControl(),
+//     uiEventStore,
+//   );
+//   const deviceStore = new FcrDeviceStore(engine.getDesktopMediaControl(), uiEventStore);
+//   const config = {
+//     mediaControl: engine.getDesktopMediaControl(),
+//     roomControl,
+//     securityStore,
+//     deviceStore,
+//     uiEventStore,
+//     roomStore: new FcrRoomStore(uiEventStore, deviceStore, {} as FcrUISceneConfig, engine),
+//     streamControl: roomControl.getStreamControl(),
+//     userControl,
+//     privilegeControl: roomControl.getPrivilegeControl(),
+//     interpreterControl: roomControl.getInterpreterControl(),
+//     chatRoomControl: roomControl.getChatRoomControl(),
+//     engine: null as any,
+//     remoteVideoRenderManager: null as any,
+//     config: null as any,
+//     parameters: null as any,
+//   };
+//   const deviceStreamStore = new FcrDeviceStreamStore(config);
+
+//   const uiModule = new FcrActionBarUIModule({ ...config, deviceStreamStore });
+
+//   const App = hot(() => {
+//     useUnmount(() => {
+//       uiModule?.release();
+//       roomControl.leave();
+//       engine.logout();
+//     });
+
+//     return uiModule?.getComponent();
+//   });
+
+//   ReactDOM.render(
+//     <Layout>
+//       <App />
+//     </Layout>,
+//     document.querySelector('#root')!,
+//   );
+// });
+"use strict";

package/lib/modules/action-bar/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+require("core-js/modules/es.array.iterator.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.to-string.js");
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.weak-map.js");
+require("core-js/modules/esnext.weak-map.delete-all.js");
+require("core-js/modules/esnext.weak-map.emplace.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrActionBarUIModule = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+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 _base = require("../../base");
+var _view = require("./view");
+var _store = _interopRequireWildcard(require("./store"));
+require("./index.css");
+var _store2 = require("../components/device-control/store");
+var _type = require("fcr-core/lib/room-control/type");
+var _constant = require("../../utilities/constant");
+var _store3 = require("../components/leave-meeting/store");
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+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 FcrActionBarUIModule = exports.FcrActionBarUIModule = /*#__PURE__*/function (_UIModule) {
+  function FcrActionBarUIModule() {
+    (0, _classCallCheck2["default"])(this, FcrActionBarUIModule);
+    return _callSuper(this, FcrActionBarUIModule, arguments);
+  }
+  (0, _inherits2["default"])(FcrActionBarUIModule, _UIModule);
+  return (0, _createClass2["default"])(FcrActionBarUIModule, [{
+    key: "onNodeWillActive",
+    value:
+    // privilegeProvider?: FcrUIPrivilegeProvider;
+
+    function onNodeWillActive() {
+      var _this$currentRoomCont, _this$mainRoomControl, _this$waitingRoomCont, _this$currentRoomCont2, _this$currentRoomCont3, _this$currentRoomCont4;
+      var privilegeProvider = ((_this$currentRoomCont = this.currentRoomControlProvider) === null || _this$currentRoomCont === void 0 || (_this$currentRoomCont = _this$currentRoomCont.currentRoomControl.getRoomInfo()) === null || _this$currentRoomCont === void 0 ? void 0 : _this$currentRoomCont.roomType) === _type.FcrRoomType.Mainroom ? (_this$mainRoomControl = this.mainRoomControlProvider) === null || _this$mainRoomControl === void 0 ? void 0 : _this$mainRoomControl.privilegeProvider : (_this$waitingRoomCont = this.waitingRoomControlProvider) === null || _this$waitingRoomCont === void 0 ? void 0 : _this$waitingRoomCont.privilegeProvider;
+      this._store = new _store["default"]({
+        roomProvider: this.roomProvider,
+        roomControl: (_this$currentRoomCont2 = this.currentRoomControlProvider) === null || _this$currentRoomCont2 === void 0 ? void 0 : _this$currentRoomCont2.currentRoomControl,
+        eventProvider: this.eventProvider,
+        privilegeProvider: privilegeProvider,
+        deviceProvider: this.deviceProvider,
+        deviceStreamProvider: this.deviceStreamProvider,
+        sharedLayoutDataSource: this.sharedLayoutDataSource,
+        screenShareProvider: this.screenShareProvider,
+        sharedWaitingRoomDataSource: this.sharedWaitingRoomDataSource,
+        chatProvider: this.chatProvider,
+        sharedInterpreterDataSource: this.sharedInterpreterDataSource,
+        dialogProvider: this.dialogProvider,
+        messageProvider: this.messageProvider,
+        sharedChatDataSource: this.sharedChatDataSource,
+        interpreterProvider: this.interpreterProvider,
+        sharedDevicePrivilegeDataSource: this.sharedDevicePrivilegeDataSource,
+        sharedMemberDataSource: this.sharedMemberDataSource,
+        widgetProvider: this.widgetProvider,
+        sharedSecuritySharedDataSource: this.sharedSecuritySharedDataSource,
+        sharedScreenShareSharedDataSource: this.sharedScreenShareSharedDataSource,
+        abilityProvider: this.abilityProvider,
+        applistProvider: this.applistProvider,
+        sharedApplistDataSource: this.sharedApplistDataSource
+      });
+      this._deviceControlStore = new _store2.DeviceControlStore((_this$currentRoomCont3 = this.currentRoomControlProvider) === null || _this$currentRoomCont3 === void 0 ? void 0 : _this$currentRoomCont3.currentRoomControl, this.deviceProvider, this.dialogProvider, this.deviceStreamProvider, this.sharedDevicePrivilegeDataSource);
+      this._leaveMeetingStore = new _store3.LeaveMeetingStore(privilegeProvider, this.roomProvider, (_this$currentRoomCont4 = this.currentRoomControlProvider) === null || _this$currentRoomCont4 === void 0 ? void 0 : _this$currentRoomCont4.currentRoomControl, this.sharedMemberDataSource, this.abilityProvider, this.dialogProvider);
+    }
+  }, {
+    key: "onNodeWillInactive",
+    value: function onNodeWillInactive() {
+      var _this$_store, _this$_leaveMeetingSt, _this$_deviceControlS;
+      (_this$_store = this._store) === null || _this$_store === void 0 || _this$_store.release();
+      (_this$_leaveMeetingSt = this._leaveMeetingStore) === null || _this$_leaveMeetingSt === void 0 || _this$_leaveMeetingSt.release();
+      (_this$_deviceControlS = this._deviceControlStore) === null || _this$_deviceControlS === void 0 || _this$_deviceControlS.release();
+    }
+  }, {
+    key: "getComponent",
+    value: function getComponent() {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_store.ActionBarContext.Provider, {
+        value: this._store,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_store2.DeviceControlStoreContext.Provider, {
+          value: this._deviceControlStore,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_store3.LeaveMeetingStoreContext.Provider, {
+            value: this._leaveMeetingStore,
+            children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_view.FcrActionBar, {})
+          })
+        })
+      });
+    }
+  }, {
+    key: "onProcessEvent",
+    value: function onProcessEvent(event) {
+      if (event.action === _constant.FcrUIRendererEventAction.CALL_CLOSE_MAIN_WINDOW) {
+        this._store.setStateBarLeaveMeeting(true);
+      }
+    }
+  }]);
+}(_base.UIModule);

package/lib/modules/action-bar/store.d.ts

@@ -0,0 +1,256 @@
+import { FcrConnectionState } from 'fcr-core';
+import { FcrLiveStreamingState, FcrRecordingState, FcrUserInfo, FcrUserRole, FcrLineType } from 'fcr-core/lib/type';
+import { DeviceSettingDialogConfig } from '../setting/store';
+import { FcrUIRoomType, FcrUIWebWidgetConfig } from '../../type';
+import { FcrUserKickedOutType } from 'fcr-core/lib/room-control/user-control/type';
+import { FcrBaseRoomControl } from 'fcr-core/lib/room-control/type';
+import { FcrLanguage } from 'fcr-core/lib/room-control/interpreter-control/types';
+import { ConnectionTabType } from '../video-window/type';
+import { FcrUIDeviceProvider } from '../../providers/device-provider';
+import { FcrUIEventProvider } from '../../providers/event-provider';
+import { FcrUIPrivilegeProvider } from '../../providers/privilege-provider';
+import { FcrUIRoomProvider } from '../../providers/room-provider';
+import { FcrUIDeviceStreamProvider } from '../../providers/device-stream-provider';
+import { FcrUISharedLayoutDataSource } from '../../shared-data-source/layout-data';
+import { FcrUISharedInterpreterDataSource, FcrUILanguage } from '../../shared-data-source/interpreter';
+import { FcrUISharedWaitingRoomDataSource } from '../../shared-data-source/waiting-room';
+import { FcrUIChatProvider } from '../../providers/chat-provider';
+import { MoreMenuType } from './enums';
+import { FcrUIScreenShareProvider } from '../../providers/screen-share-provider';
+import { FcrUIDialogProvider } from '../../providers/dialog-provider';
+import { FcrUIMessageProvider } from '../../providers/message-provider';
+import { FcrUISharedChatDataSource } from '../../shared-data-source/chat-data';
+import { FcrUIInterpreterProvider } from '../../providers/interpreter-provider';
+import { FcrUISharedDevicePrivilegeDataSource } from '../../shared-data-source/device-privilege-data';
+import { FcrUIMemberSharedDataSource } from '../../shared-data-source/member-data';
+import { FcrUIWidgetProvider } from '../../providers/widget-provider';
+import { FcrSecurityCheckedStateType, FcrUISecuritySharedDataSource } from '../../shared-data-source/security-data';
+import { FcrUIScreenShareSharedDataSource } from '../../shared-data-source/screen-share-data';
+import { FcrUIAbilityProviderImpl } from '../../providers/ability-provider';
+import { FcrUISharedApplistSource } from '../../shared-data-source/app-list-data';
+import { FcrUIApplistProvider } from '../../providers/app-list-provider';
+export declare enum AudioConnectType {
+    NONE = 0,
+    COMPUTER = 1,
+    PHONE = 2
+}
+export default class ActionBarStore {
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _roomProvider;
+    private _roomControl;
+    private _eventProvider;
+    private _dialogProvider;
+    private _messageProvider;
+    private _privilegeProvider;
+    private _deviceProvider;
+    private _deviceStreamProvider;
+    private _screenShareProvider;
+    private _sharedWaitingRoomDataSource;
+    private _sharedInterpreterDataSource;
+    private _disposers;
+    private _waitingRoomControl?;
+    private _userControl;
+    private _sharedLayoutDataSource;
+    private _sharedChatDataSource;
+    private _interpreterProvider?;
+    private _sharedDevicePrivilegeDataSource;
+    private _sharedMemberDataSource;
+    private _roomType;
+    private _widgetProvider;
+    private _sharedSecuritySharedDataSource;
+    private _sharedScreenShareSharedDataSource;
+    private _abilityProvider;
+    private _applistProvider;
+    private _sharedApplistDataSource;
+    private _userObserver;
+    private _roomObserver;
+    private _mainRoomObserver;
+    private _uiEventObserver;
+    private _openedDialogIdMap;
+    private _newMessageTooltipTimer;
+    private _hideBarArrowTimer;
+    private _interpreterProviderObserver;
+    private _applistObserver;
+    accessor newMessageTooltipVisible: boolean;
+    accessor totalWaitingRoomUser: number;
+    accessor liveStreamingState: FcrLiveStreamingState;
+    accessor currentMenuIs: MoreMenuType;
+    accessor cloudRecordingState: FcrRecordingState;
+    accessor connectionSettingVisible: boolean;
+    accessor folded: boolean;
+    accessor boardOwnerUser: FcrUserInfo | null;
+    accessor showArrow: boolean;
+    accessor phoneMicEnabled: boolean;
+    accessor chatTabIndex: FcrUIRoomType;
+    accessor stateBarLeaveMeeting: boolean;
+    accessor hasOfflineUserExistence: boolean;
+    accessor connectionState: FcrConnectionState;
+    accessor appActionbarPopoverVisible: boolean;
+    constructor(args: {
+        roomProvider: FcrUIRoomProvider;
+        roomControl: FcrBaseRoomControl;
+        eventProvider: FcrUIEventProvider;
+        dialogProvider: FcrUIDialogProvider;
+        messageProvider: FcrUIMessageProvider;
+        privilegeProvider: FcrUIPrivilegeProvider;
+        deviceProvider: FcrUIDeviceProvider;
+        deviceStreamProvider: FcrUIDeviceStreamProvider;
+        sharedLayoutDataSource: FcrUISharedLayoutDataSource;
+        screenShareProvider: FcrUIScreenShareProvider;
+        sharedWaitingRoomDataSource: FcrUISharedWaitingRoomDataSource;
+        chatProvider: FcrUIChatProvider;
+        sharedInterpreterDataSource: FcrUISharedInterpreterDataSource;
+        sharedChatDataSource: FcrUISharedChatDataSource;
+        interpreterProvider?: FcrUIInterpreterProvider;
+        sharedDevicePrivilegeDataSource: FcrUISharedDevicePrivilegeDataSource;
+        sharedMemberDataSource: FcrUIMemberSharedDataSource;
+        widgetProvider: FcrUIWidgetProvider;
+        sharedSecuritySharedDataSource: FcrUISecuritySharedDataSource;
+        sharedScreenShareSharedDataSource: FcrUIScreenShareSharedDataSource;
+        abilityProvider: FcrUIAbilityProviderImpl;
+        applistProvider: FcrUIApplistProvider;
+        sharedApplistDataSource: FcrUISharedApplistSource;
+    });
+    private _handleApplistItemClick;
+    get checkedStateMap(): FcrSecurityCheckedStateType;
+    setCheckedStateMap(val: FcrSecurityCheckedStateType): void;
+    get registeredWidgetConfigs(): FcrUIWebWidgetConfig[];
+    get appItemOptions(): import("./types").AppItemProps[];
+    get supportedLanguages(): FcrLanguage[];
+    get users(): FcrUserInfo[];
+    get localUserRole(): FcrUserRole;
+    get localUserId(): string;
+    get totalUser(): number;
+    get isPstnUser(): boolean;
+    get localInterpreterUserInfo(): import("fcr-core/lib/room-control/interpreter-control/types").FcrInterpreterUserInfo | null;
+    get interpreterUserList(): import("fcr-core/lib/room-control/interpreter-control/types").FcrInterpreterUserInfo[] | null;
+    get isInterpreterEnabled(): boolean;
+    get outputLanguage(): FcrLanguage | null;
+    get hasSubscribedLanguageList(): FcrUILanguage[];
+    get preHasSubscribedLanguageList(): FcrUILanguage[];
+    get subscribeLanguageOptionList(): FcrUILanguage[];
+    get isNewWaitingRoomUserEnter(): boolean;
+    get privilegeProvider(): FcrUIPrivilegeProvider;
+    get asideLayout(): import("../../type").FcrUIUpdateAsideParams;
+    get chatRenderAt(): "aside" | "dialog";
+    get participantsRenderAt(): "aside" | "dialog";
+    get participantVisible(): boolean | undefined;
+    get chatVisible(): boolean | undefined;
+    get remoteUsers(): FcrUserInfo[];
+    get hasStartScreenSharePermission(): boolean;
+    get hasStopScreenSharePermission(): boolean | undefined;
+    get sharingOwnerUser(): FcrUserInfo | undefined;
+    get hasEnableStartScreenSharePermission(): boolean;
+    get hasStartLiveStreamingPermission(): boolean;
+    get hasEnableStartAudioPermission(): boolean;
+    get hasEnableChangeNamePermission(): boolean;
+    get hasEnableStartVideoPermission(): boolean;
+    get hasLockRoomPermission(): boolean;
+    get hasEnableJoinWithAudioPermission(): boolean;
+    get hasWaitingRoomPermission(): boolean;
+    get hasWatermarkEnablePermission(): boolean;
+    get hasWatermarkDisablePermission(): boolean;
+    get hasEnableStartSharePermission(): boolean;
+    get hasAllowWriteBoardPermission(): boolean;
+    get hasCloseWriteBoardPermission(): boolean;
+    get hasScreenShare(): boolean;
+    get hasAllowScreenShareAndBoardPermission(): boolean;
+    get hasAllowChatPermission(): boolean;
+    get hasStartCloudRecordingPermission(): boolean;
+    get hasAssignHostBeforeLeavingPermission(): boolean;
+    get hasEndRoomPermission(): boolean;
+    get isScreenShareAndBoardEnabled(): boolean;
+    get isBoardWriteEnabled(): boolean;
+    get isWaterMarkEnabled(): boolean;
+    get isMulti(): boolean;
+    get hasEnableInterpreterPermission(): boolean;
+    get hasDisableInterpreterPermission(): boolean;
+    get microphoneEnabled(): boolean;
+    get allNewMessage(): number;
+    get isMainRoom(): boolean;
+    get hasAllowChangeNamePromission(): boolean;
+    get hasDisallowChangeNamePromission(): boolean;
+    get newMessageCount(): import("./types").ChatRoomStoreMap;
+    get endMeetingPopoverOpened(): boolean;
+    set newMessageCount(value: import("./types").ChatRoomStoreMap);
+    get latestMessage(): import("../../providers/chat-provider").FcrChatRoomReceiveMessage | undefined;
+    get isRecordingSupported(): boolean;
+    get hasSecurityPermissions(): boolean;
+    pauseCloudRecording(): void;
+    resumeCloudRecording(): void;
+    stopCloudRecording(): void;
+    startCloudRecording(): void;
+    showLockedRoomToast(enable: boolean): void;
+    toggleLayoutBarLock(payload: boolean): void;
+    showNewMessageTooltip(): void;
+    hideNewMessageTooltip(): void;
+    switchMenu(value?: MoreMenuType): void;
+    get isLocked(): boolean;
+    isWaitingRoomEnabled(): boolean;
+    isAllowJoinWithAudioEnabled(): boolean;
+    enableMicrophone(enable: boolean): void;
+    setAllowWriteBoard(state: boolean): void;
+    setAllowAnnotation(state: boolean): void;
+    setAllowScreenShare(state: boolean): void;
+    setPopoverOpened(isShow: boolean): void;
+    setStateBarLeaveMeeting(isShow: boolean): void;
+    release(): void;
+    allowJoinWithMuteAudio(): boolean;
+    setAllowJoinWithMuteAudio(enable: boolean): void;
+    isLockRoomEnabled(): boolean;
+    setLockRoomEnabled(enable: boolean): void;
+    setAllowShareScreen(enable: boolean): void;
+    allowShareScreen(): boolean;
+    allowWriteBoard(): boolean;
+    allowChat(): boolean;
+    setAllowChat(enable: boolean): void;
+    allowUnmuteSelfAudio(): boolean;
+    setAllowUnmuteSelfAudio(enable: boolean): void;
+    allowUnmuteSelfVideo(): boolean;
+    setAllowUnmuteSelfVideo(enable: boolean): void;
+    allowChangeName(): boolean;
+    setAllowChangeName(enable: boolean): void;
+    toggleChat(): void;
+    openChat(): void;
+    closeChat(): void;
+    toggleParticipants(): void;
+    openParticipants(): void;
+    closeParticipants(): void;
+    openDeviceSettingDialog(arg: Partial<DeviceSettingDialogConfig>): void;
+    startScreenShare(): void;
+    openInterpreterDialog(): void;
+    openWhiteboard(): void;
+    closeWhiteboard(): void;
+    closeShareScreen(): void;
+    openLiveStreamingDialog(): void;
+    toggleConnection(): void;
+    openConnection(type: ConnectionTabType): void;
+    closeConnection(): void;
+    private _handleJoinWaitingRoom;
+    toggleFold(): void;
+    setShowArrow(show: boolean): void;
+    setEnableWaitingRoom(enable: boolean, isNeedShowDialog: boolean): Promise<void>;
+    kickOutWaitingRoomAllMember(type: FcrUserKickedOutType): Promise<void>;
+    moveToMainRoomAllMember(): Promise<void>;
+    private _interceptShareScreen;
+    private _interceptShareBoard;
+    private _handleRemoteUsersJoined;
+    private _handleRemoteUsersLeft;
+    private _handleLiveStreamingStateUpdated;
+    private _handleChatVisible;
+    setAppActionbarPopoverVisible(visible: boolean): void;
+    setAllowWaterMark(): void;
+    setWaterMarkLineType(lineType: FcrLineType): void;
+    setAlllowChangeName(enable: boolean): void;
+    private _onEvent;
+    private _operateWaitingRoom;
+    private _handleCloudRecordingStateUpdated;
+    setOutputLanguage(language: FcrLanguage): Promise<void>;
+    subscribeLanguage(language: FcrUILanguage): Promise<void>;
+    subscribeExtraOriginLanguage(enable: boolean): Promise<void>;
+    getOfflineUserExistenceState(): boolean;
+    clickWidget(widgetConfig: FcrUIWebWidgetConfig): void;
+    closeWidget(widgetId: string): void;
+    private _checkIsWidgetSupportedRole;
+}
+export declare const ActionBarContext: import("react").Context<ActionBarStore>;