fcr-ui-scene 3.7.1 → 3.7.3

package/lib/modules/participant/components/participants/components/render-user/index.js

@@ -9,12 +9,14 @@ var _mobxReact = require("mobx-react");
 var _attendee = require("./components/attendee");
 var _userAction = require("./components/user-action");
 var _jsxRuntime = require("react/jsx-runtime");
-var RenderUser = (0, _mobxReact.observer)(function (_ref) {
-  var user = _ref.user;
+var RenderUser = (0, _mobxReact.observer)(function (props) {
+  var user = props.user,
+    isLocalCameraInSecondaryWindow = props.isLocalCameraInSecondaryWindow;
   return /*#__PURE__*/(0, _jsxRuntime.jsx)(_attendee.ParticipantAttendee, {
     user: user,
     children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_userAction.UserActions, {
-      user: user
+      user: user,
+      isLocalCameraInSecondaryWindow: isLocalCameraInSecondaryWindow
     })
   });
 });

package/lib/modules/participant/components/participants/index.js

@@ -34,7 +34,8 @@ var ParticipantsContainer = (0, _mobxReact.observer)(function () {
     isLocalUserHost = _useContext.isLocalUserHost,
     openMuteAllDialog = _useContext.openMuteAllDialog,
     handlerRoomControlAction = _useContext.handlerRoomControlAction,
-    hasInvite = _useContext.hasInvite;
+    hasInvite = _useContext.hasInvite,
+    isLocalCameraInSecondaryWindow = _useContext.isLocalCameraInSecondaryWindow;
   var dialogStore = (0, _react.useContext)(_store.StoreContext);
   var handlerRoomControlClick = function handlerRoomControlClick(action, userId) {
     if (action === _constant.FcrUIRoomControlType.MUTE_ALL_AUDIO) {
@@ -59,9 +60,11 @@ var ParticipantsContainer = (0, _mobxReact.observer)(function () {
       hasInvite: hasInvite,
       hasPinnedStream: hasPinnedStream,
       toggleParticipantAction: handlerUserAction,
+      isLocalCameraInSecondaryWindow: isLocalCameraInSecondaryWindow,
       userRenderer: function userRenderer(user) {
         return /*#__PURE__*/(0, _jsxRuntime.jsx)(_renderUser["default"], {
-          user: user
+          user: user,
+          isLocalCameraInSecondaryWindow: isLocalCameraInSecondaryWindow
         });
       },
       footer: /*#__PURE__*/(0, _jsxRuntime.jsx)(_footer["default"], {

package/lib/modules/participant/components/participants/types.d.ts

@@ -10,6 +10,7 @@ export interface ParticipantProps {
     searchText?: string;
     onInvite?: () => void;
     hasPinnedStream: boolean;
+    isLocalCameraInSecondaryWindow: boolean;
     hasInvite: boolean;
 }
 export interface User {
@@ -66,6 +67,7 @@ export interface ParticipantsMoreActionsProps {
     onParticipantsButtonClick: (action: ParticipantActionType, userId: string) => void;
     hasPinnedStream: boolean;
     hideActions: string[];
+    isLocalCameraInSecondaryWindow: boolean;
 }
 export interface IFcrParticipantItemProps {
     user: User;
@@ -94,4 +96,5 @@ export interface ParticipantsFooterParticipantProps {
 }
 export interface UserActionsPropsType {
     user: User;
+    isLocalCameraInSecondaryWindow: boolean;
 }

package/lib/modules/participant/index.d.ts

@@ -23,6 +23,7 @@ import { FcrUIAbilityProviderImpl } from '../../providers/ability-provider';
 import { FcrUIMessageProvider } from '../../providers/message-provider';
 import { FcrUISecuritySharedDataSource } from '../../shared-data-source/security-data';
 import { FcrUIScreenShareSharedDataSource } from '../../shared-data-source/screen-share-data';
+import { FcrUIMultiDisplayProvider } from '../../providers/multi-display-provider';
 export declare class ParticipantUIModule extends UIModule {
     private _store;
     deviceStreamProvider?: FcrUIDeviceStreamProvider;
@@ -48,6 +49,7 @@ export declare class ParticipantUIModule extends UIModule {
     abilityProvider?: FcrUIAbilityProviderImpl;
     sharedSecuritySharedDataSource?: FcrUISecuritySharedDataSource;
     sharedScreenShareSharedDataSource?: FcrUIScreenShareSharedDataSource;
+    multiDisplayProvider?: FcrUIMultiDisplayProvider;
     onNodeWillActive(): void;
     onNodeWillInactive(): void;
     getComponent(): import("react/jsx-runtime").JSX.Element;

package/lib/modules/participant/index.js

@@ -85,7 +85,8 @@ var ParticipantUIModule = exports.ParticipantUIModule = /*#__PURE__*/function (_
         abilityProvider: this.abilityProvider,
         messageProvider: this.messageProvider,
         sharedSecuritySharedDataSource: this.sharedSecuritySharedDataSource,
-        sharedScreenShareSharedDataSource: this.sharedScreenShareSharedDataSource
+        sharedScreenShareSharedDataSource: this.sharedScreenShareSharedDataSource,
+        multiDisplayProvider: this.multiDisplayProvider
       });
     }
   }, {

package/lib/modules/participant/store.d.ts

@@ -30,6 +30,7 @@ import { FcrUIAbilityProviderImpl } from '../../providers/ability-provider';
 import { FcrUISecuritySharedDataSource } from '../../shared-data-source/security-data';
 import { FcrUIScreenShareSharedDataSource } from '../../shared-data-source/screen-share-data';
 import { User } from './components/participants/types';
+import { FcrUIMultiDisplayProvider } from '../../providers/multi-display-provider';
 export default class ParticipantStore {
     protected logger: import("agora-foundation/lib/logger").Logger;
     private _roomStore;
@@ -59,6 +60,7 @@ export default class ParticipantStore {
     private _sharedMemberDataSource;
     private _sharedChatDataSource;
     private _sharedScreenShareSharedDataSource;
+    private _multiDisplayProvider;
     private _peerSessionObserver;
     private _dialogProvider;
     private _abilityProvider;
@@ -115,10 +117,11 @@ export default class ParticipantStore {
     get isInterpreterEnabled(): boolean;
     get waitingRoomUserCount(): number;
     get isNewWaitingRoomUserEnter(): boolean;
+    get isLocalCameraInSecondaryWindow(): boolean;
     get isHostKeyEnabled(): boolean;
     get hasInvite(): boolean;
     get checkedStateMap(): import("../../shared-data-source/security-data").FcrSecurityCheckedStateType;
-    constructor({ roomControl, securityStore, uiEventStore, deviceStore, deviceStreamStore, roomStore, sessionProvider, sharedSpeakerSpotlightDataSource, sharedPinDataSource, sharedLayoutDataSource, sharedInterpreterDataSource, sharedSettingDataSource, sharedWaitingRoomDataSource, chatProvider, sharedVideoWindowDataSource, sharedMemberDataSource, sharedChatDataSource, dialogProvider, abilityProvider, messageProvider, sharedSecuritySharedDataSource, sharedScreenShareSharedDataSource, }: {
+    constructor({ roomControl, securityStore, uiEventStore, deviceStore, deviceStreamStore, roomStore, sessionProvider, sharedSpeakerSpotlightDataSource, sharedPinDataSource, sharedLayoutDataSource, sharedInterpreterDataSource, sharedSettingDataSource, sharedWaitingRoomDataSource, chatProvider, sharedVideoWindowDataSource, sharedMemberDataSource, sharedChatDataSource, dialogProvider, abilityProvider, messageProvider, sharedSecuritySharedDataSource, sharedScreenShareSharedDataSource, multiDisplayProvider, }: {
         roomControl: FcrMainRoomControl;
         securityStore: FcrUIPrivilegeProvider;
         uiEventStore: FcrUIEventProvider;
@@ -141,6 +144,7 @@ export default class ParticipantStore {
         messageProvider: FcrUIMessageProvider;
         sharedSecuritySharedDataSource: FcrUISecuritySharedDataSource;
         sharedScreenShareSharedDataSource: FcrUIScreenShareSharedDataSource;
+        multiDisplayProvider: FcrUIMultiDisplayProvider;
     });
     release(): void;
     allowedOperations: (userId: string, userRole: FcrUserRole) => string[];

package/lib/modules/participant/store.js

@@ -174,7 +174,8 @@ var ParticipantStore = exports["default"] = /*#__PURE__*/function () {
       abilityProvider = _ref2.abilityProvider,
       messageProvider = _ref2.messageProvider,
       sharedSecuritySharedDataSource = _ref2.sharedSecuritySharedDataSource,
-      sharedScreenShareSharedDataSource = _ref2.sharedScreenShareSharedDataSource;
+      sharedScreenShareSharedDataSource = _ref2.sharedScreenShareSharedDataSource,
+      multiDisplayProvider = _ref2.multiDisplayProvider;
     (0, _classCallCheck2["default"])(this, ParticipantStore);
     (0, _defineProperty2["default"])(this, _ref, (_initProto(this), (0, _logger.createLogger)({
       prefix: 'ParticipantStore'
@@ -368,6 +369,7 @@ var ParticipantStore = exports["default"] = /*#__PURE__*/function () {
     this._sharedChatDataSource = sharedChatDataSource;
     this._sharedSecuritySharedDataSource = sharedSecuritySharedDataSource;
     this._sharedScreenShareSharedDataSource = sharedScreenShareSharedDataSource;
+    this._multiDisplayProvider = multiDisplayProvider;
     this.allowUnmute = this._securityStore.allowUnmuteSelfAudio();
     this.joinWithMuteAudio = this._securityStore.allowJoinWithMuteAudio();
     this._uiEventStore.addObserver(this._eventObserver);
@@ -657,6 +659,11 @@ var ParticipantStore = exports["default"] = /*#__PURE__*/function () {
     get: function get() {
       return this._sharedWaitingRoomDataSource.unReadState;
     }
+  }, {
+    key: "isLocalCameraInSecondaryWindow",
+    get: function get() {
+      return this._multiDisplayProvider.isLocalCameraInSecondaryWindow;
+    }
   }, {
     key: "isHostKeyEnabled",
     get: function get() {

package/lib/modules/secondary-window/index.d.ts

@@ -0,0 +1,49 @@
+import { UIModule } from '../../base';
+import { FcrUIEventProvider } from '../../providers/event-provider';
+import { FcrUIMultiDisplayProvider } from '../../providers/multi-display-provider';
+import { FcrUIMainWindowRenderer, FcrUIMainWindowRendererObserver } from './type';
+import { FcrUIVideoWindowDataSource } from '../../shared-data-source/video-window';
+import { FcrUIWhiteboardProvider } from '../../providers/whiteboard-provider';
+import { FcrUserInfo } from 'fcr-core/lib/type';
+import { FcrUIScreenShareSharedDataSource } from '../../shared-data-source/screen-share-data';
+import { FcrUIMemberSharedDataSource } from '../../shared-data-source/member-data';
+import { FcrUISharedWhiteboardDataSource } from '../../shared-data-source/whiteboard-data';
+import { ShareScreenUIModule } from '../share-screen';
+import { FcrUIAnnotationProvider } from '../../providers/annotation-provider';
+import { FcrUISharedAnnotationSource } from '../../shared-data-source/annotation-data';
+import { FcrUIPrivilegeProvider } from '../../providers/privilege-provider';
+import { FcrUIRoomProvider } from '../../providers/room-provider';
+import { FcrUIAbilityProviderImpl } from '../../providers/ability-provider';
+import { FcrUIDialogProvider } from '../../providers/dialog-provider';
+export declare class FcrUISecondaryWindowModule extends UIModule {
+    private _store?;
+    private _leaveMeetingStore?;
+    multiDisplayProvider?: FcrUIMultiDisplayProvider;
+    sharedVideoWindowDataSource?: FcrUIVideoWindowDataSource;
+    eventProvider?: FcrUIEventProvider;
+    whiteboardProvider?: FcrUIWhiteboardProvider;
+    privilegeProvider?: FcrUIPrivilegeProvider;
+    roomProvider?: FcrUIRoomProvider;
+    abilityProvider?: FcrUIAbilityProviderImpl;
+    dialogProvider?: FcrUIDialogProvider;
+    sharedScreenShareSharedDataSource?: FcrUIScreenShareSharedDataSource;
+    sharedMemberDataSource?: FcrUIMemberSharedDataSource;
+    sharedWhiteboardDataSource?: FcrUISharedWhiteboardDataSource;
+    annotationProvider?: FcrUIAnnotationProvider;
+    sharedAnnotationDataSource?: FcrUISharedAnnotationSource;
+    onNodeWillActive(): void;
+    onNodeWillInactive(): void;
+    component(shareScreenModule: ShareScreenUIModule): import("react/jsx-runtime").JSX.Element;
+}
+export declare class FcrUIMainWindowRendererImpl implements FcrUIMainWindowRenderer {
+    private _observers;
+    private _ownerUser;
+    private _backgroundColor;
+    private _hasWriteBoardPermission;
+    get ownerUser(): FcrUserInfo | undefined;
+    get backgroundColor(): string;
+    get hasWriteBoardPermission(): boolean;
+    notifyObservers(event: keyof FcrUIMainWindowRendererObserver, args: any): void;
+    addObserver(observer: FcrUIMainWindowRendererObserver): void;
+    removeObserver(observer: FcrUIMainWindowRendererObserver): void;
+}

package/lib/modules/secondary-window/index.js

@@ -0,0 +1,108 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUISecondaryWindowModule = exports.FcrUIMainWindowRendererImpl = void 0;
+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 _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 _store = require("./store");
+var _view = require("./view");
+var _imports = require("fcr-core/lib/imports");
+var _store2 = require("../components/leave-meeting/store");
+var _jsxRuntime = require("react/jsx-runtime");
+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 FcrUISecondaryWindowModule = exports.FcrUISecondaryWindowModule = /*#__PURE__*/function (_UIModule) {
+  function FcrUISecondaryWindowModule() {
+    (0, _classCallCheck2["default"])(this, FcrUISecondaryWindowModule);
+    return _callSuper(this, FcrUISecondaryWindowModule, arguments);
+  }
+  (0, _inherits2["default"])(FcrUISecondaryWindowModule, _UIModule);
+  return (0, _createClass2["default"])(FcrUISecondaryWindowModule, [{
+    key: "onNodeWillActive",
+    value: function onNodeWillActive() {
+      this._store = new _store.SecondaryWindowStore(this.multiDisplayProvider, this.sharedVideoWindowDataSource, this.eventProvider, this.sharedScreenShareSharedDataSource, this.sharedMemberDataSource, this.sharedWhiteboardDataSource, this.sharedAnnotationDataSource, this.annotationProvider);
+      this._leaveMeetingStore = new _store2.LeaveMeetingStore(this.privilegeProvider, this.roomProvider, this.roomProvider.currentRoomControl, this.sharedMemberDataSource, this.abilityProvider, this.dialogProvider);
+    }
+  }, {
+    key: "onNodeWillInactive",
+    value: function onNodeWillInactive() {
+      var _this$_store;
+      (_this$_store = this._store) === null || _this$_store === void 0 || _this$_store.release();
+    }
+  }, {
+    key: "component",
+    value: function component(shareScreenModule) {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_store.SecondaryWindowStoreContext.Provider, {
+        value: this._store,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_store2.LeaveMeetingStoreContext.Provider, {
+          value: this._leaveMeetingStore,
+          children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_view.SubWindowView, {
+            renderScreenShareControl: function renderScreenShareControl(secondaryWindowProprs) {
+              return shareScreenModule.getControlComponent(secondaryWindowProprs);
+            }
+          })
+        })
+      });
+    }
+  }]);
+}(_base.UIModule);
+var FcrUIMainWindowRendererImpl = exports.FcrUIMainWindowRendererImpl = /*#__PURE__*/function () {
+  function FcrUIMainWindowRendererImpl() {
+    (0, _classCallCheck2["default"])(this, FcrUIMainWindowRendererImpl);
+    (0, _defineProperty2["default"])(this, "_observers", new _imports.AgoraObservable());
+    (0, _defineProperty2["default"])(this, "_backgroundColor", '#ffffff');
+    (0, _defineProperty2["default"])(this, "_hasWriteBoardPermission", false);
+  }
+  return (0, _createClass2["default"])(FcrUIMainWindowRendererImpl, [{
+    key: "ownerUser",
+    get: function get() {
+      return this._ownerUser;
+    }
+  }, {
+    key: "backgroundColor",
+    get: function get() {
+      return this._backgroundColor;
+    }
+  }, {
+    key: "hasWriteBoardPermission",
+    get: function get() {
+      return this._hasWriteBoardPermission;
+    }
+  }, {
+    key: "notifyObservers",
+    value: function notifyObservers(event, args) {
+      switch (event) {
+        case 'onSharingUserUpdated':
+          this._ownerUser = args;
+          break;
+        case 'onBackgroundColorUpdated':
+          this._backgroundColor = args;
+          break;
+        case 'onPermissionUpdated':
+          this._hasWriteBoardPermission = args;
+          break;
+      }
+      this._observers.notifyObservers(event, args);
+    }
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._observers.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._observers.removeObserver(observer);
+    }
+  }]);
+}();

package/lib/modules/secondary-window/store.d.ts

@@ -0,0 +1,76 @@
+import { FcrUIMultiDisplayProvider } from '../../providers/multi-display-provider';
+import { VideoWindowDataReturn, WhiteboardToolAction } from './type';
+import { FcrUIEventProvider } from '../../providers/event-provider';
+import { FcrUIVideoWindowDataSource } from '../../shared-data-source/video-window';
+import { FcrUIScreenShareSharedDataSource } from '../../shared-data-source/screen-share-data';
+import { FcrUIMemberSharedDataSource } from '../../shared-data-source/member-data';
+import { FcrUISharedWhiteboardDataSource } from '../../shared-data-source/whiteboard-data';
+import { FcrBoardShape, FcrBoardToolType } from 'fcr-core/lib/room-control/whiteboard-control/enums';
+import { WhiteboardThemeType } from '../whiteboard/type';
+import { FcrUISharedAnnotationSource } from '../../shared-data-source/annotation-data';
+import { FcrUIAnnotationProvider } from '../../providers/annotation-provider';
+export declare class SecondaryWindowStore {
+    private _multiDisplayProvider;
+    private _videoWindowDataSource;
+    private _eventProvider;
+    private _sharedScreenShareDataSource;
+    private _memberSharedDataSource;
+    private _sharedWhiteboardDataSource;
+    private _sharedAnnotationDataSource;
+    private _annotationProvider;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _observable;
+    private _dialogId;
+    private _disposers;
+    private get _subWindowDialog();
+    private _prevFullScalc;
+    private _screenShareSpeakerViewSize;
+    private _maxScalcValue;
+    private _minScalcValue;
+    private _diffScalcValue;
+    private accessor _screenShareScalcValue;
+    accessor isSharingWhiteboard: boolean;
+    get secondaryWindowContentType(): "hidden" | "speaker" | "gallery" | "local-camera" | "remote-camera" | "sharing-screen" | "sharing-screen-with-annotation" | "sharing-whiteboard";
+    get videoWindowData(): VideoWindowDataReturn<typeof this.secondaryWindowContentType>;
+    get isCurrentOriginal(): boolean;
+    get isZoomMaxmum(): boolean;
+    get isZoomMinimum(): boolean;
+    get isAspectRatioPreserved(): boolean;
+    get scalValue(): number;
+    get currentUser(): import("fcr-core/lib/type").FcrUserInfo;
+    get ownerUser(): import("fcr-core/lib/type").FcrUserInfo | undefined;
+    get isHost(): boolean;
+    get canWriteBoard(): boolean;
+    get toolbarState(): import("../components/toolbar/types").FcrToolbarState;
+    get currentTheme(): WhiteboardThemeType;
+    get connectionState(): import("fcr-core").FcrConnectionState;
+    get showLoading(): boolean;
+    get joinSuccess(): boolean;
+    get isScreenShare(): boolean;
+    get isBoardShare(): boolean;
+    get annotationHasStart(): boolean;
+    get isShowToolbar(): boolean;
+    constructor(_multiDisplayProvider: FcrUIMultiDisplayProvider, _videoWindowDataSource: FcrUIVideoWindowDataSource, _eventProvider: FcrUIEventProvider, _sharedScreenShareDataSource: FcrUIScreenShareSharedDataSource, _memberSharedDataSource: FcrUIMemberSharedDataSource, _sharedWhiteboardDataSource: FcrUISharedWhiteboardDataSource, _sharedAnnotationDataSource: FcrUISharedAnnotationSource, _annotationProvider: FcrUIAnnotationProvider);
+    getContent(): void;
+    handleIframeLoad(iframe: HTMLIFrameElement): void;
+    zoomOut(): void;
+    zoomIn(): void;
+    fullContainer(): void;
+    setScaleValue(scale: number): void;
+    setOriginScalc(): void;
+    setSpeakerViewSize(width: number, height: number): void;
+    setWhiteboardTool(tool: {
+        action: WhiteboardToolAction;
+        tool: FcrBoardToolType | FcrBoardShape | string | number;
+    }): void;
+    saveWhiteboardDraft(): void;
+    setProgress(progress: number): void;
+    setTheme(theme: WhiteboardThemeType): void;
+    setControlEnable(enable: boolean): void;
+    setShowLoading(show: boolean): void;
+    setCommonColors(colors: string[]): void;
+    log(message: string): void;
+    release(): void;
+    private _handleContentDistributionUpdated;
+}
+export declare const SecondaryWindowStoreContext: import("react").Context<SecondaryWindowStore>;