fcr-ui-scene 3.8.1 → 3.9.0-alpha

package/lib-es/creator/provider-initializer.electron.js

@@ -0,0 +1,382 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { FcrUIObjectKeys } from '../object-manager';
+import { FcrUIDeviceProviderImpl } from '../providers/device-provider';
+import { FcrUIElectronDialogProviderImpl } from '../providers/dialog/provider.electron';
+import { FcrUIEventProviderImpl } from '../providers/event-provider';
+import { FcrUILocalStorageProviderImpl } from '../providers/local-storage-provider';
+import { FcrUIMessageProviderImpl } from '../providers/message/provider';
+import { FcrUIMonitorProviderImpl } from '../providers/monitor-provider';
+import { FcrUIWindowProviderImpl } from '../providers/window/provider';
+import { FcrUISharedConfigDataSourceImpl } from '../shared-data/config';
+import { FcrUISharedLayoutDataSourceImpl } from '../shared-data/layout-data';
+import { FcrUISharedSettingDataSourceImpl } from '../shared-data/setting';
+import { FcrCoreEngine } from 'fcr-core';
+import { FcrUIAbilityProviderImpl } from '../providers/ability-provider';
+import { FcrUIApplistProviderImpl } from '../providers/app-list-provider';
+import { FcrUIChatProviderImpl } from '../providers/chat-provider';
+import { FcrUIDevicePrivilegeProviderImpl } from '../providers/device-privilege-provider';
+import { FcrUIDeviceStreamProviderImpl } from '../providers/device-stream-provider';
+import { FcrUIInterpreterProviderImpl } from '../providers/interpreter-provider';
+import { FcrUIMultiDisplayProviderImpl } from '../providers/multi-display-provider';
+import { FcrUIPhoneAudioConnectorProviderImpl } from '../providers/phone-audio-provider';
+import { FcrUIRemoteVideoRenderProviderImpl, FcrUIMainLocalVideoRenderProviderImpl, FcrUIWaitLocalVideoRenderProviderImpl } from '../providers/renderer-provider';
+import { FcrUIMainRoomControlProviderImpl, FcrUICurrentRoomControlProviderImpl, FcrUIWaitingRoomControlProviderImpl } from '../providers/room-provider/room-provider';
+import { FcrUISessionProviderImpl } from '../providers/session-provider';
+import { FcrUIWidgetProviderImpl } from '../providers/widget-provider';
+import { FcrUISharedApplistSourceImpl } from '../shared-data/app-list-data';
+import { FcrUISharedChatDataSourceImpl } from '../shared-data/chat-data';
+import { FcrUISharedDevicePrivilegeDataSourceImpl } from '../shared-data/device-privilege-data';
+import { FcrUISharedInterpreterDataSourceImpl } from '../shared-data/interpreter';
+import { FcrUIMeetingTimeSharedDataSourceImpl } from '../shared-data/meeting-time';
+import { FcrUISharedMemberDataSourceImpl } from '../shared-data/member-data';
+import { FcrUISecurityDataSourceImpl } from '../shared-data/security-data';
+import { FcrUIVideoWindowDataSourceImpl } from '../shared-data/video-window';
+import { FcrUISharedWaitingRoomDataSourceImpl } from '../shared-data/waiting-room';
+import { FcrUISharedConfirmDataSourceImpl } from '../shared-data/confirm-data';
+import { FcrUIPrivilegeProviderImpl } from '../providers/privilege-provider';
+import { FcrUIElectronUserSettingStorageProviderImpl } from '../providers/setting-storage/provider.electron';
+import { FcrUIElectronFacilityProviderImpl } from '../providers/facility/provider.electron';
+import { FcrUIRendererWrapper } from '../utilities/renderer';
+import { FcrUIScreenShareProviderImpl } from '../providers/screen-share/provider.electron';
+import { FcrUIBoardShareProviderImpl } from '../providers/board-share/provider.electron';
+import { FcrUIMainWindowRendererImpl } from '../modules/secondary-window';
+import { FcrUISharedScreenShareDataSourceImpl } from '../shared-data/screen-share';
+import { FcrUISharedSpeakerSpotlightDataSourceImpl } from '../shared-data/speaker-spotlight';
+import { FcrUISharedPinDataSourceImpl } from '../shared-data/pin-data';
+import { createLogger } from '../utilities/logger';
+import { FcrUIMouseDetectProviderImpl } from '../providers/mouse-detect/provider';
+import { FcrUISharedWidgetDataSourceImpl } from '../shared-data/widget-data';
+import { FcrUISttProviderImpl } from '../providers/stt-provider/stt-provider';
+import { FcrUISharedSttSettingDataSourceImpl } from '../shared-data/stt-setting.ts';
+import { FcrUIAnnotationProviderImpl } from '../providers/annotation/provider.electron';
+import { FcrUISharedUserAudioVolumeDataSourceImpl } from '../shared-data/user-audio-volume';
+import { FcrUIUserAudioVolumeProviderImpl } from '../providers/user-audio-volume-provider';
+export var FcrUIElectronProviderInitializer = /*#__PURE__*/function () {
+  function FcrUIElectronProviderInitializer(args) {
+    _classCallCheck(this, FcrUIElectronProviderInitializer);
+    _defineProperty(this, "logger", createLogger({
+      prefix: 'FcrUIElectronProviderInitializer'
+    }));
+    this._objectManager = args.objectManager;
+    this._config = args.config;
+  }
+  return _createClass(FcrUIElectronProviderInitializer, [{
+    key: "onCreatorInitialize",
+    value: function onCreatorInitialize(engineConfig) {
+      // initialize all providers and shared data sources
+      var objectManager = this._objectManager;
+      var fcrUIMainWindowRenderer = new FcrUIMainWindowRendererImpl();
+
+      // @ts-ignore
+      window.FcrUIMainWindowRenderer = fcrUIMainWindowRenderer;
+      var engine = new FcrCoreEngine(engineConfig);
+      this._objectManager.setObject(FcrUIObjectKeys.CORE_ENGINE, engine);
+      var renderer = new FcrUIRendererWrapper();
+      objectManager.setObject(FcrUIObjectKeys.RENDERER_WRAPPER, renderer);
+      var localStorageProvider = new FcrUILocalStorageProviderImpl();
+      objectManager.setObject(FcrUIObjectKeys.P_LOCAL_STORAGE_PROVIDER, localStorageProvider);
+      var facilityProvider = new FcrUIElectronFacilityProviderImpl({
+        objectManager: objectManager
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_FACILITY_PROVIDER, facilityProvider);
+      var userSettingStorageProvider = new FcrUIElectronUserSettingStorageProviderImpl({
+        renderer: renderer
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_USER_SETTING_STORAGE_PROVIDER, userSettingStorageProvider);
+      var sharedSettingDataSource = new FcrUISharedSettingDataSourceImpl(this._config, userSettingStorageProvider);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_SETTING_DATA_SOURCE, sharedSettingDataSource);
+      var windowProvider = new FcrUIWindowProviderImpl({
+        renderer: renderer
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_WINDOW_PROVIDER, windowProvider);
+      var mouseDetectProvider = new FcrUIMouseDetectProviderImpl(objectManager);
+      objectManager.setObject(FcrUIObjectKeys.P_MOUSE_DETECT_PROVIDER, mouseDetectProvider);
+      var eventProvider = new FcrUIEventProviderImpl();
+      objectManager.setObject(FcrUIObjectKeys.P_EVENT_PROVIDER, eventProvider);
+      var messageProvider = new FcrUIMessageProviderImpl();
+      objectManager.setObject(FcrUIObjectKeys.P_MESSAGE_PROVIDER, messageProvider);
+      var sharedConfirmDataSource = new FcrUISharedConfirmDataSourceImpl();
+      this._objectManager.setObject(FcrUIObjectKeys.S_SHARED_CONFIRM_DATA_SOURCE, sharedConfirmDataSource);
+      var dialogProvider = new FcrUIElectronDialogProviderImpl({
+        windowProvider: windowProvider,
+        renderer: renderer
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_DIALOG_PROVIDER, dialogProvider);
+      var deviceProvider = new FcrUIDeviceProviderImpl(renderer, facilityProvider, messageProvider, engine.getDesktopMediaControl(), sharedSettingDataSource, dialogProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_DEVICE_PROVIDER, deviceProvider);
+      var sharedConfigDataSource = new FcrUISharedConfigDataSourceImpl({
+        creatorConfig: this._config
+      });
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_CONFIG_DATA_SOURCE, sharedConfigDataSource);
+      var monitorProvider = new FcrUIMonitorProviderImpl(engine.getMonitorControl());
+      objectManager.setObject(FcrUIObjectKeys.P_MONITOR_PROVIDER, monitorProvider);
+      var sharedWidgetDataSource = new FcrUISharedWidgetDataSourceImpl();
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_WIDGET_DATA_SOURCE, sharedWidgetDataSource);
+    }
+  }, {
+    key: "onCreatorRelease",
+    value: function onCreatorRelease() {
+      var objectManager = this._objectManager;
+      objectManager.deleteObject(FcrUIObjectKeys.RENDERER_WRAPPER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_MOUSE_DETECT_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_LOCAL_STORAGE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_FACILITY_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_USER_SETTING_STORAGE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_CONFIG_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_MONITOR_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_WINDOW_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_EVENT_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_MESSAGE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_DIALOG_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_DEVICE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_SETTING_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.CORE_ENGINE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_CONFIRM_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_WIDGET_DATA_SOURCE);
+      if (objectManager.size() > 0) {
+        this.logger.error("remaing objects: ".concat(objectManager.keys()));
+      } else {
+        this.logger.info('all objects released');
+      }
+    }
+  }, {
+    key: "onMainSceneInitialize",
+    value: function onMainSceneInitialize() {
+      var objectManager = this._objectManager;
+      var renderer = objectManager.getObject(FcrUIObjectKeys.RENDERER_WRAPPER);
+      var roomProvider = objectManager.getObject(FcrUIObjectKeys.P_ROOM_PROVIDER);
+      var deviceProvider = objectManager.getObject(FcrUIObjectKeys.P_DEVICE_PROVIDER);
+      var eventProvider = objectManager.getObject(FcrUIObjectKeys.P_EVENT_PROVIDER);
+      var engine = objectManager.getObject(FcrUIObjectKeys.CORE_ENGINE);
+      var sharedSettingDataSource = objectManager.getObject(FcrUIObjectKeys.S_SHARED_SETTING_DATA_SOURCE);
+      var messageProvider = objectManager.getObject(FcrUIObjectKeys.P_MESSAGE_PROVIDER);
+      var dialogProvider = objectManager.getObject(FcrUIObjectKeys.P_DIALOG_PROVIDER);
+      var sharedWidgetDataSource = objectManager.getObject(FcrUIObjectKeys.S_SHARED_WIDGET_DATA_SOURCE);
+      var windowProvider = objectManager.getObject(FcrUIObjectKeys.P_WINDOW_PROVIDER);
+      var sharedScreenShareDataSource = new FcrUISharedScreenShareDataSourceImpl();
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_SCREEN_SHARE_DATA_SOURCE, sharedScreenShareDataSource);
+      var sharedConfigDataSource = objectManager.getObject(FcrUIObjectKeys.S_SHARED_CONFIG_DATA_SOURCE);
+      var sharedLayoutDataSource = new FcrUISharedLayoutDataSourceImpl(sharedConfigDataSource);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_LAYOUT_DATA_SOURCE, sharedLayoutDataSource);
+      var mainRoomControl = roomProvider.currentRoomControl;
+      var sharingControl = mainRoomControl.getSharingControl();
+      var streamControl = mainRoomControl.getStreamControl();
+      var userControl = mainRoomControl.getUserControl();
+      var privilegeControl = mainRoomControl.getPrivilegeControl();
+      var interpreterControl = mainRoomControl.getInterpreterControl();
+      var abilityControl = mainRoomControl.getAbilityControl();
+      var abilityProvider = new FcrUIAbilityProviderImpl(abilityControl);
+      objectManager.setObject(FcrUIObjectKeys.P_ABILITY_PROVIDER, abilityProvider);
+      var devicePrivilegeProvider = new FcrUIDevicePrivilegeProviderImpl(privilegeControl, streamControl, userControl, deviceProvider, messageProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_DEVICE_PRIVILEGE_PROVIDER, devicePrivilegeProvider);
+      var remoteVideoRenderProvider = new FcrUIRemoteVideoRenderProviderImpl(mainRoomControl.getStreamControl());
+      objectManager.setObject(FcrUIObjectKeys.P_REMOTE_VIDEO_RENDER_PROVIDER, remoteVideoRenderProvider);
+      var sharedInterpreterDataSource = new FcrUISharedInterpreterDataSourceImpl(mainRoomControl.getInterpreterControl(), userControl);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_INTERPRETER_DATA_SOURCE, sharedInterpreterDataSource);
+      var mainRoomControlProvider = new FcrUIMainRoomControlProviderImpl(mainRoomControl, eventProvider, messageProvider, dialogProvider, sharedInterpreterDataSource);
+      objectManager.setObject(FcrUIObjectKeys.P_MAIN_ROOM_CONTROL_PROVIDER, mainRoomControlProvider);
+      var privilegeProvider = mainRoomControlProvider.privilegeProvider;
+      objectManager.setObject(FcrUIObjectKeys.P_PRIVILEGE_PROVIDER, privilegeProvider);
+      var interpreterProvider = new FcrUIInterpreterProviderImpl({
+        privilegeProvider: privilegeProvider,
+        interpreterControl: interpreterControl,
+        userControl: userControl,
+        sharedInterpreterDataSource: sharedInterpreterDataSource,
+        eventProvider: eventProvider,
+        devicePrivilegeProvider: devicePrivilegeProvider,
+        roomProvider: roomProvider
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_INTERPRETER_PROVIDER, interpreterProvider);
+      var currentRoomControlProvider = new FcrUICurrentRoomControlProviderImpl(mainRoomControl);
+      objectManager.setObject(FcrUIObjectKeys.P_CURRENT_ROOM_CONTROL_PROVIDER, currentRoomControlProvider);
+      var sessionProvider = new FcrUISessionProviderImpl(engine);
+      objectManager.setObject(FcrUIObjectKeys.P_SESSION_PROVIDER, sessionProvider);
+      var sharedDevicePrivilegeDataSource = new FcrUISharedDevicePrivilegeDataSourceImpl();
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_DEVICE_PRIVILEGE_DATA_SOURCE, sharedDevicePrivilegeDataSource);
+      var facilityProvider = objectManager.getObject(FcrUIObjectKeys.P_FACILITY_PROVIDER);
+      var deviceStreamProvider = new FcrUIDeviceStreamProviderImpl(mainRoomControl, deviceProvider, messageProvider, dialogProvider, devicePrivilegeProvider, sharedDevicePrivilegeDataSource, interpreterProvider, sharedInterpreterDataSource, facilityProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_DEVICE_STREAM_PROVIDER, deviceStreamProvider);
+      var waitingRoomControlProvider = new FcrUIWaitingRoomControlProviderImpl(roomProvider, eventProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_WAITING_ROOM_CONTROL_PROVIDER, waitingRoomControlProvider);
+      var chatProvider = new FcrUIChatProviderImpl(currentRoomControlProvider.currentRoomControl, roomProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_CHAT_PROVIDER, chatProvider);
+      var sharedWaitingRoomDataSource = new FcrUISharedWaitingRoomDataSourceImpl(roomProvider, eventProvider);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_WAITING_ROOM_DATA_SOURCE, sharedWaitingRoomDataSource);
+      var phoneAudioConnectorProvider = new FcrUIPhoneAudioConnectorProviderImpl({
+        roomControl: mainRoomControl,
+        messageProvider: messageProvider,
+        deviceProvider: deviceProvider
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_PHONE_AUDIO_CONNECTOR_PROVIDER, phoneAudioConnectorProvider);
+      var sharedChatDataSource = new FcrUISharedChatDataSourceImpl(chatProvider);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_CHAT_DATA_SOURCE, sharedChatDataSource);
+      var sharedMeetingTimeDataSource = new FcrUIMeetingTimeSharedDataSourceImpl({
+        mainRoomControl: mainRoomControl
+      });
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_MEETING_TIME_DATA_SOURCE, sharedMeetingTimeDataSource);
+      var sharedMemberDataSource = new FcrUISharedMemberDataSourceImpl(userControl, streamControl, sharedScreenShareDataSource, eventProvider, mainRoomControl.getSharingControl().getBoardControl());
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_MEMBER_DATA_SOURCE, sharedMemberDataSource);
+      var widgetProvider = new FcrUIWidgetProviderImpl({
+        sharedWidgetDataSource: sharedWidgetDataSource,
+        roomProvider: roomProvider,
+        dialogProvider: dialogProvider,
+        sharedMemberDataSource: sharedMemberDataSource
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_WIDGET_PROVIDER, widgetProvider);
+      // @ts-ignore
+      var fcrUIMainWindowRenderer = window.FcrUIMainWindowRenderer;
+      var whiteboardProvider = new FcrUIBoardShareProviderImpl(objectManager, fcrUIMainWindowRenderer);
+      objectManager.setObject(FcrUIObjectKeys.P_BOARD_SHARE_PROVIDER, whiteboardProvider);
+      var sharedSecurityDataSource = new FcrUISecurityDataSourceImpl(privilegeProvider, sharedMemberDataSource);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_SECURITY_DATA_SOURCE, sharedSecurityDataSource);
+      var sttProvider = new FcrUISttProviderImpl({
+        sttControl: mainRoomControl.getSttControl(),
+        roomSessionControl: mainRoomControl.getRoomSessionControl(),
+        roomControl: mainRoomControl,
+        localUserId: userControl.getLocalUser().userId,
+        messageProvider: messageProvider,
+        dialogProvider: dialogProvider,
+        sharedSecurityDataSource: sharedSecurityDataSource,
+        privilegeProvider: privilegeProvider,
+        sharedInterpreterDataSource: sharedInterpreterDataSource
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_STT_PROVIDER, sttProvider);
+      var sharedApplistDataSource = new FcrUISharedApplistSourceImpl(abilityProvider, privilegeProvider, roomProvider, widgetProvider, sharedMemberDataSource, sharedInterpreterDataSource);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_APPLIST_DATA_SOURCE, sharedApplistDataSource);
+      var sharedSttSettingDataSource = new FcrUISharedSttSettingDataSourceImpl({
+        privilegeProvider: privilegeProvider,
+        sttProvider: sttProvider,
+        sharedSecurityDataSource: sharedSecurityDataSource
+      });
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_STT_SETTING_DATA_SOURCE, sharedSttSettingDataSource);
+      var sharedUserAudioVolumeDataSource = new FcrUISharedUserAudioVolumeDataSourceImpl();
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_USER_AUDIO_VOLUME_DATA_SOURCE, sharedUserAudioVolumeDataSource);
+      var sharedVideoWindowDataSource = new FcrUIVideoWindowDataSourceImpl(sharedSettingDataSource);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_VIDEO_WINDOW_DATA_SOURCE, sharedVideoWindowDataSource);
+      var screenShareProvider = new FcrUIScreenShareProviderImpl(objectManager);
+      objectManager.setObject(FcrUIObjectKeys.P_SCREEN_SHARE_PROVIDER, screenShareProvider);
+      var applistProvider = new FcrUIApplistProviderImpl(dialogProvider, eventProvider, widgetProvider, sharedApplistDataSource, messageProvider, sttProvider, sharedSttSettingDataSource, screenShareProvider, sharedSettingDataSource, abilityProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_APPLIST_PROVIDER, applistProvider);
+      var localVideoRenderProvider = new FcrUIMainLocalVideoRenderProviderImpl(deviceProvider, screenShareProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_LOCAL_VIDEO_RENDER_PROVIDER, localVideoRenderProvider);
+      var multiDisplayProvider = new FcrUIMultiDisplayProviderImpl({
+        renderer: renderer,
+        sharedSettingDataSource: sharedSettingDataSource,
+        sharedMemberDataSource: sharedMemberDataSource,
+        sharedVideoWindowDataSource: sharedVideoWindowDataSource,
+        windowProvider: windowProvider,
+        sharingControl: sharingControl,
+        whiteboardProvider: whiteboardProvider,
+        screenShareProvider: screenShareProvider
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_MULTI_DISPLAY_PROVIDER, multiDisplayProvider);
+      var sharedSpeakerSoptlightDataSource = new FcrUISharedSpeakerSpotlightDataSourceImpl();
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_SPEAKER_SPOTLIGHT_DATA_SOURCE, sharedSpeakerSoptlightDataSource);
+      var userAudioVolumeProvider = new FcrUIUserAudioVolumeProviderImpl({
+        audioVolumeData: sharedUserAudioVolumeDataSource,
+        videoWindowData: sharedVideoWindowDataSource,
+        settingData: sharedSettingDataSource,
+        interpreterData: sharedInterpreterDataSource,
+        deviceProvider: deviceProvider,
+        screenShareProvider: screenShareProvider,
+        streamControl: streamControl
+      });
+      objectManager.setObject(FcrUIObjectKeys.P_USER_AUDIO_VOLUME_PROVIDER, userAudioVolumeProvider);
+      var pinDataSource = new FcrUISharedPinDataSourceImpl(messageProvider, sharedVideoWindowDataSource);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_PIN_DATA_SOURCE, pinDataSource);
+      var annotationProvider = new FcrUIAnnotationProviderImpl(objectManager, fcrUIMainWindowRenderer);
+      objectManager.setObject(FcrUIObjectKeys.P_ANNOTATION_PROVIDER, annotationProvider);
+    }
+  }, {
+    key: "onMainSceneRelease",
+    value: function onMainSceneRelease() {
+      var objectManager = this._objectManager;
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_SCREEN_SHARE_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_ABILITY_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_DEVICE_PRIVILEGE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_REMOTE_VIDEO_RENDER_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_MAIN_ROOM_CONTROL_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_PRIVILEGE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_INTERPRETER_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_CURRENT_ROOM_CONTROL_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_SESSION_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_DEVICE_STREAM_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_WAITING_ROOM_CONTROL_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_CHAT_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_WAITING_ROOM_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_PHONE_AUDIO_CONNECTOR_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_CHAT_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_MEETING_TIME_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_MEMBER_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_BOARD_SHARE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_LOCAL_VIDEO_RENDER_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_SECURITY_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_APPLIST_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_APPLIST_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_SCREEN_SHARE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_MULTI_DISPLAY_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_USER_AUDIO_VOLUME_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_SPEAKER_SPOTLIGHT_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_USER_AUDIO_VOLUME_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_VIDEO_WINDOW_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_PIN_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_DEVICE_PRIVILEGE_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_INTERPRETER_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_WIDGET_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_STT_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_STT_SETTING_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_LAYOUT_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_ANNOTATION_PROVIDER);
+    }
+  }, {
+    key: "onWaitingSceneInitialize",
+    value: function onWaitingSceneInitialize() {
+      var objectManager = this._objectManager;
+
+      // Get required objects from object manager
+      var roomProvider = objectManager.getObject(FcrUIObjectKeys.P_ROOM_PROVIDER);
+      var eventProvider = objectManager.getObject(FcrUIObjectKeys.P_EVENT_PROVIDER);
+      var deviceProvider = objectManager.getObject(FcrUIObjectKeys.P_DEVICE_PROVIDER);
+      var waitingRoomControl = roomProvider.currentRoomControl;
+      var waitingRoomControlProvider = new FcrUIWaitingRoomControlProviderImpl(roomProvider, eventProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_WAITING_ROOM_CONTROL_PROVIDER, waitingRoomControlProvider);
+      var privilegeProvider = new FcrUIPrivilegeProviderImpl(waitingRoomControl.getPrivilegeControl(), waitingRoomControl.getUserControl(), waitingRoomControl.getStreamControl(), eventProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_PRIVILEGE_PROVIDER, privilegeProvider);
+      var sharedWaitingRoomDataSource = new FcrUISharedWaitingRoomDataSourceImpl(roomProvider, eventProvider);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_WAITING_ROOM_DATA_SOURCE, sharedWaitingRoomDataSource);
+      var currentRoomControlProvider = new FcrUICurrentRoomControlProviderImpl(waitingRoomControl);
+      objectManager.setObject(FcrUIObjectKeys.P_CURRENT_ROOM_CONTROL_PROVIDER, currentRoomControlProvider);
+      var chatProvider = new FcrUIChatProviderImpl(currentRoomControlProvider.currentRoomControl, roomProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_CHAT_PROVIDER, chatProvider);
+      var localVideoRenderProvider = new FcrUIWaitLocalVideoRenderProviderImpl(deviceProvider);
+      objectManager.setObject(FcrUIObjectKeys.P_LOCAL_VIDEO_RENDER_PROVIDER, localVideoRenderProvider);
+      var sharedChatDataSource = new FcrUISharedChatDataSourceImpl(chatProvider);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_CHAT_DATA_SOURCE, sharedChatDataSource);
+      var sharedConfigDataSource = objectManager.getObject(FcrUIObjectKeys.S_SHARED_CONFIG_DATA_SOURCE);
+      var sharedLayoutDataSource = new FcrUISharedLayoutDataSourceImpl(sharedConfigDataSource);
+      objectManager.setObject(FcrUIObjectKeys.S_SHARED_LAYOUT_DATA_SOURCE, sharedLayoutDataSource);
+      var abilityControl = currentRoomControlProvider.currentRoomControl.getAbilityControl();
+      var abilityProvider = new FcrUIAbilityProviderImpl(abilityControl);
+      objectManager.setObject(FcrUIObjectKeys.P_ABILITY_PROVIDER, abilityProvider);
+    }
+  }, {
+    key: "onWaitingSceneRelease",
+    value: function onWaitingSceneRelease() {
+      var objectManager = this._objectManager;
+      objectManager.deleteObject(FcrUIObjectKeys.P_WAITING_ROOM_CONTROL_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_PRIVILEGE_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_WAITING_ROOM_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_CURRENT_ROOM_CONTROL_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_CHAT_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.P_LOCAL_VIDEO_RENDER_PROVIDER);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_CHAT_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.S_SHARED_LAYOUT_DATA_SOURCE);
+      objectManager.deleteObject(FcrUIObjectKeys.P_ABILITY_PROVIDER);
+    }
+  }]);
+}();

