@tencentcloud/roomkit-electron-vue3 2.3.3

package/lib/services/function/waterMark.js

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("../types.js");
+class WaterMark {
+  constructor(service) {
+    __publicField(this, "service");
+    __publicField(this, "isWatermarkEnabled", false);
+    __publicField(this, "handleRoomStart", () => {
+      this.updateWatermarkVisibility(true);
+    });
+    __publicField(this, "handleRoomJoin", () => {
+      this.updateWatermarkVisibility(true);
+    });
+    this.service = service;
+    this.bindEvent();
+  }
+  bindEvent() {
+    this.service.on(types.EventType.ROOM_START, this.handleRoomStart);
+    this.service.on(types.EventType.ROOM_JOIN, this.handleRoomJoin);
+  }
+  dispose() {
+    this.service.off(types.EventType.ROOM_START, this.handleRoomStart);
+    this.service.off(types.EventType.ROOM_JOIN, this.handleRoomJoin);
+  }
+  toggleWatermark(enabled) {
+    this.isWatermarkEnabled = enabled;
+    this.updateWatermarkVisibility(enabled);
+  }
+  updateWatermarkVisibility(enabled) {
+    const watermarkContainer = document.querySelector(".watermark-container");
+    if (!enabled || !this.isWatermarkEnabled) {
+      watermarkContainer == null ? void 0 : watermarkContainer.remove();
+      return;
+    }
+    if (!watermarkContainer) {
+      const videoElement = document.querySelector(".content-container");
+      const { userId, userName } = this.service.basicStore;
+      this.addWatermark(videoElement, `${userName}(${userId})`);
+    }
+  }
+  addStyles() {
+    const styles = `
+          .watermark-container {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+          }
+          .watermark {
+            font-size: 16px;
+            position: absolute;
+            transform: rotate(-45deg);
+            opacity: 0.3;
+            word-wrap: break-word;
+            text-align: center;
+            color: #99A2B2;
+            max-width: 400px;
+            font-weight: 500;
+          }
+        `;
+    const styleElement = document.createElement("style");
+    styleElement.type = "text/css";
+    styleElement.appendChild(document.createTextNode(styles));
+    document.head.appendChild(styleElement);
+  }
+  addWatermark(targetElement, watermarkText) {
+    if (!targetElement)
+      return;
+    this.addStyles();
+    let watermarkContainer = document.createElement("div");
+    watermarkContainer.classList.add("watermark-container");
+    targetElement.appendChild(watermarkContainer);
+    const addWatermarkElements = () => {
+      const maxWidth = 200;
+      const watermarkSpacing = maxWidth + 25;
+      for (let y = -watermarkSpacing; y < watermarkContainer.offsetHeight + watermarkSpacing; y += watermarkSpacing) {
+        for (let x = -watermarkSpacing; x < watermarkContainer.offsetWidth + watermarkSpacing; x += watermarkSpacing) {
+          const watermarkElement = document.createElement("div");
+          watermarkElement.classList.add("watermark");
+          watermarkElement.textContent = watermarkText;
+          watermarkElement.style.left = `${x}px`;
+          watermarkElement.style.top = `${y}px`;
+          watermarkContainer.appendChild(watermarkElement);
+        }
+      }
+    };
+    addWatermarkElements();
+    const observerCallback = (mutations, observer) => {
+      mutations.forEach((mutation) => {
+        if (mutation.removedNodes.length > 0) {
+          const removedWatermark = Array.from(mutation.removedNodes).some((node) => {
+            var _a;
+            return (_a = node.classList) == null ? void 0 : _a.contains("watermark-container");
+          });
+          if (removedWatermark) {
+            watermarkContainer = document.createElement("div");
+            watermarkContainer.classList.add("watermark-container");
+            targetElement.appendChild(watermarkContainer);
+            addWatermarkElements();
+            observer.disconnect();
+            observeChanges();
+          }
+        }
+        if (mutation.type === "attributes" && mutation.attributeName === "style") {
+          watermarkContainer.style.display = "";
+        }
+      });
+    };
+    const observeChanges = () => {
+      const observer = new MutationObserver(observerCallback);
+      observer.observe(targetElement, { childList: true });
+      observer.observe(watermarkContainer, { attributes: true, attributeFilter: ["style"] });
+    };
+    observeChanges();
+  }
+}
+exports.WaterMark = WaterMark;

