fcr-ui-scene 3.7.5 → 3.7.7

package/lib/modules/share-screen/components/selection/index.css

@@ -31,6 +31,10 @@
   -webkit-app-region: no-drag;
 }
 
+.share-selection-window__share-content::--webkit-scrollbar {
+  display: none;
+}
+
 .share-selection-window__header {
   height: 46px;
 }

package/lib/modules/share-screen/store.base.js

@@ -108,6 +108,9 @@ var ShareScreenStoreBase = exports["default"] = /*#__PURE__*/function () {
     (0, _defineProperty2["default"])(this, "_dom", null);
     (0, _defineProperty2["default"])(this, "_asyncLock", false);
     (0, _defineProperty2["default"])(this, "_screenShareObserver", {
+      onPrepreScreenCapture: function onPrepreScreenCapture() {
+        _this.dialogProvider.setSharingDisplayBounds(_this.screenShareProvider.sharingDisplayBounds);
+      },
       onScreenShareStarted: function onScreenShareStarted() {
         (0, _mobx.runInAction)(function () {
           _this.isSharing = true;
@@ -117,6 +120,7 @@ var ShareScreenStoreBase = exports["default"] = /*#__PURE__*/function () {
         (0, _mobx.runInAction)(function () {
           _this.isSharing = false;
         });
+        _this.dialogProvider.setSharingDisplayBounds(null);
         if (reason === _struct.FcrUIScreenShareStopReason.STOPPED_BY_OTHER) {
           _this.messageProvider.showToast({
             type: 'info',
@@ -125,6 +129,9 @@ var ShareScreenStoreBase = exports["default"] = /*#__PURE__*/function () {
           _this._replaceShareConfirmDialog(operator);
         }
       },
+      onShareSourceReplaced: function onShareSourceReplaced() {
+        _this.dialogProvider.setSharingDisplayBounds(_this.screenShareProvider.sharingDisplayBounds);
+      },
       onScreenShareErrorOccurred: function onScreenShareErrorOccurred(code) {
         if (code === _struct.FcrUIScreenShareErrorCode.NETWORK_DISCONNECTED) {
           if (!_this.facilityProvider.isNetworkConnected) {
@@ -311,7 +318,7 @@ var ShareScreenStoreBase = exports["default"] = /*#__PURE__*/function () {
     key: "startShareScreen",
     value: function () {
       var _startShareScreen = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-        var params, captureType, videoSourceId;
+        var params, captureType, videoSourceId, _t;
         return _regenerator["default"].wrap(function (_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -373,15 +380,21 @@ var ShareScreenStoreBase = exports["default"] = /*#__PURE__*/function () {
               });
             case 6:
               this.dialogProvider.closeDialog(_constant.FcrUIDialogKey.SHARE_SCREEN_SELECTION);
+              _context2.next = 8;
+              break;
             case 7:
               _context2.prev = 7;
-              this._asyncLock = false;
-              return _context2.finish(7);
+              _t = _context2["catch"](2);
+              this.screenShareProvider.stopShare();
             case 8:
+              _context2.prev = 8;
+              this._asyncLock = false;
+              return _context2.finish(8);
+            case 9:
             case "end":
               return _context2.stop();
           }
-        }, _callee2, this, [[2,, 7, 8]]);
+        }, _callee2, this, [[2, 7, 8, 9]]);
       }));
       function startShareScreen() {
         return _startShareScreen.apply(this, arguments);

package/lib/modules/share-screen/store.d.ts

@@ -0,0 +1,148 @@
+import { FcrConnectionState, FcrMediaSourceState } from 'fcr-core';
+import { FcrScreenTrack } from 'fcr-core/lib/media-control/type';
+import { FcrUserInfo } from 'fcr-core/lib/type';
+import { FcrScreenCaptureType } from 'fcr-core/lib/type';
+import { AudioProcessingChannel } from 'agora-ui-foundation/lib/components/room-screen-share-state-bar/share-audio';
+import { FcrMainRoomControl } from 'fcr-core/lib/room-control/type';
+import { FcrUIPrivilegeProvider } from '../../providers/privilege-provider';
+import { FcrUIEventProvider } from '../../providers/event-provider';
+import { FcrUIDeviceProvider } from '../../providers/device-provider';
+import { FcrUIMessageProvider } from '../../providers/message-provider';
+import { FcrUIDialogProvider } from '../../providers/dialog-provider';
+import { CurrentShareBounds } from '../control-bar/types';
+import { FcrUIMemberSharedDataSource } from '../../shared-data-source/member-data';
+import { FcrUIRoomProvider } from '../../providers/room-provider';
+import { FcrUISharedConfigDataSource } from '../../shared-data-source/config';
+import { FcrUIScreenShareProvider } from '../../providers/screen-share-provider';
+import { FcrUIScreenShareSharedDataSource } from '../../shared-data-source/screen-share-data';
+import { FcrUIAnnotationProvider } from '../../providers/annotation-provider';
+import { FcrUIAbilityProvider } from '../../providers/ability-provider';
+import { FcrUISharedAnnotationSource } from '../../shared-data-source/annotation-data';
+import { FcrUIMultiDisplayProvider } from '../../providers/multi-display-provider';
+export default class ShareScreenStore {
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _disposers;
+    private _deviceProvider;
+    private _eventProvider;
+    private _messageProvider;
+    private _dialogProvider;
+    private _roomProvider;
+    private _securityStore;
+    private _userControl;
+    private _boardControl;
+    private _screenShareProvider;
+    private _sharedMemberDataSource;
+    private _sharedScreenShareSharedDataSource;
+    private _abilityProvider;
+    private _isOnline;
+    private _windowList;
+    private _displayList;
+    private _streamControl;
+    private _cardChooseBounds;
+    private _roomObserver;
+    private _uiEventObserver;
+    private _screenCaptureStateObserver;
+    private _boardObserver;
+    private _handleOnScreenCaptureStopped;
+    private _handleOnScreenCaptureStarted;
+    private _hasScreenSharePermission;
+    private _shareSelectionDialogId;
+    private _controlBarDialogId;
+    private _videoWindowDialogId;
+    private _annotationProvider;
+    private _sharedAnnotationDataSource;
+    accessor boardOwnerUser: FcrUserInfo | undefined;
+    get cardChooseBounds(): CurrentShareBounds;
+    get currentShareStreamId(): string | undefined;
+    get screenTrack(): FcrScreenTrack | null;
+    get currentShareType(): FcrScreenCaptureType;
+    get isCurrentOriginal(): boolean;
+    get localUser(): FcrUserInfo;
+    get localUserRole(): import("fcr-core").FcrUserRole;
+    get isHost(): boolean;
+    get supportEnumScreen(): boolean;
+    get appWindowList(): Promise<import("fcr-core/lib/imports").AgoraRtcWindowInfo[]>;
+    get displayList(): Promise<import("fcr-core/lib/imports").AgoraRtcDisplayInfo[]>;
+    get connectionState(): FcrConnectionState;
+    get localUserScreenSharingState(): FcrMediaSourceState;
+    get applicationCaptureSources(): import("fcr-core/lib/imports").AgoraRtcWindowInfo[];
+    get screenCaptureSources(): import("./types").FcrUIDisplayCaptureSource[];
+    get currentShareAudioProcessingChannel(): AudioProcessingChannel;
+    get currentSelectionId(): string;
+    get currentSelectionType(): FcrScreenCaptureType;
+    get shareWithAudio(): boolean;
+    get currentSelectionBounds(): CurrentShareBounds;
+    get shareLock(): boolean;
+    get currentShareId(): string;
+    get annotationHasStart(): boolean;
+    get allowAnnotationWrite(): boolean;
+    get screenShareWindowData(): import("../../type").FcrUIVideoWindowData | undefined;
+    get isZoomMaxmum(): boolean;
+    get isZoomMinimum(): boolean;
+    get isAspectRatioPreserved(): boolean;
+    get isCurrentScreenShareInSmoothType(): boolean;
+    get _screenShareInfoForLog(): string;
+    get allowAnnotationSelfWriteState(): boolean;
+    get isShowToolbar(): boolean;
+    get isAnnotationSupported(): boolean;
+    constructor({ roomControl, deviceProvider, privilegeProvider, messageProvider, dialogProvider, eventProvider, sharedMemberDataSource, roomProvider, sharedConfigDataSource, screenShareProvider, annotationProvider, sharedScreenShareSharedDataSource, abilityProvider, sharedAnnotationDataSource, multiDisplayProvider, }: {
+        roomControl: FcrMainRoomControl;
+        deviceProvider: FcrUIDeviceProvider;
+        privilegeProvider: FcrUIPrivilegeProvider;
+        messageProvider: FcrUIMessageProvider;
+        dialogProvider: FcrUIDialogProvider;
+        eventProvider: FcrUIEventProvider;
+        sharedMemberDataSource: FcrUIMemberSharedDataSource;
+        roomProvider: FcrUIRoomProvider;
+        sharedConfigDataSource: FcrUISharedConfigDataSource;
+        screenShareProvider: FcrUIScreenShareProvider;
+        annotationProvider: FcrUIAnnotationProvider;
+        sharedScreenShareSharedDataSource: FcrUIScreenShareSharedDataSource;
+        abilityProvider: FcrUIAbilityProvider;
+        sharedAnnotationDataSource: FcrUISharedAnnotationSource;
+        multiDisplayProvider: FcrUIMultiDisplayProvider;
+    });
+    toggleIsShowToolbar(): void;
+    handleChooseScreen: (id: string, type?: FcrScreenCaptureType) => void;
+    setShareWithAudioState(withAudio: boolean): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    fullContainer(): void;
+    setOriginScalc(): void;
+    setShareAudioProcessingChannel(currentShareAudioProcessingChannel: AudioProcessingChannel): void;
+    setCardChooseBounds(bounds: CurrentShareBounds): void;
+    handlerBoardShareStop(): void;
+    release(): void;
+    openRelaunchTipsDialog(): void;
+    startRenderSharePreview(dom: HTMLElement): void;
+    stopRenderSharePreview(screenTrack?: FcrScreenTrack | null | undefined): void;
+    handleStopShare(): void;
+    handleStopShareByExitRoom(): void;
+    participantShareCanWeAnnotation(): boolean;
+    prepareShareScreen(): Promise<void>;
+    handleStartShare(id: string, type: FcrScreenCaptureType, withAudio: boolean, audioProcessingChannel: AudioProcessingChannel | undefined, bounds: CurrentShareBounds): Promise<void>;
+    private _openShareScreenSelection;
+    private _closeShareScreenSelection;
+    private _openVideoWindowDialog;
+    private _closeControlBar;
+    private _closeVideoWindowDialog;
+    private _handleOnScreenShareReplaceBegin;
+    private _handleReplaceScreen;
+    private _closeShareScreenComps;
+    private _addEventListeners;
+    private _removeEventListeners;
+    private _handleOnline;
+    private _handleOffline;
+    private _onUiEvent;
+    private _showToast;
+    private _validateWindow;
+    private _validateDisplay;
+    private _validateShareStart;
+    private _initControlbar;
+    private _handleBrowserShow;
+    private _hendleBrowserHide;
+    private _handleOnScreenShareSeize;
+    handleToggleScreenShareWithAudio(withAudio: boolean): void;
+    toggleShareWithScenarioType(isCurrentSmoothType: boolean): void;
+}
+export declare const StoreContext: import("react").Context<ShareScreenStore>;

package/lib/modules/share-screen/store.electron.js

@@ -170,7 +170,10 @@ var ElectronShareScreenStore = exports["default"] = /*#__PURE__*/function (_Shar
       } else {
         controlBarWindow = this._windowProvider.getWindowById(_constant.FcrUIDialogKey.SHARE_SCREEN_CONTROL_BAR);
       }
-      controlBarWindow.setBounds(sharingDisplayBounds);
+
+      // 不在这里控制，在control bar模块中控制
+      // controlBarWindow.setBounds(sharingDisplayBounds);
+
       if (!isMultiDisplayActive) {
         var videoWindow = this._windowProvider.getWindowById(_constant.FcrUIDialogKey.VIDEO_WINDOW);
         (0, _videoWindow.setVideoWindowDialogPosition)(sharingDisplayBounds, videoWindow);
@@ -179,7 +182,7 @@ var ElectronShareScreenStore = exports["default"] = /*#__PURE__*/function (_Shar
   }, {
     key: "_interceptDialogClose",
     value: function _interceptDialogClose(dialogKey) {
-      if (dialogKey === _constant.FcrUIDialogKey.SHARE_SCREEN_CONTROL_BAR || dialogKey === _constant.FcrUIDialogKey.VIDEO_WINDOW) {
+      if (dialogKey === _constant.FcrUIDialogKey.SHARE_SCREEN_CONTROL_BAR) {
         return this._isSharing;
       }
       return false;