agora-rte-sdk 2.8.50 → 2.8.52

package/lib/core/media/loopback.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from '../logger';
+import { AGRtcManager } from '../rtc';
+import { AGRtcConnectionType } from '../rtc/channel';
+import { AgoraRteMediaSourceState } from '../rtc/type';
+import { AGEventEmitter } from '../utils/events';
+export declare class AgoraRteLoopbackDevice extends AGEventEmitter {
+    logger: Logger;
+    private _rtc;
+    private _state;
+    private _volume;
+    private _device?;
+    get device(): string | undefined;
+    get state(): AgoraRteMediaSourceState;
+    get volume(): number;
+    constructor(rtc: AGRtcManager);
+    setDevice(deviceName: string): void;
+    startRecording(connType?: AGRtcConnectionType): void;
+    stopRecording(connType?: AGRtcConnectionType): void;
+    updateSignalVolume(volume: number, connType?: AGRtcConnectionType): void;
+}

package/lib/core/media/loopback.js

@@ -0,0 +1,90 @@
+"use strict";
+
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgoraRteLoopbackDevice = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _decorator = require("../decorator");
+var _type = require("../rtc/type");
+var _events = require("../utils/events");
+var _dec, _class;
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+var AgoraRteLoopbackDevice = exports.AgoraRteLoopbackDevice = (_dec = _decorator.Log.attach(), _dec(_class = /*#__PURE__*/function (_AGEventEmitter) {
+  (0, _inherits2["default"])(AgoraRteLoopbackDevice, _AGEventEmitter);
+  var _super = _createSuper(AgoraRteLoopbackDevice);
+  function AgoraRteLoopbackDevice(rtc) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, AgoraRteLoopbackDevice);
+    _this = _super.call(this);
+    _this.logger = void 0;
+    _this._rtc = void 0;
+    _this._state = _type.AgoraRteMediaSourceState.stopped;
+    _this._volume = 0;
+    _this._device = void 0;
+    _this._rtc = rtc;
+    return _this;
+  }
+  (0, _createClass2["default"])(AgoraRteLoopbackDevice, [{
+    key: "device",
+    get: function get() {
+      return this._device;
+    }
+  }, {
+    key: "state",
+    get: function get() {
+      return this._state;
+    }
+  }, {
+    key: "volume",
+    get: function get() {
+      return this._volume;
+    }
+  }, {
+    key: "setDevice",
+    value: function setDevice(deviceName) {
+      this._device = deviceName;
+    }
+  }, {
+    key: "startRecording",
+    value: function startRecording(connType) {
+      if (this._state !== _type.AgoraRteMediaSourceState.started) {
+        var code = this._rtc.enableLoopbackRecording(true, this._device, connType);
+        if (code === 0) {
+          this._state = _type.AgoraRteMediaSourceState.started;
+        } else {
+          this._state = _type.AgoraRteMediaSourceState.error;
+        }
+      }
+    }
+  }, {
+    key: "stopRecording",
+    value: function stopRecording(connType) {
+      if (this._state !== _type.AgoraRteMediaSourceState.stopped) {
+        var code = this._rtc.enableLoopbackRecording(false, this._device, connType);
+        if (code === 0) {
+          this._state = _type.AgoraRteMediaSourceState.stopped;
+        } else {
+          this._state = _type.AgoraRteMediaSourceState.error;
+        }
+      }
+    }
+  }, {
+    key: "updateSignalVolume",
+    value: function updateSignalVolume(volume, connType) {
+      if (volume !== this._volume) {
+        this._volume = volume;
+        this._rtc.adjustLoopbackSignalVolume(volume, connType);
+      }
+    }
+  }]);
+  return AgoraRteLoopbackDevice;
+}(_events.AGEventEmitter)) || _class);

package/lib/core/processor/message-handler.js