package/lib/services/index.d.ts

@@ -0,0 +1,8 @@
+
+export * from './roomService';
+export * from './types';
+export * from './manager/componentManager';
+export * from './manager/configManager';
+export * from './manager/userManager';
+export * from './manager/lifeCycleManager';
+export * from './manager/roomActionManager';

package/lib/services/main.d.ts

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

package/lib/services/main.js

@@ -0,0 +1,4 @@
+"use strict";
+const chatExtension = require("../extension/chatExtension.js");
+const roomService = require("./roomService.js");
+roomService.roomService.useExtension(chatExtension.chatExtension);

package/lib/services/manager/componentManager.d.ts

@@ -0,0 +1,26 @@
+import { IRoomService } from '..';
+
+interface IComponentManager {
+    getComponentConfig(name: ComponentName): ComponentConfigItem;
+    setComponentConfig(options: Partial<ComponentConfig>): boolean;
+}
+declare const componentNames: readonly ["SwitchTheme", "LayoutControl", "RoomInfo", "RoomLink", "Language", "UserInfo", "ScreenShare", "FullScreen", "ManageMemberControl", "InviteControl", "ChatControl", "MoreControl", "VirtualBackground"];
+export type ComponentName = typeof componentNames[number];
+type ComponentConfigItem = {
+    visible: boolean;
+    [key: string]: any;
+};
+export type ComponentConfig = {
+    [key in ComponentName]: ComponentConfigItem;
+};
+export declare class ComponentManager implements IComponentManager {
+    static instance?: ComponentManager;
+    private service;
+    private componentConfig;
+    constructor(service: IRoomService);
+    static getInstance(ctx: IRoomService): ComponentManager;
+    static destroyInstance(): void;
+    getComponentConfig(name: ComponentName): ComponentConfigItem;
+    setComponentConfig(options: Partial<ComponentConfig>): boolean;
+}
+export {};

package/lib/services/manager/componentManager.js

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../utils/common/logger/index.js");
+const componentNames = [
+  "SwitchTheme",
+  "LayoutControl",
+  "RoomInfo",
+  "RoomLink",
+  "Language",
+  "UserInfo",
+  "ScreenShare",
+  "FullScreen",
+  "ManageMemberControl",
+  "InviteControl",
+  "ChatControl",
+  "MoreControl",
+  "VirtualBackground"
+];
+const logPrefix = "[RoomService ComponentManager]";
+const defaultConfig = {
+  SwitchTheme: { visible: true },
+  LayoutControl: { visible: true },
+  RoomInfo: { visible: true },
+  RoomLink: { visible: true },
+  Language: { visible: true },
+  UserInfo: { visible: true },
+  ScreenShare: { visible: true },
+  FullScreen: { visible: true },
+  ManageMemberControl: { visible: true },
+  InviteControl: { visible: true },
+  ChatControl: { visible: true },
+  MoreControl: { visible: true },
+  VirtualBackground: { visible: false }
+};
+const _ComponentManager = class _ComponentManager {
+  constructor(service) {
+    __publicField(this, "service");
+    __publicField(this, "componentConfig", Object.fromEntries(componentNames.map((name) => [
+      name,
+      {
+        ...defaultConfig[name]
+      }
+    ])));
+    this.service = service;
+  }
+  static getInstance(ctx) {
+    if (!_ComponentManager.instance) {
+      _ComponentManager.instance = new _ComponentManager(ctx);
+    }
+    return _ComponentManager.instance;
+  }
+  static destroyInstance() {
+    if (!_ComponentManager.instance)
+      return;
+    _ComponentManager.instance = void 0;
+  }
+  getComponentConfig(name) {
+    return this.componentConfig[name];
+  }
+  setComponentConfig(options) {
+    try {
+      Object.entries(options).forEach(([name, current]) => {
+        this.componentConfig[name] = Object.assign(
+          {},
+          this.componentConfig[name],
+          current
+        );
+      });
+      return true;
+    } catch (error) {
+      index.default.error(`${logPrefix}setComponentConfig error: ${error}`);
+      return false;
+    }
+  }
+};
+__publicField(_ComponentManager, "instance");
+let ComponentManager = _ComponentManager;
+exports.ComponentManager = ComponentManager;