package/lib-es/creator/type.js

@@ -0,0 +1 @@
+export {};

package/lib-es/electron/app.js

@@ -0,0 +1,264 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.date.to-json.js";
+import "core-js/modules/es.json.stringify.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.starts-with.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.json.parse.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import { open, close, windowOptionsMap, webPreferencesMap, setFragmentBaseUrl, closeAllWindows } from './window';
+import { powerMonitor, screen, BrowserWindow, ipcMain, systemPreferences, desktopCapturer } from 'electron';
+import path from 'path';
+import os from 'os';
+import { getLogger } from './logger';
+import { exec } from 'child_process';
+import { browserWindowIPCHandler } from './window-proxy/browser-window-proxy-factory';
+var logger = getLogger();
+export var hookApp = function hookApp(app) {
+  logger.info("hook app, main process id: ".concat(process.pid));
+  app.commandLine.appendSwitch('ignore-certificate-errors');
+  app.commandLine.appendSwitch('--force_high_performance_gpu');
+  // app.commandLine.appendSwitch('enable-logging');
+  // app.commandLine.appendSwitch('log-level', '0');
+  // app.commandLine.appendSwitch('v', '1');
+
+  // 启用 V8 调试信息
+  // app.commandLine.appendSwitch('js-flags', '--expose-gc --trace-gc');
+
+  app.addListener('browser-window-created', function (_, window) {
+    var windowId = window.id;
+    logger.info("browser window is created, id: ".concat(windowId));
+    window.webContents.addListener('render-process-gone', function (event, details) {
+      // 安全地获取 window 信息，避免在崩溃状态下访问可能失效的属性
+      var windowTitle = 'Unknown';
+      var windowId = 'Unknown';
+      try {
+        // 检查 window 是否仍然有效
+        if (!window.isDestroyed()) {
+          windowTitle = window.getTitle() || 'Unknown';
+          windowId = String(window.id);
+        }
+      } catch (error) {
+        logger.warn("failed to get window info during crash: ".concat(error));
+      }
+
+      // 输出详细的崩溃信息
+      logger.error("app exit due to render-process-gone event, window crash details - title: ".concat(windowTitle, ", id: ").concat(windowId, ", exitCode: ").concat(details.exitCode, ", reason: ").concat(details.reason));
+
+      // logger.error('exiting process due to render-process-gone event');
+
+      // app.exit(AppExitCode.RENDERER_PROCESS_GONE);
+    });
+    window.webContents.addListener('did-finish-load', function () {
+      var title = window.getTitle();
+      var processId = window.webContents.getOSProcessId();
+      logger.info("browser window did finish load, id: ".concat(windowId, ", title: ").concat(title, ", process id: ").concat(processId));
+    });
+  });
+  app.addListener('ready', function () {
+    powerMonitor.addListener('suspend', function () {
+      logger.info("power monitor event: suspend");
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_SUSPEND'
+        });
+      });
+    });
+    powerMonitor.addListener('resume', function () {
+      logger.info("power monitor event: resume");
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_RESUME'
+        });
+      });
+    });
+    powerMonitor.addListener('lock-screen', function () {
+      logger.info("power monitor event: lock-screen");
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_LOCK_SCREEN'
+        });
+      });
+    });
+    powerMonitor.addListener('unlock-screen', function () {
+      logger.info("power monitor event: unlock-screen");
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_UNLOCK_SCREEN'
+        });
+      });
+    });
+    powerMonitor.addListener('shutdown', function () {
+      logger.info("power monitor event: shutdown");
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'POWER_MONITOR_SHUTDOWN'
+        });
+      });
+    });
+    screen.addListener('display-added', function (event, newDisplay) {
+      logger.info("screen event: display-added, displayId: ".concat(newDisplay.id));
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'SCREEN_DISPLAY_ADDED',
+          display: newDisplay
+        });
+      });
+    });
+    screen.addListener('display-removed', function (event, oldDisplay) {
+      logger.info("screen event: display-removed, displayId: ".concat(oldDisplay.id));
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'SCREEN_DISPLAY_REMOVED',
+          display: oldDisplay
+        });
+      });
+    });
+    screen.addListener('display-metrics-changed', function (event, display, changedMetrics) {
+      logger.info("screen event: display-metrics-changed, displayId: ".concat(display.id, ", metrics: ").concat(changedMetrics.join(',')));
+      BrowserWindow.getAllWindows().forEach(function (window) {
+        window.webContents.send('custom-event', {
+          action: 'SCREEN_DISPLAY_METRICS_CHANGED',
+          display: display,
+          changedMetrics: changedMetrics
+        });
+      });
+    });
+    ipcMain.handle('get-launch-options', function () {
+      logger.info("ipcMain handle: get-launch-options");
+      var result = {};
+      var launchOptions = process.argv.find(function (arg) {
+        return arg.startsWith('--launch-options=');
+      });
+      if (!launchOptions) {
+        logger.error('No launch options found');
+      } else {
+        var jsonStr = launchOptions.substring('--launch-options='.length);
+        try {
+          result = JSON.parse(jsonStr);
+        } catch (e) {
+          logger.error('Invalid JSON argument:', jsonStr);
+        }
+      }
+      logger.info("ipcMain handle: get-launch-options, result: ".concat(JSON.stringify(result)));
+      return result;
+    });
+    ipcMain.handle('getBundleType', function () {
+      logger.info("ipcMain handle: getBundleType");
+      var bundleType = '';
+      if (process.env.DEV === 'true') {
+        bundleType = 'JS_BUNDLE';
+      }
+      // get bundle type from package.json
+      var packageJson = require(path.join(__dirname, '../../../../', 'package.json'));
+      bundleType = packageJson.bundleType || 'JS_BUNDLE';
+      logger.info("ipcMain handle: getBundleType, result: ".concat(bundleType));
+      return bundleType;
+    });
+    ipcMain.handle('getBrowserWindowId', function (_, frameName) {
+      var _browserWindowIPCHand;
+      logger.info("ipcMain handle: getBrowserWindowId, frameName: ".concat(frameName));
+      var windowId = (_browserWindowIPCHand = browserWindowIPCHandler.getWindow(frameName)) === null || _browserWindowIPCHand === void 0 ? void 0 : _browserWindowIPCHand.id;
+      logger.info("ipcMain handle: getBrowserWindowId, frameName: ".concat(frameName, ", result: ").concat(windowId));
+      return windowId;
+    });
+    ipcMain.handle('checkMediaPermission', /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_, mediaType) {
+        var result, accessStatus, platform;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              logger.info("ipcMain handle: checkMediaPermission, mediaType: ".concat(mediaType));
+              if (!(mediaType === 'sharing')) {
+                _context.next = 1;
+                break;
+              }
+              // below API call will trigger the system to add the permission for screen recording on macOS
+              desktopCapturer.getSources({
+                types: ['screen']
+              });
+              return _context.abrupt("return", true);
+            case 1:
+              result = false;
+              accessStatus = systemPreferences.getMediaAccessStatus(mediaType);
+              platform = os.platform();
+              if (!(accessStatus !== 'granted')) {
+                _context.next = 4;
+                break;
+              }
+              if (!(platform === 'darwin')) {
+                _context.next = 3;
+                break;
+              }
+              _context.next = 2;
+              return systemPreferences.askForMediaAccess(mediaType);
+            case 2:
+              result = _context.sent;
+            case 3:
+              _context.next = 5;
+              break;
+            case 4:
+              result = true;
+            case 5:
+              logger.info("ipcMain handle: checkMediaPermission, mediaType: ".concat(mediaType, ", result: ").concat(result));
+              return _context.abrupt("return", result);
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    ipcMain.addListener('openSystemPreferences', function (_, mediaType) {
+      logger.info("ipcMain event: openSystemPreferences, mediaType: ".concat(mediaType));
+      var execMap = {
+        camera: "open x-apple.systempreferences:com.apple.preference.security?Privacy_Camera",
+        microphone: "open x-apple.systempreferences:com.apple.preference.security?Privacy_Microphone",
+        sharing: "open x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture"
+      };
+      var execMapByWin32 = {
+        microphone: 'start ms-settings:privacy-microphone',
+        camera: 'start ms-settings:privacy-webcam',
+        sharing: 'start ms-settings:privacy-screen-capture'
+      };
+      if (os.platform() === 'win32') {
+        exec(execMapByWin32[mediaType]);
+      } else {
+        exec(execMap[mediaType]);
+      }
+    });
+    ipcMain.addListener('open', function (_, entryPath, dialogId) {
+      logger.info("ipcMain event: open, entryPath: ".concat(entryPath, ", dialogId: ").concat(dialogId));
+      open(entryPath, dialogId);
+    });
+    ipcMain.addListener('close', function (_, entryPath, dialogId) {
+      logger.info("ipcMain event: close, entryPath: ".concat(entryPath, ", dialogId: ").concat(dialogId));
+      close(entryPath, dialogId);
+    });
+    ipcMain.addListener('setFragmentBaseUrl', function (_, isDev, baseUrl) {
+      logger.info("ipcMain event: setFragmentBaseUrl, isDev: ".concat(isDev, ", baseUrl: ").concat(baseUrl));
+      setFragmentBaseUrl(isDev, baseUrl);
+    });
+    ipcMain.addListener('setFragmentOptions', function (_, entryPath, windowOptions, webPreferences) {
+      logger.info("ipcMain event: setFragmentOptions, entryPath: ".concat(entryPath, ", windowOptions: ").concat(JSON.stringify(windowOptions), ", webPreferences: ").concat(JSON.stringify(webPreferences)));
+      windowOptionsMap[entryPath] = windowOptions;
+      webPreferencesMap[entryPath] = webPreferences;
+    });
+    ipcMain.addListener('initialize', function () {
+      logger.info('ipcMain event: initialize');
+      closeAllWindows();
+      browserWindowIPCHandler.clearAllWindows();
+    });
+  });
+};