agora-rte-sdk 3.8.2 → 3.9.0-alpha

package/lib/core/scene/helpers/rtc-event.js

@@ -0,0 +1,36 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.relayRtcChannelEvents = void 0;
+var relayRtcChannelEvents = exports.relayRtcChannelEvents = function relayRtcChannelEvents(rtcChannelClient, observable) {
+  rtcChannelClient.addObserver({
+    onNetworkQualityUpdated: function onNetworkQualityUpdated(streamId, txQuality, rxQuality, channelId) {
+      observable.notifyObservers('onNetworkQualityUpdated', channelId, {
+        streamId: streamId,
+        txQuality: txQuality,
+        rxQuality: rxQuality
+      });
+    },
+    onNetworkStatsUpdated: function onNetworkStatsUpdated(stats, channelId) {
+      observable.notifyObservers('onNetworkStatsUpdated', channelId, stats);
+    },
+    onLocalVideoStatsUpdated: function onLocalVideoStatsUpdated(channelId, streamId, stats) {
+      observable.notifyObservers('onLocalVideoStatsUpdated', channelId, streamId, stats);
+    },
+    onLocalAudioStatsUpdated: function onLocalAudioStatsUpdated(channelId, streamId, stats) {
+      observable.notifyObservers('onLocalAudioStatsUpdated', channelId, streamId, stats);
+    },
+    onRemoteVideoStatsUpdated: function onRemoteVideoStatsUpdated(channelId, streamId, stats) {
+      observable.notifyObservers('onRemoteVideoStatsUpdated', channelId, streamId, stats);
+    },
+    onRemoteAudioStatsUpdated: function onRemoteAudioStatsUpdated(channelId, streamId, stats) {
+      observable.notifyObservers('onRemoteAudioStatsUpdated', channelId, streamId, stats);
+    },
+    onFirstRemoteVideoFrameRendered: function onFirstRemoteVideoFrameRendered(streamId, channelId) {
+      observable.notifyObservers('onFirstRemoteVideoFrameRendered', channelId, streamId);
+    }
+  });
+};

package/lib/core/scene/helpers/stream-publish-handlers.d.ts

@@ -0,0 +1,15 @@
+import type { AgoraRtcChannelClient } from '../../rtc/channel';
+import { AgoraRteMediaStreamInfo, AgoraRteLocalUser } from '../type';
+/**
+ * Handle streams published event - republish audio/video streams through RTC
+ * @param streams Array of stream info to be published
+ * @param rtcChannelClient RTC channel client for publishing
+ * @param localUser Local user for token management
+ */
+export declare function handleStreamsPublished(streams: AgoraRteMediaStreamInfo[], rtcChannelClient: AgoraRtcChannelClient, localUser: AgoraRteLocalUser, screenStreamLabelMap: Map<string, Map<string, string>>): void;
+/**
+ * Handle streams unpublished event - stop publishing audio/video streams through RTC
+ * @param streams Array of stream info to be unpublished
+ * @param rtcChannelClient RTC channel client for unpublishing
+ */
+export declare function handleStreamsUnPublished(streams: AgoraRteMediaStreamInfo[], rtcChannelClient: AgoraRtcChannelClient): void;

package/lib/core/scene/helpers/stream-publish-handlers.js