@@ -47,6 +47,7 @@ require("core-js/modules/esnext.set.symmetric-difference.js");
 require("core-js/modules/esnext.set.union.js");
 require("core-js/modules/web.dom-collections.iterator.js");
 require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.concat.js");
 require("core-js/modules/es.map.js");
 require("core-js/modules/esnext.map.delete-all.js");
 require("core-js/modules/esnext.map.every.js");
@@ -61,7 +62,6 @@ 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/es.array.concat.js");
 require("core-js/modules/es.date.now.js");
 require("core-js/modules/es.date.to-string.js");
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
@@ -325,11 +325,16 @@ var AgoraRteMessageHandle = (_dec = _decorator.Log.attach({
           var streamUuids = _streams.map(function (stream) {
             return stream.streamUuid;
           });
-          _this3._dataStore.deleteStreams(streamUuids);
-          _this3._dataStore.deleteUser(u.userUuid);
+          if (_this3.userUuid !== u.userUuid) {
+            _this3._dataStore.deleteUser(u.userUuid);
+            _this3.logger.info("unsubscribe remote user, delete user and streams from data store, userUuid: ".concat(u.userUuid, ", streams: ").concat(streamUuids.join(',')));
+          } else {
+            _this3.logger.info('unsubscribe local user');
+          }
           if (_streams.length) {
             removedStreamsData = _streams;
           }
+          _this3._dataStore.deleteStreams(streamUuids);
           unsubscribeUsersData.push(user);
         }
       });
