fcr-core 3.4.0

package/lib/room-control/chatroom-control/index.js

@@ -0,0 +1,323 @@
+"use strict";
+
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/esnext.async-iterator.filter.js");
+require("core-js/modules/esnext.async-iterator.for-each.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrChatRoomControlImpl = void 0;
+require("core-js/modules/es.error.cause.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _observable = require("agora-foundation/lib/utilities/observable");
+var _easemobWebsdk = _interopRequireDefault(require("easemob-websdk"));
+var _user = require("../../utilities/user");
+var _error = require("../../utilities/error");
+var _logger = require("agora-foundation/lib/logger");
+var _type = require("./type");
+var _type2 = require("../../chat-connection/type");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * @internal
+ */
+class FcrChatRoomControlImpl {
+  _setConnectionState(state) {
+    this._connectionState = state;
+    this._observable.notifyObservers('onConnectionStateUpdated', this._scene.sceneId, state);
+  }
+  get conn() {
+    if (!this._chatConnection.getConnectionInstance()) {
+      throw (0, _error.generateFcrCoreClientError)(_error.FcrErrorModuleCode.ROOM_CHATROOM, _error.FcrErrorCode.UNDEFINED_ERROR, 'chat room connection not initialized, please get chat room token first', new Error('chat room connection not initialized, please get chat room token first'));
+    }
+    return this._chatConnection.getConnectionInstance();
+  }
+  get chatRoomId() {
+    return this._scene.getScenePropertiesByKeyPath('widgets.easemobIM.extra.chatRoomId');
+  }
+  constructor(_engine, _scene, _api, _chatConnection, _chatIpList, _restIpList) {
+    (0, _defineProperty2.default)(this, "logger", (0, _logger.getLogger)());
+    (0, _defineProperty2.default)(this, "_observable", new _observable.AgoraObservable());
+    (0, _defineProperty2.default)(this, "_connectionState", _type.FcrChatRoomConnectionState.Disconnected);
+    (0, _defineProperty2.default)(this, "_chatConnectionObserver", {
+      onConnectionStateUpdated: async state => {
+        this._joinChatRoom(state);
+      }
+    });
+    (0, _defineProperty2.default)(this, "_joinChatRoom", async state => {
+      if (state === _type2.FcrChatConnectionState.DISCONNECTED && this.getConnectionState() === _type.FcrChatRoomConnectionState.Connected) {
+        this._setConnectionState(_type.FcrChatRoomConnectionState.Connecting);
+        await this.conn.joinChatRoom({
+          roomId: this.chatRoomId
+        });
+        this._setConnectionState(_type.FcrChatRoomConnectionState.Connected);
+      }
+    });
+    (0, _defineProperty2.default)(this, "_convertAgoraChatMessageToFcrChatRoomReceiveMessage", msg => {
+      // TODO: 没看到有 contentsType 字段
+      //@ts-ignore
+      switch (msg.type) {
+        case 'txt':
+          {
+            const message = {
+              id: msg.id,
+              //@ts-ignore
+              from: msg.ext.sender,
+              type: _type.FcrChatRoomMessageType.Text,
+              //@ts-ignore
+              timestamp: parseInt(msg.time),
+              //@ts-ignore
+              content: msg.msg,
+              //@ts-ignore
+              isPrivate: msg.ext.isPrivate
+            };
+            return message;
+          }
+        // TODO: 3.x
+        // case 'IMAGE': {
+        //   const message: FcrChatRoomReceiveImageMessage = {
+        //     id: msg.id,
+        //     //@ts-ignore
+        //     from: msg.ext.sender,
+        //     type: FcrChatRoomMessageType.Image,
+        //     //@ts-ignore
+        //     timestamp: parseInt(msg.time),
+        //     //@ts-ignore
+        //     file: msg.url,
+        //     //@ts-ignore
+        //     isPrivate: msg.ext.isPrivate,
+        //   };
+        //   return message;
+        // }
+      }
+      throw (0, _error.generateFcrCoreClientError)(_error.FcrErrorModuleCode.ROOM_CHATROOM, _error.FcrErrorCode.UNDEFINED_ERROR, 'unknown remote message type', new Error('unknown remote message type'));
+    });
+    (0, _defineProperty2.default)(this, "_convertFcrChatRoomSendBaseMessageToAgoraChatMessage", msg => {
+      var _message$to;
+      switch (msg.type) {
+        case _type.FcrChatRoomMessageType.Text:
+          const message = msg;
+          const isPrivate = !!((_message$to = message.to) !== null && _message$to !== void 0 && _message$to.length);
+          const localUserInfo = this._scene.getUser(this._scene.getLocalUser().getLocalUserId());
+          return _easemobWebsdk.default.message.create({
+            to: this.chatRoomId,
+            msg: message.content,
+            type: 'txt',
+            chatType: 'chatRoom',
+            ext: {
+              sender: (0, _user.convertRteUserToFcrUser)(localUserInfo),
+              roomUuid: this._scene.sceneId,
+              isPrivate
+            },
+            receiverList: message.to
+          });
+      }
+      throw (0, _error.generateFcrCoreClientError)(_error.FcrErrorModuleCode.ROOM_CHATROOM, _error.FcrErrorCode.UNDEFINED_ERROR, 'unknown local message type', new Error('unknown local message type'));
+    });
+    this._engine = _engine;
+    this._scene = _scene;
+    this._api = _api;
+    this._chatConnection = _chatConnection;
+    this._chatIpList = _chatIpList;
+    this._restIpList = _restIpList;
+    this._chatConnection.addObserver(this._chatConnectionObserver);
+    this._join();
+    this._addEventListener();
+  }
+  async _join() {
+    await this._joinChatRoom(this._chatConnection.getConnectionState());
+  }
+  _removeEventListener() {
+    this.conn.removeEventHandler("chatroom".concat(this._scene.sceneId));
+  }
+  _addEventListener() {
+    this.conn.addEventHandler("chatroom".concat(this._scene.sceneId), {
+      onTextMessage: msg => {
+        if (msg.to !== this._scene.getScenePropertiesByKeyPath('widgets.easemobIM.extra.chatRoomId')) {
+          return;
+        }
+        const message = this._convertAgoraChatMessageToFcrChatRoomReceiveMessage(msg);
+        this._observable.notifyObservers('onTextMessageReceived', this._scene.sceneId, message);
+      }
+    });
+    // TODO: 3.x
+    // this.conn.onPictureMessage = (msg) => {
+    //   if (msg.to !== this.initConfig.chatRoomId) {
+    //     return;
+    //   }
+    //   const message: FcrChatRoomReceiveImageMessage =
+    //     this._convertAgoraChatMessageToFcrChatRoomReceiveMessage(
+    //       msg,
+    //     ) as FcrChatRoomReceiveImageMessage;
+    //   this._observable.notifyObservers('onImageMessageReceived', this._scene.sceneId, message);
+    // };
+
+    // TODO: 3.x
+    // this.conn.onCmdMessage = (msg) => {
+    //   if (msg.to !== this.initConfig.chatRoomId) {
+    //     return;
+    //   }
+    //   const message: FcrChatRoomReceiveCustomMessage =
+    //     this._convertAgoraChatMessageToFcrChatRoomReceiveMessage(msg);
+    //   this._observable.notifyObservers('onCustomMessageReceived', this._scene.sceneId, message);
+    // };
+
+    // TODO: 3.x
+    // this.conn.onChatroomEvent = (eventData: EasemobChat.ChatroomEvent) => {
+    //   if (eventData.operation === 'updateAnnouncement') {
+    //     this._observable.notifyObservers(
+    //       'onAnnouncementUpdated',
+    //       this._scene.sceneId,
+    //       // TODO: 应该用什么字段传递?
+    //       (eventData.attributes as { [key: string]: string })?.announcement,
+    //     );
+    //   } else if (eventData.operation === 'deleteAnnouncement') {
+    //     this._observable.notifyObservers('onAnnouncementDeleted', this._scene.sceneId);
+    //   }
+    // };
+  }
+  getConnectionState() {
+    return this._connectionState;
+  }
+  async sendMessage(message) {
+    var _message$to2;
+    const msg = this._convertFcrChatRoomSendBaseMessageToAgoraChatMessage(message);
+    await this.conn.send(msg);
+    const localUserInfo = this._scene.getUser(this._scene.getLocalUser().getLocalUserId());
+    const res = _objectSpread(_objectSpread({}, message.type === _type.FcrChatRoomMessageType.Text ? {
+      content: message.content
+    } : {
+      file: message.file
+    }), {}, {
+      from: (0, _user.convertRteUserToFcrUser)(localUserInfo),
+      id: msg.id,
+      type: _type.FcrChatRoomMessageType.Text,
+      properties: message.properties,
+      timestamp: Date.now(),
+      isPrivate: !!((_message$to2 = message.to) !== null && _message$to2 !== void 0 && _message$to2.length)
+    });
+    return res;
+  }
+  addObserver(observer) {
+    this._observable.addObserver(observer);
+  }
+  removeObserver(observer) {
+    this._observable.removeObserver(observer);
+  }
+  async leave() {
+    await new Promise(async (resolve, reject) => {
+      this._removeEventListener();
+      try {
+        await this.conn.leaveChatRoom({
+          roomId: this.chatRoomId,
+          success: () => {
+            resolve(undefined);
+          },
+          error: e => {
+            reject((0, _error.generateFcrCoreClientError)(_error.FcrErrorModuleCode.ROOM_CHATROOM, _error.FcrErrorCode.UNDEFINED_ERROR, 'leave chat room failed', e));
+          }
+        });
+      } catch (e) {
+        resolve(undefined);
+      }
+    });
+  }
+
+  // TODO: 3.x
+  // /**
+  //  *
+  //  * @param pageSize max 50
+  //  * @param startedMessageId
+  //  * @returns
+  //  */
+  // async getHistoryMessageList(
+  //   pageSize: number,
+  //   startedMessageId: string,
+  // ): Promise<Array<FcrChatRoomReceiveBaseMessage>> {
+  //   if (pageSize > 50) {
+  //     throw generateFcrCoreClientError(
+  //       FcrErrorModuleCode.ROOM_CHATROOM,
+  //       FcrErrorCode.UNDEFINED_ERROR,
+  //       'pageSize should be less than 50',
+  //       new Error('pageSize should be less than 50'),
+  //     );
+  //   }
+
+  //   const assembleRet = await this.conn.fetchHistoryMessages({
+  //     queue: this.initConfig.chatRoomId,
+  //     isGroup: true,
+  //     count: pageSize,
+  //     start: startedMessageId,
+  //     fail(error) {
+  //       throw generateFcrCoreClientError(
+  //         FcrErrorModuleCode.ROOM_CHATROOM,
+  //         FcrErrorCode.UNDEFINED_ERROR,
+  //         error.message,
+  //         new Error('get history message list failed'),
+  //       );
+  //     },
+  //   });
+
+  //   const ret: FcrChatRoomReceiveBaseMessage[] = assembleRet.map((msgBody) => {
+  //     return this._convertAgoraChatMessageToFcrChatRoomReceiveMessage(msgBody);
+  //   });
+  //   return ret;
+  // }
+
+  // TODO: 3.x
+  // async getAnnouncement(): Promise<string> {
+  //   const announcement = await this.conn.fetchChatRoomAnnouncement({
+  //     roomId: this.initConfig.chatRoomId,
+  //     error: (e) => {
+  //       throw generateFcrCoreClientError(
+  //         FcrErrorModuleCode.ROOM_CHATROOM,
+  //         FcrErrorCode.UNDEFINED_ERROR,
+  //         e.message,
+  //         new Error('get announcement failed'),
+  //       );
+  //     },
+  //   });
+
+  //   return announcement.data?.announcement || '';
+  // }
+
+  // TODO: 3.x
+  // async setAnnouncement(announcement: string) {
+  //   await this.conn.updateChatRoomAnnouncement({
+  //     roomId: this.initConfig.chatRoomId,
+  //     announcement,
+  //     success: (_) => {},
+  //     error: (e) => {
+  //       throw generateFcrCoreClientError(
+  //         FcrErrorModuleCode.ROOM_CHATROOM,
+  //         FcrErrorCode.UNDEFINED_ERROR,
+  //         e.message,
+  //         new Error('set announcement failed'),
+  //       );
+  //     },
+  //   });
+  // }
+
+  // TODO: 3.x
+  // async deleteAnnouncement() {
+  //   await this.conn.updateChatRoomAnnouncement({
+  //     roomId: this.initConfig.chatRoomId,
+  //     announcement: '',
+  //     success: (_) => {},
+  //     error: (e) => {
+  //       const { message } = e;
+  //       throw generateFcrCoreClientError(
+  //         FcrErrorModuleCode.ROOM_CHATROOM,
+  //         FcrErrorCode.UNDEFINED_ERROR,
+  //         message,
+  //         new Error('delete announcement failed'),
+  //       );
+  //     },
+  //   });
+  // }
+}
+exports.FcrChatRoomControlImpl = FcrChatRoomControlImpl;

package/lib/room-control/chatroom-control/type.d.ts

@@ -0,0 +1,95 @@
+import { FcrUserInfo } from '../../type';
+import { FcrError } from '../../utilities/error';
+export interface FcrChatRoomControl {
+    join(): Promise<void>;
+    /**
+     * Gets the connection state of the chat room.
+     */
+    getConnectionState(): FcrChatRoomConnectionState;
+    /**
+     * Sends a message to the chat room.
+     * @param message
+     */
+    sendMessage(message: FcrChatRoomSendBaseMessage): Promise<FcrChatRoomReceiveBaseMessage>;
+    /**
+     * Adds an observer to the chat room.
+     * @param observer
+     */
+    addObserver(observer: FcrChatRoomObserver): void;
+    /**
+     * Removes the observer from the chat room.
+     * @param observer
+     */
+    removeObserver(observer: FcrChatRoomObserver): void;
+}
+export declare enum FcrChatRoomConnectionState {
+    Disconnected = 0,
+    Connecting = 1,
+    Connected = 2
+}
+export declare enum FcrChatRoomMessageType {
+    Text = "text",
+    Image = "image",
+    Custom = "custom"
+}
+export type FcrChatRoomSendBaseMessage = {
+    type: FcrChatRoomMessageType;
+    properties?: Record<string, unknown>;
+    to?: string[];
+};
+export type FcrChatRoomSendTextMessage = FcrChatRoomSendBaseMessage & {
+    content: string;
+};
+export type FcrChatRoomReceiveBaseMessage = {
+    id: string;
+    from: FcrUserInfo;
+    type: FcrChatRoomMessageType;
+    properties?: Record<string, unknown>;
+    timestamp: number;
+    isPrivate: boolean;
+};
+export type FcrChatRoomReceiveTextMessage = FcrChatRoomReceiveBaseMessage & {
+    content: string;
+};
+export type FcrChatRoomFile = {
+    filename: string;
+    filetype: string;
+    url: string;
+    data: any;
+};
+export type FcrChatRoomReceiveImageMessage = FcrChatRoomReceiveBaseMessage & {
+    file: FcrChatRoomFile;
+};
+export type FcrChatRoomSendImageMessage = FcrChatRoomSendBaseMessage & {
+    file: FcrChatRoomFile;
+};
+export type FcrChatRoomReceiveCustomMessage = FcrChatRoomReceiveBaseMessage & {};
+export type FcrChatRoomObserver = {
+    /**
+     * Callback to receive the connection state change of the chat room.
+     * @param roomId
+     * @param state
+     * @returns
+     */
+    onConnectionStateUpdated?: (roomId: string, state: FcrChatRoomConnectionState) => void;
+    /**
+     * Callback to receive the message sent to the chat room.
+     * @param roomId
+     * @param message
+     * @returns
+     */
+    onTextMessageReceived?: (roomId: string, message: FcrChatRoomReceiveTextMessage) => void;
+    /**
+     * Callback when an error occurs.
+     * @param roomId
+     * @param error
+     * @returns
+     */
+    onErrorOccurred?: (roomId: string, error: FcrError) => void;
+};
+export type FcrChatRoomControlInitConfig = {
+    appkey: string;
+    token: string;
+    roomId: string;
+    userInfo: FcrUserInfo;
+};

package/lib/room-control/chatroom-control/type.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrChatRoomMessageType = exports.FcrChatRoomConnectionState = void 0;
+let FcrChatRoomConnectionState = exports.FcrChatRoomConnectionState = /*#__PURE__*/function (FcrChatRoomConnectionState) {
+  FcrChatRoomConnectionState[FcrChatRoomConnectionState["Disconnected"] = 0] = "Disconnected";
+  FcrChatRoomConnectionState[FcrChatRoomConnectionState["Connecting"] = 1] = "Connecting";
+  FcrChatRoomConnectionState[FcrChatRoomConnectionState["Connected"] = 2] = "Connected";
+  return FcrChatRoomConnectionState;
+}({});
+let FcrChatRoomMessageType = exports.FcrChatRoomMessageType = /*#__PURE__*/function (FcrChatRoomMessageType) {
+  FcrChatRoomMessageType["Text"] = "text";
+  FcrChatRoomMessageType["Image"] = "image";
+  FcrChatRoomMessageType["Custom"] = "custom";
+  return FcrChatRoomMessageType;
+}({});

package/lib/room-control/group-control/index.d.ts

@@ -0,0 +1,25 @@
+import { AgoraRteEngine, AgoraRteScene } from '../../imports';
+import { FcrCoreEngineConfig, FcrGroupCreateConfig, FcrGroupInfo, FcrGroupObserver, FcrGroupUpdateOptions } from '../../type';
+import { FcrCoreServiceApi } from '../../service/api';
+export declare class FcrGroupControl {
+    private _engine;
+    private _scene;
+    private _api;
+    private _config;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _observable;
+    constructor(_engine: AgoraRteEngine, _scene: AgoraRteScene, _api: FcrCoreServiceApi, _config: FcrCoreEngineConfig);
+    private _addSceneObserver;
+    private _getGroupDetails;
+    getGroupList(): FcrGroupInfo[];
+    getGroupUserList(groupId: string): string[];
+    addGroups(groups: FcrGroupCreateConfig[]): Promise<void>;
+    updateGroups(groups: FcrGroupUpdateOptions[]): Promise<void>;
+    deleteGroups(groupIds: string[]): Promise<void>;
+    deleteAllGroups(): Promise<void>;
+    addUsers(userList: string[], groupId: string): Promise<void>;
+    removeUsers(userList: string[], groupId: string): Promise<void>;
+    moveUsers(userList: string[], fromGroupId: string, toGroupId: string): Promise<void>;
+    addObserver(observer: FcrGroupObserver): void;
+    removeObserver(observer: FcrGroupObserver): void;
+}

package/lib/room-control/group-control/index.js

@@ -0,0 +1,227 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrGroupControl = void 0;
+require("core-js/modules/es.array.push.js");
+require("core-js/modules/esnext.async-iterator.for-each.js");
+require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.map.delete-all.js");
+require("core-js/modules/esnext.map.emplace.js");
+require("core-js/modules/esnext.map.every.js");
+require("core-js/modules/esnext.map.filter.js");
+require("core-js/modules/esnext.map.find.js");
+require("core-js/modules/esnext.map.find-key.js");
+require("core-js/modules/esnext.map.includes.js");
+require("core-js/modules/esnext.map.key-of.js");
+require("core-js/modules/esnext.map.map-keys.js");
+require("core-js/modules/esnext.map.map-values.js");
+require("core-js/modules/esnext.map.merge.js");
+require("core-js/modules/esnext.map.reduce.js");
+require("core-js/modules/esnext.map.some.js");
+require("core-js/modules/esnext.map.update.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _imports = require("../../imports");
+var _user = require("../../utilities/user");
+class FcrGroupControl {
+  constructor(_engine, _scene, _api, _config) {
+    (0, _defineProperty2.default)(this, "logger", (0, _imports.getLogger)());
+    (0, _defineProperty2.default)(this, "_observable", new _imports.AgoraObservable());
+    this._engine = _engine;
+    this._scene = _scene;
+    this._api = _api;
+    this._config = _config;
+    this._addSceneObserver();
+  }
+  _addSceneObserver() {
+    const observer = {
+      onScenePropertiesUpdated: (sceneId, event) => {
+        var _event$cause;
+        if (((_event$cause = event.cause) === null || _event$cause === void 0 ? void 0 : _event$cause.cmd) === 11) {
+          const data = event.cause.data;
+          const changedProperties = event.changedProperties;
+          const groupDetails = changedProperties.groups.details;
+          const groupEvents = Object.keys(groupDetails).map(groupId => {
+            return {
+              info: {
+                groupId,
+                groupName: groupDetails[groupId].groupName
+              },
+              operatorUser: event.operatorUser && (0, _user.convertRteUserToFcrUser)(event.operatorUser)
+            };
+          });
+          if (data.actionType === 2) {
+            if (data.removeGroupUuids) {
+              this._observable.notifyObservers('onGroupsRemoved', groupEvents);
+            } else {
+              this._observable.notifyObservers('onGroupsAdded', groupEvents);
+            }
+          }
+          if (data.actionType === 3) {
+            this._observable.notifyObservers('onGroupsUpdated', groupEvents);
+          }
+          if (data.actionType === 4) {
+            var _data$changeGroups, _data$changeGroups2, _data$changeGroups3;
+            (_data$changeGroups = data.changeGroups) === null || _data$changeGroups === void 0 || _data$changeGroups.forEach(group => {
+              const {
+                removeUsers,
+                groupUuid
+              } = group;
+              if (removeUsers) {
+                this._observable.notifyObservers('onUserListRemovedFromGroup', removeUsers.map(user => {
+                  return {
+                    groupId: groupUuid,
+                    userId: user.userUuid,
+                    reason: user.reason,
+                    operatorUser: event.operatorUser && (0, _user.convertRteUserToFcrUser)(event.operatorUser)
+                  };
+                }));
+              }
+            });
+            const toGroupMap = new Map();
+            (_data$changeGroups2 = data.changeGroups) === null || _data$changeGroups2 === void 0 || _data$changeGroups2.forEach(group => {
+              const {
+                removeUsers
+              } = group;
+              if (removeUsers) {
+                removeUsers.forEach(user => {
+                  if (user.toGroupUuid) {
+                    const toGroup = toGroupMap.get(user.toGroupUuid);
+                    if (toGroup) {
+                      toGroup.userList.push({
+                        userUuid: user.userUuid,
+                        reason: user.reason,
+                        toGroupUuid: user.toGroupUuid
+                      });
+                    } else {
+                      toGroupMap.set(user.toGroupUuid, {
+                        fromGroupId: group.groupUuid,
+                        userList: [{
+                          userUuid: user.userUuid,
+                          reason: user.reason,
+                          toGroupUuid: user.toGroupUuid
+                        }]
+                      });
+                    }
+                  }
+                });
+              }
+            });
+            toGroupMap.forEach((toGroupInfo, toGroupUuid) => {
+              this._observable.notifyObservers('onUserListMoveToGroup', toGroupInfo.userList.map(user => {
+                return {
+                  fromGroupId: toGroupInfo.fromGroupId,
+                  toGroupId: toGroupUuid,
+                  userId: user.userUuid,
+                  reason: user.reason,
+                  operatorUser: event.operatorUser && (0, _user.convertRteUserToFcrUser)(event.operatorUser)
+                };
+              }));
+            });
+            (_data$changeGroups3 = data.changeGroups) === null || _data$changeGroups3 === void 0 || _data$changeGroups3.forEach(group => {
+              const {
+                addUsers,
+                groupUuid
+              } = group;
+              if (addUsers) {
+                this._observable.notifyObservers('onUserListAddedToGroup', addUsers.map(user => {
+                  return {
+                    groupId: groupUuid,
+                    userId: user.userUuid,
+                    operatorUser: event.operatorUser && (0, _user.convertRteUserToFcrUser)(event.operatorUser)
+                  };
+                }));
+              }
+            });
+          }
+        }
+      }
+    };
+    this._scene.addObserver(observer);
+  }
+  _getGroupDetails() {
+    return this._scene.getScenePropertiesByKeyPath('groups.details');
+  }
+  getGroupList() {
+    const groupDetails = this._getGroupDetails();
+    const list = [];
+    Object.keys(groupDetails).forEach(groupId => {
+      const {
+        groupName
+      } = groupDetails[groupId];
+      list.push({
+        groupId,
+        groupName
+      });
+    });
+    return list;
+  }
+  getGroupUserList(groupId) {
+    const groupDetails = this._getGroupDetails();
+    const groupInfo = groupDetails[groupId];
+    if (groupInfo) {
+      return groupInfo.users.map(user => user.userUuid);
+    } else {
+      this.logger.warn('group not found', groupId);
+      return [];
+    }
+  }
+  addGroups(groups) {
+    return this._api.addGroups(groups, {
+      roomId: this._scene.sceneId,
+      startTime: Date.now()
+    });
+  }
+  updateGroups(groups) {
+    return this._api.updateGroups(groups, {
+      roomId: this._scene.sceneId
+    });
+  }
+  deleteGroups(groupIds) {
+    return this._api.deleteGroups(groupIds, {
+      roomId: this._scene.sceneId
+    });
+  }
+  deleteAllGroups() {
+    return this._api.deleteAllGroups({
+      roomId: this._scene.sceneId
+    });
+  }
+  addUsers(userList, groupId) {
+    return this._api.addUsers(userList, groupId, {
+      roomId: this._scene.sceneId
+    });
+  }
+  removeUsers(userList, groupId) {
+    return this._api.removeUsers(userList, groupId, {
+      roomId: this._scene.sceneId
+    });
+  }
+  moveUsers(userList, fromGroupId, toGroupId) {
+    return this._api.moveUsers(userList, fromGroupId, toGroupId, {
+      roomId: this._scene.sceneId
+    });
+  }
+  // createSubRoomControl(groupId: string) {
+  //   return new FcrSubRoomControlImpl(
+  //     this._engine,
+  //     this._engine.createScene({ sceneId: groupId }),
+  //     this._api,
+  //     this._config,
+  //     101
+  //   );
+  // }
+  addObserver(observer) {
+    this._observable.addObserver(observer);
+  }
+  removeObserver(observer) {
+    this._observable.removeObserver(observer);
+  }
+}
+exports.FcrGroupControl = FcrGroupControl;

package/lib/room-control/index.d.ts

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