package/lib/services/manager/configManager.d.ts

@@ -0,0 +1,15 @@
+import { IRoomService } from '../types';
+
+interface IConfigManager {
+    setTheme(theme: ThemeOption): void;
+    setLanguage(language: LanguageOption): void;
+}
+export type LanguageOption = 'zh-CN' | 'en-US';
+export type ThemeOption = 'LIGHT' | 'DARK';
+export declare class ConfigManager implements IConfigManager {
+    private service;
+    constructor(service: IRoomService);
+    setTheme(theme: ThemeOption): void;
+    setLanguage(language: LanguageOption): void;
+}
+export {};

package/lib/services/manager/configManager.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../locales/index.js");
+const THEME = {
+  LIGHT: "tui-theme-white",
+  DARK: "tui-theme-black"
+};
+class ConfigManager {
+  constructor(service) {
+    __publicField(this, "service");
+    this.service = service;
+  }
+  setTheme(theme) {
+    const isDarkTheme = theme === "DARK";
+    document.body.classList.toggle(THEME.DARK, isDarkTheme);
+    document.body.classList.toggle(THEME.LIGHT, !isDarkTheme);
+    localStorage.setItem("tuiRoom-currentTheme", isDarkTheme ? THEME.DARK : THEME.LIGHT);
+  }
+  setLanguage(language) {
+    index.default.global.locale.value = language;
+    this.service.basicStore.setLang(language);
+    localStorage.setItem("tuiRoom-language", language);
+  }
+}
+exports.ConfigManager = ConfigManager;

package/lib/services/manager/lifeCycleManager.d.ts

@@ -0,0 +1,34 @@
+import { IRoomService } from '../types';
+
+export type LifeCycleEvent = 'mount' | 'unmount';
+export declare enum LifeCycleChangeReason {
+    RoomLogout = "room logout",
+    RoomStart = "room start",
+    RoomJoin = "room join",
+    RoomLeave = "room leave",
+    RoomDestroy = "room destroy",
+    RoomKickedOffline = "room kicked offline",
+    RoomKickedOut = "room kicked out",
+    RoomUserSigExpired = "room user sig expired",
+    RoomError = "room error"
+}
+interface ILifeCycleManager {
+    on(eventType: LifeCycleEvent, callback: (data?: any) => any): void;
+    off(eventType: LifeCycleEvent, callback: (data?: any) => void): void;
+    start(): void;
+    stop(): void;
+}
+export declare class LifeCycleManager implements ILifeCycleManager {
+    private service;
+    private eventCallbacks;
+    private emitter;
+    constructor(service: IRoomService);
+    start(): void;
+    stop(): void;
+    on(eventType: LifeCycleEvent, callback: (data?: any) => any): void;
+    off(eventType: LifeCycleEvent, callback: (data?: any) => void): void;
+    private emit;
+    private addEventListeners;
+    private removeEventListeners;
+}
+export {};