@@ -355,11 +360,16 @@ var AgoraRteMessageHandle = (_dec = _decorator.Log.attach({
         var streamUuids = streams.map(function (stream) {
           return stream.streamUuid;
         });
-        _this4._dataStore.deleteStreams(streamUuids);
-        _this4._dataStore.deleteUser(u.userUuid);
+        if (_this4.userUuid !== u.userUuid) {
+          _this4._dataStore.deleteUser(u.userUuid);
+          _this4.logger.info("remote user is offline, delete user and streams from data store, userUuid: ".concat(u.userUuid, ", streams: ").concat(streamUuids.join(',')));
+        } else {
+          _this4.logger.info('local user is offline');
+        }
         if (streams.length) {
           removedStreamsData = streams;
         }
+        _this4._dataStore.deleteStreams(streamUuids);
         return user;
       });
       var onlineUsersData = onlineUsers.map(function (u) {

package/lib/core/processor/struct.d.ts

@@ -0,0 +1,54 @@
+import Immutable from 'immutable';
+import { AgoraFromUser, IAgoraRoomData, IAgoraRoomStateData, IAgoraStreamData, IAgoraUserData } from './type';
+import { AgoraRteVideoSourceType, AgoraRteAudioSourceType, AgoraRteMediaPublishState } from '../media/track';
+import { AgoraRteMediaSourceState } from '../rtc/type';
+export declare class AgoraUser {
+    static fromData(data: any): AgoraUser;
+    userUuid: string;
+    userName: string;
+    userRole: string;
+    userProperties: Immutable.Map<any, any>;
+    constructor(data: IAgoraUserData);
+    setUserProperties(userProperties: any): void;
+    toString(): string;
+}
+export declare class AgoraStream {
+    static fromData(data: IAgoraStreamData): AgoraStream;
+    streamUuid: string;
+    streamName: string;
+    fromUser: AgoraFromUser;
+    videoSourceType: AgoraRteVideoSourceType;
+    audioSourceType: AgoraRteAudioSourceType;
+    videoState: AgoraRteMediaPublishState;
+    audioState: AgoraRteMediaPublishState;
+    videoSourceState: AgoraRteMediaSourceState;
+    audioSourceState: AgoraRteMediaSourceState;
+    playUrl?: string;
+    flvPlayUrl?: string;
+    rtmpPlayUrl?: string;
+    previous?: AgoraStream;
+    constructor(data: IAgoraStreamData);
+    toString(): string;
+}
+export declare class AgoraRoom {
+    static fromData(data: any): AgoraRoom;
+    roomName: string;
+    roomUuid: string;
+    roomScenario: string;
+    constructor(data: IAgoraRoomData);
+}
+export declare class AgoraRoomState {
+    static fromData(data: IAgoraRoomStateData): AgoraRoomState;
+    total: number;
+    constructor(data: IAgoraRoomStateData);
+}
+export declare class AgoraRteSyncSnapshotData {
+    static fromData(data: any): AgoraRteSyncSnapshotData;
+    sequence: number;
+    users: Map<string, AgoraUser>;
+    streams: Map<string, AgoraStream>;
+    roomProperties: Immutable.Map<unknown, unknown>;
+    room: AgoraRoom;
+    roomState: AgoraRoomState;
+    constructor(data: any);
+}

package/lib/core/processor/struct.js

@@ -0,0 +1,200 @@
+"use strict";
+
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.symbol.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.get-own-property-descriptors.js");
+require("core-js/modules/es.object.define-properties.js");
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgoraUser = exports.AgoraStream = exports.AgoraRteSyncSnapshotData = exports.AgoraRoomState = exports.AgoraRoom = void 0;
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/esnext.map.delete-all.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");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _immutable = _interopRequireDefault(require("immutable"));
+var _logger = require("../logger");
+var _error = require("../utils/error");
+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; }
+var AgoraUser = exports.AgoraUser = /*#__PURE__*/function () {
+  function AgoraUser(data) {
+    (0, _classCallCheck2["default"])(this, AgoraUser);
+    this.userUuid = void 0;
+    this.userName = void 0;
+    this.userRole = void 0;
+    this.userProperties = void 0;
+    this.userName = data.userName;
+    this.userRole = data.role;
+    this.userUuid = data.userUuid;
+    this.userProperties = _immutable["default"].Map(data.userProperties);
+  }
+  (0, _createClass2["default"])(AgoraUser, [{
+    key: "setUserProperties",
+    value: function setUserProperties(userProperties) {
+      this.userProperties = _immutable["default"].Map(userProperties);
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.userUuid;
+    }
+  }], [{
+    key: "fromData",
+    value: function fromData(data) {
+      return new AgoraUser(data);
+    }
+  }]);
+  return AgoraUser;
+}();
+var AgoraStream = exports.AgoraStream = /*#__PURE__*/function () {
+  function AgoraStream(data) {
+    (0, _classCallCheck2["default"])(this, AgoraStream);
+    this.streamUuid = void 0;
+    this.streamName = void 0;
+    this.fromUser = void 0;
+    this.videoSourceType = void 0;
+    this.audioSourceType = void 0;
+    this.videoState = void 0;
+    this.audioState = void 0;
+    this.videoSourceState = void 0;
+    this.audioSourceState = void 0;
+    this.playUrl = void 0;
+    this.flvPlayUrl = void 0;
+    this.rtmpPlayUrl = void 0;
+    this.previous = void 0;
+    this.streamUuid = data.streamUuid;
+    this.streamName = data.streamName;
+    this.fromUser = data.fromUser;
+    this.videoSourceType = data.videoSourceType;
+    this.audioSourceType = data.audioSourceType;
+    this.videoState = data.videoState;
+    this.audioState = data.audioState;
+    this.videoSourceState = data.videoSourceState;
+    this.audioSourceState = data.audioSourceState;
+    this.playUrl = data.playUrl;
+    this.flvPlayUrl = data.flvPlayUrl;
+    this.rtmpPlayUrl = data.rtmpPlayUrl;
+    ['streamUuid', 'fromUser', 'videoSourceType', 'audioSourceType', 'videoState', 'audioState', 'videoSourceState', 'audioSourceState'].forEach(function (key) {
+      var value = data[key];
+      if (value === undefined) {
+        _logger.Logger.warn("stream key ".concat(key, " is unexpectedly undefined"));
+      }
+    });
+    if (!this.fromUser) {
+      _logger.Logger.error("[stream-data-struct] stream must have owner info");
+      _error.RteErrorCenter.shared.handleThrowableError(_error.AGRteErrorCode.RTE_ERR_INVALID_DATA_STRUCT, new Error("invalid stream data"));
+    }
+  }
+  (0, _createClass2["default"])(AgoraStream, [{
+    key: "toString",
+    value: function toString() {
+      return this.streamUuid;
+    }
+  }], [{
+    key: "fromData",
+    value: function fromData(data) {
+      return new AgoraStream(data);
+    }
+  }]);
+  return AgoraStream;
+}();
+var AgoraRoom = exports.AgoraRoom = /*#__PURE__*/function () {
+  function AgoraRoom(data) {
+    (0, _classCallCheck2["default"])(this, AgoraRoom);
+    this.roomName = void 0;
+    this.roomUuid = void 0;
+    this.roomScenario = void 0;
+    this.roomName = data.roomName;
+    this.roomUuid = data.roomUuid;
+    this.roomScenario = data.roomScenario;
+  }
+  (0, _createClass2["default"])(AgoraRoom, null, [{
+    key: "fromData",
+    value: function fromData(data) {
+      return new AgoraRoom(data);
+    }
+  }]);
+  return AgoraRoom;
+}();
+var AgoraRoomState = exports.AgoraRoomState = /*#__PURE__*/function () {
+  function AgoraRoomState(data) {
+    (0, _classCallCheck2["default"])(this, AgoraRoomState);
+    this.total = void 0;
+    this.total = data.total;
+  }
+  (0, _createClass2["default"])(AgoraRoomState, null, [{
+    key: "fromData",
+    value: function fromData(data) {
+      return new AgoraRoomState(data);
+    }
+  }]);
+  return AgoraRoomState;
+}();
+var AgoraRteSyncSnapshotData = exports.AgoraRteSyncSnapshotData = /*#__PURE__*/function () {
+  function AgoraRteSyncSnapshotData(data) {
+    var _this = this;
+    (0, _classCallCheck2["default"])(this, AgoraRteSyncSnapshotData);
+    this.sequence = void 0;
+    this.users = new Map();
+    this.streams = new Map();
+    this.roomProperties = _immutable["default"].Map();
+    this.room = void 0;
+    this.roomState = void 0;
+    var sequence = data.sequence,
+      users = data.users,
+      roomProperties = data.roomProperties,
+      roomInfo = data.roomInfo,
+      roomState = data.roomState;
+    this.sequence = sequence;
+    users.forEach(function (u) {
+      var user = AgoraUser.fromData(u);
+      var _u$streams = u.streams,
+        streams = _u$streams === void 0 ? [] : _u$streams;
+      streams.forEach(function (s) {
+        _this.streams.set(s.streamUuid, AgoraStream.fromData(_objectSpread(_objectSpread({}, s), {}, {
+          fromUser: {
+            userName: user.userName,
+            role: user.userRole,
+            userUuid: user.userUuid
+          }
+        })));
+      });
+      _this.users.set(u.userUuid, user);
+    });
+    this.roomProperties = _immutable["default"].Map(roomProperties);
+    this.room = AgoraRoom.fromData(roomInfo);
+    this.roomState = AgoraRoomState.fromData(roomState);
+  }
+  (0, _createClass2["default"])(AgoraRteSyncSnapshotData, null, [{
+    key: "fromData",
+    value: function fromData(data) {
+      var snapshot = new AgoraRteSyncSnapshotData(data);
+      return snapshot;
+    }
+  }]);
+  return AgoraRteSyncSnapshotData;
+}();

package/lib/core/rtm/type.d.ts

@@ -0,0 +1,49 @@
+import { AgoraRteUser } from '../processor/type';
+export declare enum AgoraRtmConnectionState {
+    DISCONNECTED = "DISCONNECTED",
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    RECONNECTING = "RECONNECTING",
+    ABORTED = "ABORTED"
+}
+export interface AGRtmManagerInitConfig {
+    uploadLog?: boolean;
+}
+export declare type AgoraRteCustomMessage = {
+    fromUser: AgoraRteUser;
+    payload: AgoraRteCustomMessagePayload;
+};
+export declare type AgoraRteCustomMessagePayload = {
+    cmd: string;
+    data: any;
+};
+/**
+ * 自定义RTM消息观察者
+ */
+/** @en
+ *
+ */
+export declare type AgoraRteCustomMessageObserver = {
+    /**
+     * 收到点对点消息
+     * @param message
+     * @returns
+     */
+    /** @en
+     *
+     * @param message
+     * @returns
+     */
+    onReceivePeerMessage: (message: AgoraRteCustomMessage) => void;
+    /**
+     * 收到频道消息
+     * @param message
+     * @returns
+     */
+    /** @en
+     *
+     * @param message
+     * @returns
+     */
+    onReceiveChannelMessage: (message: AgoraRteCustomMessage) => void;
+};

package/lib/core/rtm/type.js

@@ -0,0 +1,21 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AgoraRtmConnectionState = void 0;
+var AgoraRtmConnectionState = exports.AgoraRtmConnectionState = /*#__PURE__*/function (AgoraRtmConnectionState) {
+  AgoraRtmConnectionState["DISCONNECTED"] = "DISCONNECTED";
+  AgoraRtmConnectionState["CONNECTING"] = "CONNECTING";
+  AgoraRtmConnectionState["CONNECTED"] = "CONNECTED";
+  AgoraRtmConnectionState["RECONNECTING"] = "RECONNECTING";
+  AgoraRtmConnectionState["ABORTED"] = "ABORTED";
+  return AgoraRtmConnectionState;
+}({});
+/**
+ * 自定义RTM消息观察者
+ */
+/** @en
+ *
+ */

package/lib/core/services/domain-region-map.d.ts

@@ -0,0 +1,7 @@
+export declare const commonDomains: string[];
+export declare const domainRegionMap: {
+    AP: string[];
+    CN: string[];
+    EU: string[];
+    NA: string[];
+};

package/lib/core/services/domain-region-map.js

@@ -0,0 +1,13 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.domainRegionMap = exports.commonDomains = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _type = require("../../type");
+var _domainRegionMap;
+var commonDomains = exports.commonDomains = ['https://api.sd-rtn.com', 'https://api.agora.io'];
+var domainRegionMap = exports.domainRegionMap = (_domainRegionMap = {}, (0, _defineProperty2["default"])(_domainRegionMap, _type.AgoraRegion.AP, [commonDomains[1], 'https://api-ap-northeast-1.sd-rtn.com', 'https://api-ap-southeast-1.agora.io', commonDomains[0], 'https://api-ap-northeast-1.agora.io', 'https://api-ap-southeast-1.sd-rtn.com']), (0, _defineProperty2["default"])(_domainRegionMap, _type.AgoraRegion.CN, [commonDomains[0], 'https://api-cn-north-1.agora.io', 'https://api-cn-east-1.sd-rtn.com', commonDomains[1], 'https://api-cn-north-1.sd-rtn.com', 'https://api-cn-east-1.agora.io']), (0, _defineProperty2["default"])(_domainRegionMap, _type.AgoraRegion.EU, [commonDomains[1], 'https://api-eu-central-1.sd-rtn.com', 'https://api-eu-west-1.agora.io', commonDomains[0], 'https://api-eu-central-1.agora.io', 'https://api-eu-west-1.sd-rtn.com']), (0, _defineProperty2["default"])(_domainRegionMap, _type.AgoraRegion.NA, [commonDomains[1], 'https://api-us-east-1.sd-rtn.com', 'https://api-us-west-1.agora.io', commonDomains[0], 'https://api-us-east-1.agora.io', 'https://api-us-west-1.sd-rtn.com']), _domainRegionMap);

package/lib/core/services/fallback-request-handler.d.ts

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