@@ -0,0 +1,121 @@
+"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.handleStreamsPublished = handleStreamsPublished;
+exports.handleStreamsUnPublished = handleStreamsUnPublished;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _type = require("../type");
+var _logger = require("../../utilities/logger");
+var _type2 = require("../../../type");
+var logger = (0, _logger.createLogger)({
+  prefix: 'StreamHandlers'
+});
+
+/**
+ * Handle streams published event - republish audio/video streams through RTC
+ * @param streams Array of stream info to be published
+ * @param rtcChannelClient RTC channel client for publishing
+ * @param localUser Local user for token management
+ */
+function handleStreamsPublished(streams, rtcChannelClient, localUser, screenStreamLabelMap) {
+  streams.forEach(/*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(stream) {
+      var streamToken, shouldPublishAudio, shouldPublishVideo, localLabelSourceType, sourceType, observer;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (stream.connectorType === _type.AgoraRteRoomConnectorType.NONE) {
+              streamToken = localUser.getStreamTokenByStreamId(stream.streamId);
+              shouldPublishAudio = stream.streamType === _type.AgoraRteMediaStreamType.BOTH || stream.streamType === _type.AgoraRteMediaStreamType.AUDIO;
+              shouldPublishVideo = stream.streamType === _type.AgoraRteMediaStreamType.BOTH || stream.streamType === _type.AgoraRteMediaStreamType.VIDEO;
+              localLabelSourceType = getLocalStreamSourceTypeFromStreamLabel(stream.streamId, screenStreamLabelMap);
+              sourceType = localLabelSourceType !== null && localLabelSourceType !== void 0 ? localLabelSourceType : stream.videoSourceType;
+              if (shouldPublishVideo) {
+                rtcChannelClient.publisher.publishLocalVideoStream(streamToken, stream.streamId, stream.videoSourceId, sourceType);
+              } else {
+                rtcChannelClient.publisher.unpublishLocalVideoStream(stream.streamId, sourceType);
+              }
+              if (shouldPublishAudio) {
+                rtcChannelClient.publisher.publishLocalAudioStream(streamToken, stream.streamId, stream.audioSourceId, stream.audioSourceType);
+              } else {
+                rtcChannelClient.publisher.unpublishLocalAudioStream(stream.streamId, stream.audioSourceType);
+              }
+              if (!streamToken) {
+                observer = {
+                  onStreamTokenUpdated: function onStreamTokenUpdated(streamId, token) {
+                    logger.info("republish stream after token updated streamId: ".concat(streamId));
+                    if (streamId === stream.streamId) {
+                      if (shouldPublishAudio) {
+                        rtcChannelClient === null || rtcChannelClient === void 0 || rtcChannelClient.publisher.publishLocalAudioStream(token, stream.streamId, stream.audioSourceId, stream.audioSourceType);
+                      }
+                      if (shouldPublishVideo) {
+                        rtcChannelClient === null || rtcChannelClient === void 0 || rtcChannelClient.publisher.publishLocalVideoStream(token, stream.streamId, stream.videoSourceId, sourceType);
+                      }
+                      localUser.removeObserver(observer);
+                    }
+                  },
+                  onStreamTokenRemoved: function onStreamTokenRemoved() {
+                    localUser.removeObserver(observer);
+                  }
+                };
+                localUser.addObserver(observer);
+              }
+            }
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+}
+var getLocalStreamSourceTypeFromStreamLabel = function getLocalStreamSourceTypeFromStreamLabel(streamId, screenStreamLabelMap) {
+  var label = screenStreamLabelMap.get(streamId);
+  if ((label === null || label === void 0 ? void 0 : label.get('localSourceType')) === 'screen') {
+    return _type2.AgoraRteVideoSourceType.SCREEN;
+  }
+  if ((label === null || label === void 0 ? void 0 : label.get('localSourceType')) === 'camera') {
+    return _type2.AgoraRteVideoSourceType.CAMERA;
+  }
+  return undefined;
+};
+
+/**
+ * Handle streams unpublished event - stop publishing audio/video streams through RTC
+ * @param streams Array of stream info to be unpublished
+ * @param rtcChannelClient RTC channel client for unpublishing
+ */
+function handleStreamsUnPublished(streams, rtcChannelClient) {
+  streams.forEach(/*#__PURE__*/function () {
+    var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(stream) {
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (stream.connectorType === _type.AgoraRteRoomConnectorType.NONE) {
+              rtcChannelClient.publisher.unpublishLocalAudioStream(stream.streamId, stream.audioSourceType);
+              rtcChannelClient.publisher.unpublishLocalVideoStream(stream.streamId, stream.videoSourceType);
+            }
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    return function (_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }());
+}

package/lib/core/scene/helpers/stream-type.d.ts

@@ -0,0 +1,7 @@
+import { AgoraRteMediaPublishState } from '../../media/type';
+import { AgoraRteMediaStreamType } from '../type';
+export declare const convertStreamTypeToPublishState: (type: AgoraRteMediaStreamType) => {
+    audioState: AgoraRteMediaPublishState;
+    videoState: AgoraRteMediaPublishState;
+};
+export declare const convertPublishStateToStreamType: (audioState: AgoraRteMediaPublishState, videoState: AgoraRteMediaPublishState) => AgoraRteMediaStreamType;

package/lib/core/scene/{helper.js → helpers/stream-type.js}

@@ -4,9 +4,9 @@ require("core-js/modules/es.object.define-property.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.relayRtcChannelEvents = exports.convertStreamTypeToPublishState = exports.convertPublishStateToStreamType = void 0;
-var _type = require("../media/type");
-var _type2 = require("./type");
+exports.convertStreamTypeToPublishState = exports.convertPublishStateToStreamType = void 0;
+var _type = require("../../media/type");
+var _type2 = require("../type");
 var convertStreamTypeToPublishState = exports.convertStreamTypeToPublishState = function convertStreamTypeToPublishState(type) {
   switch (type) {
     case _type2.AgoraRteMediaStreamType.NONE:
@@ -47,33 +47,4 @@ var convertPublishStateToStreamType = exports.convertPublishStateToStreamType =
     return _type2.AgoraRteMediaStreamType.VIDEO;
   }
   return _type2.AgoraRteMediaStreamType.NONE;
-};
-var relayRtcChannelEvents = exports.relayRtcChannelEvents = function relayRtcChannelEvents(rtcChannelClient, observable) {
-  rtcChannelClient.addObserver({
-    onNetworkQualityUpdated: function onNetworkQualityUpdated(streamId, txQuality, rxQuality, channelId) {
-      observable.notifyObservers('onNetworkQualityUpdated', channelId, {
-        streamId: streamId,
-        txQuality: txQuality,
-        rxQuality: rxQuality
-      });
-    },
-    onNetworkStatsUpdated: function onNetworkStatsUpdated(stats, channelId) {
-      observable.notifyObservers('onNetworkStatsUpdated', channelId, stats);
-    },
-    onLocalVideoStatsUpdated: function onLocalVideoStatsUpdated(channelId, streamId, stats) {
-      observable.notifyObservers('onLocalVideoStatsUpdated', channelId, streamId, stats);
-    },
-    onLocalAudioStatsUpdated: function onLocalAudioStatsUpdated(channelId, streamId, stats) {
-      observable.notifyObservers('onLocalAudioStatsUpdated', channelId, streamId, stats);
-    },
-    onRemoteVideoStatsUpdated: function onRemoteVideoStatsUpdated(channelId, streamId, stats) {
-      observable.notifyObservers('onRemoteVideoStatsUpdated', channelId, streamId, stats);
-    },
-    onRemoteAudioStatsUpdated: function onRemoteAudioStatsUpdated(channelId, streamId, stats) {
-      observable.notifyObservers('onRemoteAudioStatsUpdated', channelId, streamId, stats);
-    },
-    onFirstRemoteVideoFrameRendered: function onFirstRemoteVideoFrameRendered(streamId, channelId) {
-      observable.notifyObservers('onFirstRemoteVideoFrameRendered', channelId, streamId);
-    }
-  });
 };

package/lib/core/scene/index.d.ts

@@ -1,232 +1,114 @@
+import { AgoraObservable } from '../../imports';
+import { AgoraRteAudioSourceType, AgoraRteMediaSourceState, AgoraRteVideoSourceType } from '../../type';
 import { AgoraRteSyncDataStore } from '../processor/sequence-msg/data';
-import { AgoraRteMediaStreamInfo, AgoraRteSceneInfo, AgoraRteSceneInitOptions, AgoraRteSceneJoinOptions, AgoraRteSceneJoinSnapshotOptions, AgoraRteSceneObserver, AgoraRteUserInfo, AgoraRteUserPageParams, AgoraRteUserPageResponse, AgoraRteUserPropertiesUpdatedEvent } from './type';
-import { AgoraRtcChannelClient } from '../rtc';
+import { AgoraRteLocalUserImpl } from './local-user';
 import { AgoraRteStreamPlayer } from './stream-player';
-import { AgoraRteLocalUser } from './local-user';
-import { AgoraRteServiceApi } from '../services/api';
-import { AgoraObservable, AgoraRteError } from '../../imports';
-import { AgoraRtcMediaSourceState, AgoraRtcScreenCaptureType, AgoraRtcVideoSourceType } from '../rtc/type';
-export declare class AgoraRteScene {
+import { AgoraRteMediaStreamInfo, AgoraRteScene, AgoraRteSceneInfo, AgoraRteSceneInitOptions, AgoraRteSceneInternalObserver, AgoraRteSceneJoinOptions, AgoraRteSceneJoinSnapshotOptions, AgoraRteUserInfo, AgoraRteUserPageParams, AgoraRteUserPageResponse } from './type';
+export declare class AgoraRteSceneImpl implements AgoraRteScene {
     protected logger: import("agora-foundation/lib/logger/type").Logger;
-    protected readonly observable: AgoraObservable<Partial<{
-        onJoinSceneSuccess(sceneId: string, localUser: AgoraRteLocalUser, streamPlayer: AgoraRteStreamPlayer): void;
-        onJoinSceneFailure(sceneId: string, error: AgoraRteError): void;
-        onSceneMessageReceived(sceneId: string, message: import("../../type").AgoraRteMessage): void;
-        onScenePropertiesUpdated(sceneId: string, event: import("./type").AgoraRteScenePropertiesUpdatedEvent): void;
-        onScenePropertiesDeleted(sceneId: string, event: import("./type").AgoraRteScenePropertiesDeletedEvent): void;
-        onUserPropertiesUpdated(sceneId: string, event: AgoraRteUserPropertiesUpdatedEvent): void;
-        onUserPropertiesDeleted(sceneId: string, event: import("./type").AgoraRteUserPropertiesDeletedEvent): void;
-        onRemoteUsersJoined(sceneId: string, events: Array<import("./type").AgoraRteUserJoinedEvent>): void;
-        onRemoteUsersLeft(sceneId: string, events: Array<import("./type").AgoraRteUserLeftEvent>): void;
-        onUserUpdated(sceneId: string, event: import("./type").AgoraRteUserUpdatedEvent): void;
-        onAllUserCountUpdated(sceneId: string, count: number): void;
-        onStreamsAdded(sceneId: string, events: Array<import("./type").AgoraRteMediaStreamEvent>): void;
-        onStreamsRemoved(sceneId: string, events: Array<import("./type").AgoraRteMediaStreamEvent>): void;
-        onStreamsUpdated(sceneId: string, events: Array<import("./type").AgoraRteMediaStreamEvent>): void;
-        onLocalVideoStatsUpdated: (sceneId: string, streamId: string, stats: import("./type").AgoraRteLocalVideoStats) => void;
-        onLocalAudioStatsUpdated: (sceneId: string, streamId: string, stats: import("./type").AgoraRteLocalAudioStats) => void;
-        onRemoteVideoStatsUpdated: (sceneId: string, streamId: string, stats: import("./type").AgoraRteRemoteVideoStats) => void;
-        onRemoteAudioStatsUpdated: (sceneId: string, streamId: string, stats: import("./type").AgoraRteRemoteAudioStats) => void;
-        onNetworkQualityUpdated: (sceneId: string, event: import("./type").AgoraRteNetworkQualityEvent) => void;
-        onNetworkStatsUpdated: (sceneId: string, networkStats: import("../rtc/type").AgoraRtcNetworkStats) => void;
-        onFirstRemoteVideoFrameRendered(sceneId: string, streamId: string): void;
-        onStreamMessageReceived: (sceneId: string, data: import("./type").AgoraRteStreamMessage) => void;
-    }>>;
+    protected observable: AgoraObservable<AgoraRteSceneInternalObserver>;
     private _sceneId;
+    private _localUserId;
+    private _screenStreamLabelMap;
     private _sceneInfo?;
     private _localUser?;
-    private _messageUserId;
+    private _streamPlayer?;
+    private _userToken?;
     private _apiService;
     private _rtmClient;
-    private _rtmChannelClient?;
     private _rtcClient;
     private _apDetector;
-    private _rtcMainChannelClient?;
+    private _rtmChannelClient?;
+    private _rtcChannelClient?;
     private _stateSynchronizer?;
     private _messageSynchronizer?;
-    private _messageHandlerObservers?;
-    private _screenStreamLabelMap;
-    private _streamPlayer?;
+    private _rtcChannelConnectionState;
     private _timestampGap;
     private _totalUserCount;
-    private _joinSuccess;
-    private _joining;
-    private _joinState;
-    private _localCameraStateMap;
-    private _localMicrophoneStateMap;
-    private _localScreenCaptureStateMap;
-    private _localLoopbackStateMap;
-    private _deviceStateSyncTimer?;
-    private _deviceSyncMutex;
-    private _connectionState;
+    private _cleanupPromise;
+    private _initialApiService;
+    private _joinManager;
+    private _abortManager;
     private _rtmObserver;
-    private _startDeviceStateSync;
-    private _stopDeviceStateSync;
-    get apiService(): AgoraRteServiceApi;
-    get dataStore(): AgoraRteSyncDataStore;
+    private _messageHandlerObservers;
+    private _rtcChannelObserver;
     get sceneId(): string;
-    get rtcMainChannelClient(): AgoraRtcChannelClient | undefined;
-    get timestampServerLocalGap(): number;
-    /**
-     * The local user of scene, you can use local user to publish stream,set scene properties, set user properties, etc.
-     */
-    get localUser(): AgoraRteLocalUser;
-    get localStreams(): import("../processor/struct").AgoraRteMediaStream[];
-    /**
-     * The stream player of scene, you can use stream player to subscribe stream, render remote stream, etc.
-     */
+    get localUser(): AgoraRteLocalUserImpl;
+    get dataStore(): AgoraRteSyncDataStore;
     get streamPlayer(): AgoraRteStreamPlayer;
     constructor(sceneId: string, options: AgoraRteSceneInitOptions);
-    join(options: AgoraRteSceneJoinSnapshotOptions): Promise<void>;
-    join(options: AgoraRteSceneJoinOptions): Promise<void>;
-    /**
-     * Leave rte scene, including leave apaas room & leave rtm channel & leave rtc channel
-     * After leave, local user will be removed from scene
-     */
-    leave(): Promise<void>;
-    /**
-     * Get scene info
-     * @returns {AgoraRteSceneInfo} scene info
-     */
-    getSceneInfo(): AgoraRteSceneInfo | undefined;
-    /**
-     * Get local user info
-     * You can use local user to publish stream, subscribe stream, set user properties, etc.
-     * @returns {AgoraRteUserInfo} local user info
-     */
-    getLocalUser(): AgoraRteLocalUser;
-    /**
-     * Get all users in scene
-     * @returns {Record<string, AgoraRteUserInfo>} all users in scene
-     */
+    join(options: AgoraRteSceneJoinOptions): Promise<number>;
+    joinWithSnapshot(options: AgoraRteSceneJoinSnapshotOptions): Promise<number>;
+    leave(): void;
+    getSceneInfo(): AgoraRteSceneInfo;
+    getLocalUser(): AgoraRteLocalUserImpl;
     getUsers(): {
         [key: string]: AgoraRteUserInfo;
     };
-    /**
-     * Get all users in scene, return as list
-     * @returns {AgoraRteUserInfo[]} all users in scene
-     */
     getUserList(): AgoraRteUserInfo[];
-    /**
-     * Get user by user id
-     * @param {string} userId - The user id.
-     * @returns {AgoraRteUserInfo | undefined} user info
-     */
-    getUser(userId?: string): AgoraRteUserInfo | undefined;
-    /**
-     * Get total user count in scene, including user not in stage
-     * @returns {number} total user count
-     */
+    getUser(userId: string): AgoraRteUserInfo | undefined;
     getUserCount(): number;
-    /**
-     * Get user list in scene by page
-     *
-     */
     fetchUserList(params: AgoraRteUserPageParams): Promise<AgoraRteUserPageResponse>;
     addLocalStreamLabels(streamId: string, labels: Map<string, any>): void;
     removeLocalStreamLabel(streamId: string): void;
-    getLocalStreamSourceTypeFromStreamLabel(streamId: string): AgoraRtcVideoSourceType.CAMERA | AgoraRtcVideoSourceType.SCREEN | undefined;
     /**
      * Get all streams in scene, return as object
      * @returns {Record<string, AgoraRteMediaStreamInfo[]>} all streams in scene
      */
     getStreams(): Record<string, AgoraRteMediaStreamInfo[]>;
-    /**
-     * Get all streams in scene, return as list
-     * @returns {AgoraRteMediaStreamInfo[]} all streams in scene
-     */
     getStreamList(): AgoraRteMediaStreamInfo[];
-    /**
-     * Get stream by user id
-     * @param {string} userId - The user id.
-     * @returns {AgoraRteMediaStreamInfo[]} stream array
-     */
     getStreamsByUserId(userId: string): AgoraRteMediaStreamInfo[];
-    /**
-     * Get stream by stream id
-     * @param {string} streamId - The stream id.
-     * @returns {AgoraRteMediaStreamInfo | undefined} stream info
-     */
     getStreamByStreamId(streamId: string): AgoraRteMediaStreamInfo | undefined;
-    /**
-     * Get Scene Properties
-     * @returns {Record<string, unknown>} scene properties
-     */
     getSceneProperties(): Record<string, unknown>;
-    /**
-     * Get Scene Properties by key path
-     * @param {string} keyPath - The key path.
-     * @returns {unknown} scene properties
-     */
-    getScenePropertiesByKeyPath(keyPath: string): unknown;
-    /**
-     * Get User Properties
-     * @returns {Record<string, unknown>} user properties
-     */
+    getScenePropertiesByKeyPath<T = unknown>(keyPath: string): T;
     getUserProperties(): Record<string, unknown>;
-    /**
-     * Get User Properties by user id
-     * @param {string} userId - The user id.
-     * @returns {Record<string, unknown>} user properties
-     */
     getUserPropertiesByUserId(userId: string): Record<string, unknown> | undefined;
-    /**
-     * Get User Properties by key path
-     * @param {string} keyPath - The key path.
-     * @param {string} userId - The user id.
-     * @returns {unknown} user properties
-     */
-    getUserPropertiesByKeyPath<T = unknown>(keyPath: string, userId: string): unknown;
-    /**
-     * Get Call Id of rtc channel client
-     * @returns {string} rtc call id
-     */
-    getCallId(): void;
-    /**
-     * Get session id of rtm client
-     * @returns {string} rtm session id
-     */
+    getUserPropertiesByKeyPath<T = unknown>(keyPath: string, userId: string): T;
     getSessionId(): string;
-    /**
-     * Get timestamp from apaas server
-     * @returns
-     */
     getSyncTimestamp(): number;
-    /**
-     * add rte scene observer
-     * @param {AgoraRteSceneObserver} observer
-     */
-    addObserver(observer: AgoraRteSceneObserver): void;
-    /**
-     * remove rte scene observer
-     * @param {AgoraRteSceneObserver} observer
-     */
-    removeObserver(observer: AgoraRteSceneObserver): void;
-    onCameraVideoStateUpdated: (deviceId: string, state: AgoraRtcMediaSourceState) => void;
-    onMicrophoneAudioStateUpdated: (deviceId: string, state: AgoraRtcMediaSourceState, error?: Error | undefined) => void;
-    onScreenCaptureVideoStateUpdated: (deviceId: string, type: AgoraRtcScreenCaptureType, state: AgoraRtcMediaSourceState) => void;
-    onLoopbackAudioStateUpdated: (deviceId: string, state: AgoraRtcMediaSourceState) => void;
-    private _joinRTMChannel;
+    addObserver(observer: AgoraRteSceneInternalObserver): void;
+    removeObserver(observer: AgoraRteSceneInternalObserver): void;
+    onTrackVideoStateUpdated(sourceId: string, sourceType: AgoraRteVideoSourceType, state: AgoraRteMediaSourceState): void;
+    onTrackAudioStateUpdated(sourceId: string, sourceType: AgoraRteAudioSourceType, state: AgoraRteMediaSourceState): void;
+    private _performJoin;
+    private _getEntryRoomData;
     private _entryRoom;
-    private _joinRTCChannel;
-    private _handleConnectionStateUpdated;
+    private _handleRtcConnectionStateUpdated;
     private _leaveRTCChannel;
     private _leaveRTMChannel;
-    private _handleStreamsPublished;
-    private _handleStreamsUnPublished;
-    private _getChannelMessageEventListeners;
-    private _handleRemoteUserAdded;
-    private _handleLocalUserAdded;
-    private _handleRemoteUserRemoved;
-    private _handleLocalUserRemoved;
-    private _getLocalCameraVideoStatePatches;
-    private _getLocalLoopbackAudioStatePatches;
-    private _getLocalMicrophoneAudioStatePatches;
-    private _getLocalScreenCaptureVideoStatePatches;
-    private _syncDeviceState;
+    private _handleOnSnapshotUpdated;
+    private _handleOnUserCountUpdated;
+    private _handleOnRemoteUsersAdded;
+    private _handleOnLocalUserAdded;
+    private _handleOnUserUpdated;
+    private _handleOnUserSubscribe;
+    private _handleOnUserUnsubscribe;
+    private _handleOnRemoteUsersRemoved;
+    private _handleOnLocalUserRemoved;
+    private _handleOnRoomPropertyUpdated;
+    private _handleOnRoomPropertyDeleted;
+    private _handleOnUserPropertyUpdated;
+    private _handleOnUserPropertyDeleted;
+    private _handleOnUserPropertyListUpdated;
+    private _handleOnLocalStreamAdded;
+    private _handleOnLocalStreamUpdated;
+    private _handleOnLocalStreamRemoved;
+    private _handleOnRemoteStreamAdded;
+    private _handleOnRemoteStreamUpdated;
+    private _handleOnRemoteStreamRemoved;
+    private _handleOnTimeStampGapUpdate;
+    private _handleOnCustomChannelMessageRecieved;
+    private _handleOnJoinSuccess;
+    private _handleOnJoinFailure;
     private _cleanup;
-    private _keypathObjectToNormalObject;
-    private _startApDetect;
-    private _restartApDetect;
+    private _beginCleanup;
     private _handleOnRtmConnectionStateUpdated;
+    private _checkIfLocalUserIsKickedOut;
+    private _setOnlineState;
+    private _checkMediaSourceState;
+    private _checkLocalStreamBind;
+    private _unbindLocalStream;
+    private _asyncStep1EntryRoom;
+    private _asyncStep2JoinChannels;
+    private _step3InitializeComponents;
 }