package/lib/services/manager/lifeCycleManager.js

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mitt = require("mitt");
+const types = require("../types.js");
+class LifeCycleManager {
+  constructor(service) {
+    __publicField(this, "service");
+    __publicField(this, "eventCallbacks", {});
+    __publicField(this, "emitter", mitt());
+    this.service = service;
+  }
+  start() {
+    this.stop();
+    this.addEventListeners();
+  }
+  stop() {
+    this.removeEventListeners();
+  }
+  on(eventType, callback) {
+    this.emitter.on(eventType, callback);
+  }
+  off(eventType, callback) {
+    this.emitter.off(eventType, callback);
+  }
+  emit(eventType, data) {
+    this.emitter.emit(eventType, data);
+  }
+  addEventListeners() {
+    const handleMount = (reason) => this.emit("mount", { reason });
+    const handleUnmount = (reason) => this.emit("unmount", { reason });
+    const handleCallback = (type, reason) => {
+      const callback = type === "mount" ? handleMount : handleUnmount;
+      return callback.bind(this, reason);
+    };
+    const eventReasonMap = {
+      [types.EventType.ROOM_START]: { reason: "room start", type: "mount" },
+      [types.EventType.ROOM_JOIN]: { reason: "room join", type: "mount" },
+      [types.EventType.USER_LOGOUT]: { reason: "room logout", type: "unmount" },
+      [types.EventType.ROOM_LEAVE]: { reason: "room leave", type: "unmount" },
+      [types.EventType.ROOM_DISMISS]: { reason: "room destroy", type: "unmount" },
+      [types.EventType.KICKED_OFFLINE]: { reason: "room kicked offline", type: "unmount" },
+      [types.EventType.KICKED_OUT]: { reason: "room kicked out", type: "unmount" },
+      [types.EventType.USER_SIG_EXPIRED]: { reason: "room user sig expired", type: "unmount" },
+      [types.EventType.ROOM_ERROR]: { reason: "room error", type: "unmount" }
+    };
+    Object.entries(eventReasonMap).forEach(([event, { reason, type }]) => {
+      const callback = handleCallback(type, reason);
+      this.eventCallbacks[event] = callback;
+      this.service.on(event, callback);
+    });
+  }
+  removeEventListeners() {
+    Object.entries(this.eventCallbacks).forEach(([event, callback]) => {
+      this.service.off(event, callback);
+    });
+  }
+}
+exports.LifeCycleManager = LifeCycleManager;

package/lib/services/manager/roomActionManager.d.ts

@@ -0,0 +1,38 @@
+import { IRoomService, RoomParam } from '../types';
+
+export interface DeviceParams {
+    isOpenCamera?: boolean;
+    isOpenMicrophone?: boolean;
+    defaultCameraId?: string;
+    defaultMicrophoneId?: string;
+    defaultSpeakerId?: string;
+}
+export interface StartParams extends DeviceParams {
+    roomName?: string;
+    isSeatEnabled?: boolean;
+}
+export interface JoinParams extends DeviceParams {
+}
+export declare class RoomActionManager {
+    private service;
+    constructor(service: IRoomService);
+    start(roomId: string, params?: StartParams): Promise<void>;
+    join(roomId: string, params?: JoinParams): Promise<void>;
+    leaveRoom(): Promise<void>;
+    dismissRoom(): Promise<void>;
+    createRoom(options: {
+        roomId: string;
+        roomName?: string;
+        roomMode?: 'FreeToSpeak' | 'SpeakAfterTakingSeat';
+        roomParam?: DeviceParams;
+    }): Promise<void>;
+    private handleRoomCreation;
+    enterRoom(options: {
+        roomId: string;
+        roomParam?: RoomParam;
+    }): Promise<void>;
+    private doEnterRoom;
+    private getUserList;
+    private getSeatList;
+    private closeMediaBeforeLeave;
+}

package/lib/services/manager/roomActionManager.js

@@ -0,0 +1,227 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const TUIRoomEngine = require("@tencentcloud/tuiroom-engine-electron");
+const types = require("../types.js");
+const environment = require("../../utils/environment.js");
+const index = require("../../utils/common/logger/index.js");
+const logPrefix = "[RoomService:roomActionManager]";
+const smallParam = new TUIRoomEngine.TRTCVideoEncParam();
+smallParam.videoResolution = TUIRoomEngine.TRTCVideoResolution.TRTCVideoResolution_640_360;
+smallParam.videoFps = 10;
+smallParam.videoBitrate = 550;
+class RoomActionManager {
+  constructor(service) {
+    __publicField(this, "service");
+    this.service = service;
+  }
+  async start(roomId, params = {}) {
+    const {
+      roomName,
+      isSeatEnabled = false,
+      isOpenCamera = false,
+      isOpenMicrophone = false,
+      defaultCameraId,
+      defaultMicrophoneId,
+      defaultSpeakerId
+    } = params;
+    const roomMode = isSeatEnabled ? "SpeakAfterTakingSeat" : "FreeToSpeak";
+    await this.createRoom({
+      roomId,
+      roomName,
+      roomMode,
+      roomParam: {
+        isOpenCamera,
+        isOpenMicrophone,
+        defaultCameraId,
+        defaultMicrophoneId,
+        defaultSpeakerId
+      }
+    });
+    await this.enterRoom({
+      roomId,
+      roomParam: {
+        isOpenCamera,
+        isOpenMicrophone,
+        defaultCameraId,
+        defaultMicrophoneId,
+        defaultSpeakerId
+      }
+    });
+    this.service.emit(types.EventType.ROOM_START);
+  }
+  async join(roomId, params = {}) {
+    const {
+      isOpenCamera = false,
+      isOpenMicrophone = false,
+      defaultCameraId,
+      defaultMicrophoneId,
+      defaultSpeakerId
+    } = params;
+    await this.enterRoom({
+      roomId,
+      roomParam: {
+        isOpenCamera,
+        isOpenMicrophone,
+        defaultCameraId,
+        defaultMicrophoneId,
+        defaultSpeakerId
+      }
+    });
+    this.service.emit(types.EventType.ROOM_JOIN);
+  }
+  async leaveRoom() {
+    var _a;
+    try {
+      this.closeMediaBeforeLeave();
+      const response = await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.exitRoom());
+      this.service.resetStore();
+      index.default.log(`${logPrefix}leaveRoom:`, response);
+      this.service.emit(types.EventType.ROOM_LEAVE, response);
+    } catch (error) {
+      index.default.error(`${logPrefix}leaveRoom error:`, error);
+    }
+  }
+  async dismissRoom() {
+    var _a;
+    try {
+      index.default.log(`${logPrefix}dismissRoom: enter`);
+      this.closeMediaBeforeLeave();
+      await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.destroyRoom());
+      this.service.resetStore();
+      this.service.emit(types.EventType.ROOM_DISMISS, {});
+    } catch (error) {
+      index.default.error(`${logPrefix}dismissRoom error:`, error);
+    }
+  }
+  async createRoom(options) {
+    try {
+      const { roomId, roomName, roomMode } = options;
+      const roomParams = {
+        roomId,
+        name: roomName,
+        roomType: TUIRoomEngine.TUIRoomType.kConference,
+        isSeatEnabled: roomMode !== "FreeToSpeak",
+        seatMode: roomMode === "SpeakAfterTakingSeat" ? TUIRoomEngine.TUISeatMode.kApplyToTake : void 0
+      };
+      await this.handleRoomCreation(roomParams, options);
+    } catch (error) {
+      index.default.error(`${logPrefix}createRoom error:`, error);
+      this.service.emit(types.EventType.ROOM_NOTICE_MESSAGE_BOX, {
+        title: this.service.t("Note"),
+        message: this.service.t("Failed to initiate meeting"),
+        confirmButtonText: this.service.t("Sure"),
+        callback: async () => {
+          this.service.emit(types.EventType.ROOM_ERROR, error);
+          this.service.resetStore();
+        }
+      });
+      throw error;
+    }
+  }
+  async handleRoomCreation(roomParams, options) {
+    var _a;
+    const { roomEngine } = this.service;
+    if (!roomEngine.instance) {
+      return;
+    }
+    this.service.basicStore.setRoomId(roomParams.roomId);
+    index.default.debug(`${logPrefix}createRoom:`, roomParams, options);
+    await ((_a = roomEngine.instance) == null ? void 0 : _a.createRoom(roomParams));
+  }
+  async enterRoom(options) {
+    var _a;
+    try {
+      const { roomId, roomParam } = options;
+      const roomParams = {
+        roomId,
+        roomType: TUIRoomEngine.TUIRoomType.kConference
+      };
+      const roomInfo = await this.doEnterRoom(roomParams);
+      this.service.roomStore.setRoomInfo(roomInfo);
+      await this.getUserList();
+      if (roomInfo.isSeatEnabled) {
+        await this.getSeatList();
+        this.service.roomStore.isMaster && await ((_a = this.service.roomEngine.instance) == null ? void 0 : _a.takeSeat({
+          seatIndex: -1,
+          timeout: 0
+        }));
+      }
+      this.service.roomStore.setRoomParam(roomParam);
+    } catch (error) {
+      index.default.error(`${logPrefix}enterRoom error:`, error);
+      this.service.emit(types.EventType.ROOM_NOTICE_MESSAGE_BOX, {
+        title: this.service.t("Note"),
+        message: this.service.t("Failed to enter the meeting"),
+        confirmButtonText: this.service.t("Sure"),
+        callback: async () => {
+          this.service.emit(types.EventType.ROOM_ERROR, error);
+          this.service.roomStore.reset();
+        }
+      });
+      throw error;
+    }
+  }
+  async doEnterRoom(options) {
+    var _a, _b, _c, _d;
+    const { roomEngine } = this.service;
+    const { roomId, roomType } = options;
+    this.service.basicStore.setRoomId(roomId);
+    const isH5 = environment.isMobile && !environment.isWeChat;
+    const trtcCloud = (_a = roomEngine.instance) == null ? void 0 : _a.getTRTCCloud();
+    trtcCloud == null ? void 0 : trtcCloud.setDefaultStreamRecvMode(true, false);
+    trtcCloud == null ? void 0 : trtcCloud.enableSmallVideoStream(!isH5, smallParam);
+    const roomInfo = await ((_b = roomEngine.instance) == null ? void 0 : _b.enterRoom({
+      roomId,
+      roomType
+    }));
+    (_c = roomEngine.instance) == null ? void 0 : _c.muteLocalAudio();
+    if (!roomInfo.isSeatEnabled) {
+      (_d = roomEngine.instance) == null ? void 0 : _d.openLocalMicrophone();
+      this.service.basicStore.setIsOpenMic(true);
+    }
+    return roomInfo;
+  }
+  async getUserList() {
+    var _a;
+    const { roomEngine } = this.service;
+    let nextSequence = 0;
+    try {
+      do {
+        const result = await ((_a = roomEngine.instance) == null ? void 0 : _a.getUserList({
+          nextSequence
+        }));
+        this.service.roomStore.updateUserList(result.userInfoList);
+        nextSequence = result.nextSequence;
+      } while (nextSequence !== 0);
+    } catch (error) {
+      index.default.error("TUIRoomEngine.getUserList", error.code, error.message);
+    }
+  }
+  async getSeatList() {
+    var _a;
+    const { roomEngine } = this.service;
+    try {
+      const seatList = await ((_a = roomEngine.instance) == null ? void 0 : _a.getSeatList());
+      this.service.roomStore.setSeatList(seatList);
+    } catch (error) {
+      index.default.error("TUIRoomEngine.getSeatList", error.code, error.message);
+    }
+  }
+  closeMediaBeforeLeave() {
+    var _a, _b;
+    const { roomEngine } = this.service;
+    if (this.service.roomStore.localUser.hasAudioStream) {
+      (_a = roomEngine.instance) == null ? void 0 : _a.closeLocalMicrophone();
+    }
+    if (this.service.roomStore.localUser.hasVideoStream) {
+      (_b = roomEngine.instance) == null ? void 0 : _b.closeLocalCamera();
+    }
+  }
+}
+exports.RoomActionManager = RoomActionManager;