agora-rte-sdk 3.10.2 → 3.11.0-rc.2

package/lib/core/engine/index.js

@@ -123,6 +123,12 @@ var AgoraRteEngineImpl = exports.AgoraRteEngineImpl = /*#__PURE__*/function () {
     this._mediaControl.addObserver(this._mediaControlObserver);
     if (this._rtcClient) {
       this._mediaControl.setRtcClient(this._rtcClient);
+
+      // Set client recording manager if available (Electron platform)
+      var clientRecordingManager = this._rtcClient.getMediaRecorderManager();
+      if (clientRecordingManager) {
+        this._mediaControl.setClientRecordingManager(clientRecordingManager);
+      }
     }
     if (this._rtmClient) {
       this._rtmClient.addObserver(this._rtmClientObserver);
@@ -172,7 +178,7 @@ var AgoraRteEngineImpl = exports.AgoraRteEngineImpl = /*#__PURE__*/function () {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               _context.next = 1;
-              return this.rtmClient.login(this._config.userToken, this._config.userId);
+              return this.rtmClient.login(this._config.userToken);
             case 1:
             case "end":
               return _context.stop();
@@ -295,6 +301,7 @@ var AgoraRteEngineImpl = exports.AgoraRteEngineImpl = /*#__PURE__*/function () {
   }, {
     key: "renewUserToken",
     value: function renewUserToken(token) {
+      this._config.userToken = token;
       this._httpAuthHeadersProvider.putHeaders((0, _defineProperty2["default"])({}, _constants.HTTP_HEADER_K_AUTHORIZATION, (0, _authHeaders.getAuthorization)(token)));
       return this.rtmClient.renewToken(token);
     }

package/lib/core/media/index.js

@@ -20,8 +20,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AgoraRteMediaControlImpl = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 require("core-js/modules/es.error.cause.js");
 require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.array.concat.js");
 require("core-js/modules/es.array.for-each.js");
 require("core-js/modules/es.array.iterator.js");
 require("core-js/modules/es.map.js");
@@ -47,12 +49,14 @@ require("core-js/modules/esnext.map.update.js");
 require("core-js/modules/web.dom-collections.for-each.js");
 require("core-js/modules/web.dom-collections.iterator.js");
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _constant = require("../../constant");
 var _imports = require("../../imports");
-var _type = require("../rtc/type");
+var _type = require("../../type");
+var _type2 = require("../rtc/type");
 var _logger = require("../utilities/logger");
 var _camera = require("./camera");
 var _loopback = require("./loopback");
@@ -80,24 +84,31 @@ var AgoraRteMediaControlImpl = exports.AgoraRteMediaControlImpl = /*#__PURE__*/f
     (0, _defineProperty2["default"])(this, "_microphoneAudioTracksMap", new Map());
     (0, _defineProperty2["default"])(this, "_screenShareTracksMap", new Map());
     (0, _defineProperty2["default"])(this, "_loopbackAudioTracksMap", new Map());
+    // Screen share state
+    (0, _defineProperty2["default"])(this, "_isScreenShareActive", false);
     (0, _defineProperty2["default"])(this, "_cameraTrackObserver", {
       onCameraStateUpdated: function onCameraStateUpdated(deviceId, state) {
-        _this._observable.notifyObservers('onTrackVideoStateUpdated', deviceId, _type.AgoraRtcVideoSourceType.CAMERA, state);
+        _this._observable.notifyObservers('onTrackVideoStateUpdated', deviceId, _type2.AgoraRtcVideoSourceType.CAMERA, state);
       }
     });
     (0, _defineProperty2["default"])(this, "_microphoneTrackObserver", {
       onMicrophoneStateUpdated: function onMicrophoneStateUpdated(deviceId, state) {
-        _this._observable.notifyObservers('onTrackAudioStateUpdated', deviceId, _type.AgoraRtcAudioSourceType.MICROPHONE, state);
+        _this._observable.notifyObservers('onTrackAudioStateUpdated', deviceId, _type2.AgoraRtcAudioSourceType.MICROPHONE, state);
       }
     });
     (0, _defineProperty2["default"])(this, "_screenTrackObserver", {
       onScreenCaptureStateUpdated: function onScreenCaptureStateUpdated(deviceId, state) {
-        _this._observable.notifyObservers('onTrackVideoStateUpdated', deviceId, _type.AgoraRtcVideoSourceType.SCREEN, state);
+        if (state === _type.AgoraRteMediaSourceState.OPEN) {
+          _this.setScreenShareState(true, deviceId);
+        } else if ((state === _type.AgoraRteMediaSourceState.CLOSE || state === _type.AgoraRteMediaSourceState.ERROR) && _this._currentScreenShareSourceId === deviceId) {
+          _this.setScreenShareState(false);
+        }
+        _this._observable.notifyObservers('onTrackVideoStateUpdated', deviceId, _type2.AgoraRtcVideoSourceType.SCREEN, state);
       }
     });
     (0, _defineProperty2["default"])(this, "_loopbackTrackObserver", {
       onLoopbackRecordingStateUpdated: function onLoopbackRecordingStateUpdated(deviceId, state) {
-        _this._observable.notifyObservers('onTrackAudioStateUpdated', deviceId, _type.AgoraRtcAudioSourceType.LOOPBACK, state);
+        _this._observable.notifyObservers('onTrackAudioStateUpdated', deviceId, _type2.AgoraRtcAudioSourceType.LOOPBACK, state);
       }
     });
     (0, _defineProperty2["default"])(this, "_sourceManagerObserver", {
@@ -342,15 +353,178 @@ var AgoraRteMediaControlImpl = exports.AgoraRteMediaControlImpl = /*#__PURE__*/f
   }, {
     key: "release",
     value: function release() {
+      var _this$_clientRecordin;
       this.rtcClient.sourceManager.removeObserver(this._sourceManagerObserver);
       this.rtcClient.removeObserver(this._rtcClientObserver);
+      (_this$_clientRecordin = this._clientRecordingManager) === null || _this$_clientRecordin === void 0 || _this$_clientRecordin.release();
+      this._clientRecordingManager = undefined;
       this._rtcClient = null;
       return _constant.AgoraRteReturnCode.SUCCESS;
     }
+
+    /**
+     * Set the client recording manager for handling client-side recording.
+     * This is called by platform-specific implementations (e.g., Electron).
+     */
+  }, {
+    key: "setClientRecordingManager",
+    value: function setClientRecordingManager(manager) {
+      this._clientRecordingManager = manager;
+    }
+  }, {
+    key: "startClientRecording",
+    value: function () {
+      var _startClientRecording = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(channelId, uid, config, isScreenShareActive, currentScreenShareSourceId) {
+        return _regenerator["default"].wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this._clientRecordingManager) {
+                _context.next = 1;
+                break;
+              }
+              this.logger.warn('startClientRecording: client recording manager is not available. ' + 'This feature is only supported on Electron platform.');
+              return _context.abrupt("return");
+            case 1:
+              _context.next = 2;
+              return this._clientRecordingManager.startClientRecording(channelId, uid, config, isScreenShareActive, currentScreenShareSourceId);
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function startClientRecording(_x, _x2, _x3, _x4, _x5) {
+        return _startClientRecording.apply(this, arguments);
+      }
+      return startClientRecording;
+    }()
+  }, {
+    key: "stopClientRecording",
+    value: function () {
+      var _stopClientRecording = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+        return _regenerator["default"].wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (this._clientRecordingManager) {
+                _context2.next = 1;
+                break;
+              }
+              this.logger.warn('stopClientRecording: client recording manager is not available');
+              return _context2.abrupt("return");
+            case 1:
+              _context2.next = 2;
+              return this._clientRecordingManager.stopClientRecording();
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function stopClientRecording() {
+        return _stopClientRecording.apply(this, arguments);
+      }
+      return stopClientRecording;
+    }()
+  }, {
+    key: "resumeClientRecordingOwnCapture",
+    value: function () {
+      var _resumeClientRecordingOwnCapture = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        return _regenerator["default"].wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (this._clientRecordingManager) {
+                _context3.next = 1;
+                break;
+              }
+              this.logger.warn('resumeClientRecordingOwnCapture: client recording manager is not available');
+              return _context3.abrupt("return");
+            case 1:
+              _context3.next = 2;
+              return this._clientRecordingManager.resumeOwnCapture();
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function resumeClientRecordingOwnCapture() {
+        return _resumeClientRecordingOwnCapture.apply(this, arguments);
+      }
+      return resumeClientRecordingOwnCapture;
+    }()
+  }, {
+    key: "releaseClientRecordingOwnCapture",
+    value: function releaseClientRecordingOwnCapture() {
+      if (!this._clientRecordingManager) {
+        this.logger.warn('releaseClientRecordingOwnCapture: client recording manager is not available');
+        return;
+      }
+      this._clientRecordingManager.releaseOwnCapture();
+    }
+  }, {
+    key: "isClientRecordingActive",
+    value: function isClientRecordingActive() {
+      var _this$_clientRecordin2, _this$_clientRecordin3;
+      return (_this$_clientRecordin2 = (_this$_clientRecordin3 = this._clientRecordingManager) === null || _this$_clientRecordin3 === void 0 ? void 0 : _this$_clientRecordin3.isLocalClientRecordingActive()) !== null && _this$_clientRecordin2 !== void 0 ? _this$_clientRecordin2 : false;
+    }
+  }, {
+    key: "isClientRecordingOwnsCapture",
+    value: function isClientRecordingOwnsCapture() {
+      var _this$_clientRecordin4, _this$_clientRecordin5;
+      return (_this$_clientRecordin4 = (_this$_clientRecordin5 = this._clientRecordingManager) === null || _this$_clientRecordin5 === void 0 ? void 0 : _this$_clientRecordin5.isClientRecordingOwnsCapture()) !== null && _this$_clientRecordin4 !== void 0 ? _this$_clientRecordin4 : false;
+    }
+  }, {
+    key: "addClientRecordingObserver",
+    value: function addClientRecordingObserver(observer) {
+      var _this$_clientRecordin6;
+      (_this$_clientRecordin6 = this._clientRecordingManager) === null || _this$_clientRecordin6 === void 0 || _this$_clientRecordin6.addObserver(observer);
+    }
+  }, {
+    key: "removeClientRecordingObserver",
+    value: function removeClientRecordingObserver(observer) {
+      var _this$_clientRecordin7;
+      (_this$_clientRecordin7 = this._clientRecordingManager) === null || _this$_clientRecordin7 === void 0 || _this$_clientRecordin7.removeObserver(observer);
+    }
+  }, {
+    key: "isScreenShareActive",
+    value: function isScreenShareActive() {
+      return this._isScreenShareActive;
+    }
+  }, {
+    key: "getCurrentScreenShareSourceId",
+    value: function getCurrentScreenShareSourceId() {
+      return this._currentScreenShareSourceId;
+    }
+  }, {
+    key: "setScreenShareState",
+    value: function setScreenShareState(active, sourceId) {
+      this._isScreenShareActive = active;
+      this._currentScreenShareSourceId = active ? sourceId : undefined;
+      this.logger.info("Screen share state updated: active=".concat(active, ", sourceId=").concat(sourceId));
+    }
+  }, {
+    key: "waitForScreenCaptureStopped",
+    value: function () {
+      var _waitForScreenCaptureStopped = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        return _regenerator["default"].wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", this.rtcClient.sourceManager.waitForScreenCaptureStopped());
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function waitForScreenCaptureStopped() {
+        return _waitForScreenCaptureStopped.apply(this, arguments);
+      }
+      return waitForScreenCaptureStopped;
+    }()
   }]);
 }();
 _AgoraRteMediaControlImpl = AgoraRteMediaControlImpl;
-var _applyDecs$e = _applyDecs(_AgoraRteMediaControlImpl, [[_observeSystemSelectedSpeakerChangedDecs, 2, "observeSystemSelectedSpeakerChanged"], [_observeSystemSelectedMicrophoneChangedDecs, 2, "observeSystemSelectedMicrophoneChanged"], [_imports.trace, 2, "disableAGC"], [_imports.trace, 2, "enableAGC"], [_setSelectedSpeakerDecs, 2, "setSelectedSpeaker"], [_setSelectedSpeakerVolumeDecs, 2, "setSelectedSpeakerVolume"], [_setEnableSpeakerDecs, 2, "setEnableSpeaker"], [_startSpeakerTestDecs, 2, "startSpeakerTest"], [_imports.trace, 2, "stopSpeakerTest"], [_adjustAudioOutputVolumeDecs, 2, "adjustAudioOutputVolume"], [_imports.trace, 2, "release"]], []).e;
+var _applyDecs$e = _applyDecs(_AgoraRteMediaControlImpl, [[_observeSystemSelectedSpeakerChangedDecs, 2, "observeSystemSelectedSpeakerChanged"], [_observeSystemSelectedMicrophoneChangedDecs, 2, "observeSystemSelectedMicrophoneChanged"], [_imports.trace, 2, "disableAGC"], [_imports.trace, 2, "enableAGC"], [_setSelectedSpeakerDecs, 2, "setSelectedSpeaker"], [_setSelectedSpeakerVolumeDecs, 2, "setSelectedSpeakerVolume"], [_setEnableSpeakerDecs, 2, "setEnableSpeaker"], [_startSpeakerTestDecs, 2, "startSpeakerTest"], [_imports.trace, 2, "stopSpeakerTest"], [_adjustAudioOutputVolumeDecs, 2, "adjustAudioOutputVolume"], [_imports.trace, 2, "release"], [_imports.trace, 2, "startClientRecording"], [_imports.trace, 2, "stopClientRecording"], [_imports.trace, 2, "resumeClientRecordingOwnCapture"]], []).e;
 var _applyDecs$e2 = (0, _slicedToArray2["default"])(_applyDecs$e, 1);
 _initProto = _applyDecs$e2[0];
 _applyDecs$e;

package/lib/core/media/screen.js

@@ -124,7 +124,7 @@ var AgoraRteScreenTrackImpl = exports.AgoraRteScreenTrackImpl = /*#__PURE__*/fun
         if (this._params) {
           return this._rtcClient.sourceManager.startScreenCaptureByWindowIdWithParams(this._sourceId, this._params);
         } else {
-          return this._rtcClient.sourceManager.startScreenCaptureByWindowId(this._sourceId);
+          return this._rtcClient.sourceManager.startScreenCaptureByWindowId(this._sourceId, true);
         }
       }
     }

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

@@ -4,6 +4,29 @@ import { AgoraRteCameraTrack } from './camera';
 import { AgoraRteLoopbackTrack } from './loopback';
 import { AgoraRteMicrophoneTrack } from './microphone';
 import { AgoraRteScreenTrack } from './screen';
+import { AgoraRteClientRecordingConfig, AgoraRteClientRecordingObserver } from '../scene/type';
+/**
+ * Client recording manager interface.
+ * Platform-specific implementations (Electron/Web) should implement this interface.
+ */
+export interface AgoraRteClientRecordingManager {
+    addObserver(observer: AgoraRteClientRecordingObserver): void;
+    removeObserver(observer: AgoraRteClientRecordingObserver): void;
+    isLocalClientRecordingActive(): boolean;
+    isClientRecordingOwnsCapture(): boolean;
+    startClientRecording(channelId: string, uid: number, config?: AgoraRteClientRecordingConfig, isScreenShareActive?: boolean, currentScreenShareSourceId?: string): Promise<void>;
+    stopClientRecording(): Promise<void>;
+    /**
+     * Resume recording's own window capture after it was released.
+     */
+    resumeOwnCapture(): Promise<void>;
+    /**
+     * Release the recording's own screen/window capture without stopping the recording.
+     * Called before starting screen share to free the capture resource.
+     */
+    releaseOwnCapture(): void;
+    release(): void;
+}
 /**
  * 音频的输出位置
  */
@@ -226,6 +249,65 @@ export interface AgoraRteMediaControl {
      * Releases the resources used by the media control.
      */
     release(): number;
+    /**
+     * Start client recording.
+     * @param channelId The channel ID for recording.
+     * @param uid The user ID for recording.
+     * @param config Recording configuration including storage path, etc.
+     * @param isScreenShareActive Whether screen sharing is currently active.
+     * @param currentScreenShareSourceId Current screen share source ID if active.
+     * @returns A promise that resolves when recording starts successfully.
+     */
+    startClientRecording(channelId: string, uid: number, config?: AgoraRteClientRecordingConfig, isScreenShareActive?: boolean, currentScreenShareSourceId?: string): Promise<void>;
+    /**
+     * Stop client recording.
+     * @returns A promise that resolves when recording stops successfully.
+     */
+    stopClientRecording(): Promise<void>;
+    /**
+     * Resume recording's own window capture.
+     */
+    resumeClientRecordingOwnCapture(): Promise<void>;
+    /**
+     * Release the recording's own screen/window capture without stopping the recording.
+     * Called before starting screen share to free the capture resource.
+     */
+    releaseClientRecordingOwnCapture(): void;
+    /**
+     * Check whether client recording is currently active.
+     * @returns Whether client recording is active.
+     */
+    isClientRecordingActive(): boolean;
+    /**
+     * Check whether client recording owns its own screen capture.
+     * @returns Whether client recording owns its own capture.
+     */
+    isClientRecordingOwnsCapture(): boolean;
+    /**
+     * Add an observer for client recording events.
+     * @param observer The observer to add.
+     */
+    addClientRecordingObserver(observer: AgoraRteClientRecordingObserver): void;
+    /**
+     * Remove an observer for client recording events.
+     * @param observer The observer to remove.
+     */
+    removeClientRecordingObserver(observer: AgoraRteClientRecordingObserver): void;
+    /**
+     * Check if screen sharing is currently active.
+     * @returns Whether screen sharing is active.
+     */
+    isScreenShareActive(): boolean;
+    /**
+     * Get the current screen share source ID if screen sharing is active.
+     * @returns The screen share source ID, or undefined if not sharing.
+     */
+    getCurrentScreenShareSourceId(): string | undefined;
+    /**
+     * Wait for the SDK's onLocalVideoStateChanged(VideoSourceScreenPrimary, Stopped) callback.
+     * Used to ensure the SDK has fully processed a screen capture stop before starting a new one.
+     */
+    waitForScreenCaptureStopped(): Promise<void>;
 }
 export type AgoraRteObservableTrack<T> = {
     addObserver(observer: T): void;

package/lib/core/media/type.js

@@ -37,6 +37,10 @@ Object.defineProperty(exports, "AgoraRteVideoRenderMode", {
   }
 });
 var _type = require("../rtc/type");
+/**
+ * Client recording manager interface.
+ * Platform-specific implementations (Electron/Web) should implement this interface.
+ */
 /**
  * 音频的输出位置
  */

package/lib/core/rtc/canvas.d.ts

@@ -1,6 +1,6 @@
 import { Logger } from '../../imports';
 import { AgoraRteRenderView } from '../../type';
-import { AgoraRtcConnection, AgoraRtcRenderMode, AgoraRtcRenderResultType, AgoraRtcRenderSourceType } from './type';
+import { AgoraRtcConnection, AgoraRtcMediaSourceIndex, AgoraRtcRenderMode, AgoraRtcRenderResultType, AgoraRtcRenderSourceType } from './type';
 export declare abstract class AgoraRtcCanvasHelper {
     protected logger: Logger;
     canvasMap: Map<AgoraRteRenderView, string>;
@@ -15,7 +15,8 @@ export declare class AgoraRtcCanvasTag {
     sourceId: string;
     connection?: AgoraRtcConnection;
     isLocal: boolean;
-    constructor(canvas: AgoraRtcVideoCanvas, sourceId: string, isLocal: boolean, connection?: AgoraRtcConnection);
+    localCameraSourceIndex?: AgoraRtcMediaSourceIndex;
+    constructor(canvas: AgoraRtcVideoCanvas, sourceId: string, isLocal: boolean, connection?: AgoraRtcConnection, localCameraSourceIndex?: AgoraRtcMediaSourceIndex);
     normalize(): {
         canvas: {
             view: unknown;
@@ -25,6 +26,7 @@ export declare class AgoraRtcCanvasTag {
         sourceId: string;
         connection: string | undefined;
         isLocal: boolean;
+        localCameraSourceIndex: AgoraRtcMediaSourceIndex | undefined;
     };
 }
 export declare class AgoraRtcVideoCanvas {
@@ -47,7 +49,7 @@ export declare class AgoraRtcVideoCanvas {
 export declare abstract class AgoraRtcCanvasTagPool {
     protected logger: Logger;
     abstract getTagWithCanvasId(canvasAddress: AgoraRteRenderView): AgoraRtcCanvasTag | undefined;
-    abstract addTagWithCanvasId(canvasAddress: AgoraRteRenderView, sourceId: string, canvas: AgoraRtcVideoCanvas, isLocal: boolean, connection?: AgoraRtcConnection): void;
+    abstract addTagWithCanvasId(canvasAddress: AgoraRteRenderView, sourceId: string, canvas: AgoraRtcVideoCanvas, isLocal: boolean, connection?: AgoraRtcConnection, localCameraSourceIndex?: AgoraRtcMediaSourceIndex): void;
     abstract ifNeedStopRenderCanvas(canvasAddress: AgoraRteRenderView): void;
     abstract ifNeedStopLocalRenderCanvas(canvasAddress: AgoraRteRenderView): void;
     abstract stopRenderOnAllCanvasWithSourceId(sourceId: string): void;

package/lib/core/rtc/canvas.js

@@ -43,13 +43,14 @@ var AgoraRtcCanvasHelper = exports.AgoraRtcCanvasHelper = /*#__PURE__*/(0, _crea
   (0, _defineProperty2["default"])(this, "canvasMap", new Map());
 });
 var AgoraRtcCanvasTag = exports.AgoraRtcCanvasTag = /*#__PURE__*/function () {
-  function AgoraRtcCanvasTag(canvas, sourceId, isLocal, connection) {
+  function AgoraRtcCanvasTag(canvas, sourceId, isLocal, connection, localCameraSourceIndex) {
     (0, _classCallCheck2["default"])(this, AgoraRtcCanvasTag);
     (0, _defineProperty2["default"])(this, "__json_serializable__", true);
     this.canvas = canvas;
     this.sourceId = sourceId;
     this.connection = connection;
     this.isLocal = isLocal;
+    this.localCameraSourceIndex = localCameraSourceIndex;
   }
   return (0, _createClass2["default"])(AgoraRtcCanvasTag, [{
     key: "normalize",
@@ -58,7 +59,8 @@ var AgoraRtcCanvasTag = exports.AgoraRtcCanvasTag = /*#__PURE__*/function () {
         canvas: this.canvas.normalize(),
         sourceId: this.sourceId,
         connection: this.connection ? this.connection.toString() : undefined,
-        isLocal: this.isLocal
+        isLocal: this.isLocal,
+        localCameraSourceIndex: this.localCameraSourceIndex
       };
     }
   }]);

package/lib/core/rtc/client.d.ts

@@ -1,10 +1,11 @@
 import { AgoraRteRenderView } from '../../imports';
 import { AgoraRtcChannelClient } from './channel';
-import { AgoraRtcDeviceInfo, AgoraRtcLatencyLevelType, AgoraRtcClientObserver, AgoraRtcRenderMode, AgoraRtcCapability, AgoraRtcAudioOutputRouting, AgoraRtcScreenCaptureType } from './type';
+import { AgoraRtcChannelType, AgoraRtcDeviceInfo, AgoraRtcLatencyLevelType, AgoraRtcClientObserver, AgoraRtcRenderMode, AgoraRtcCapability, AgoraRtcAudioOutputRouting, AgoraRtcScreenCaptureType } from './type';
 import { AgoraRtcSourceManager } from './source-manager';
 import { AgoraRtcCaptureEnhancement } from './capture-enhancement';
 import { AgoraRtcCanvasHelper } from './canvas';
 import { AgoraRtcAccessPointConfig } from '../engine/ap-detector';
+import type { AgoraRteClientRecordingManager } from '../media/type';
 /**
  * Abstract class that defines the interface for an Agora RTC client. This class provides methods for managing cameras, microphones, speakers, and screen capture, as well as creating and managing Agora RTC channels.
  */
@@ -19,10 +20,11 @@ export declare abstract class AgoraRtcClient {
     /**
      * Creates an Agora RTC channel client.
      * @param channelId The ID of the channel to join.
+     * @param localUserId The local user ID.
      * @param latencyLevel The latency level to use for the channel.
-     * @param channelType The type of channel to join, main means communication channel, screen means screen sharing channel.
+     * @param channelType The channel type. Standard for normal communication, LargeScale for large-scale broadcast.
      */
-    abstract createChannelClient(channelId: string, localUserId: string, latencyLevel: AgoraRtcLatencyLevelType): AgoraRtcChannelClient;
+    abstract createChannelClient(channelId: string, localUserId: string, latencyLevel: AgoraRtcLatencyLevelType, channelType?: AgoraRtcChannelType): AgoraRtcChannelClient;
     /**
      * Sets the client parameters.
      * @param parameters The parameters to set.
@@ -212,4 +214,10 @@ export declare abstract class AgoraRtcClient {
      * Releases the client resources.
      */
     abstract release(): void;
+    /**
+     * Gets the media recorder manager for client-side recording.
+     * Only available on Electron platform.
+     * @returns The media recorder manager, or undefined if not supported.
+     */
+    getMediaRecorderManager(): AgoraRteClientRecordingManager | undefined;
 }

package/lib/core/rtc/client.js

@@ -156,5 +156,29 @@ var AgoraRtcClient = exports.AgoraRtcClient = /*#__PURE__*/function () {
     /**
      * Releases the client resources.
      */
+  }, {
+    key: "getMediaRecorderManager",
+    value:
+    /**
+     * Gets the media recorder manager for client-side recording.
+     * Only available on Electron platform.
+     * @returns The media recorder manager, or undefined if not supported.
+     */
+    function getMediaRecorderManager() {
+      return this.sourceManager.getMediaRecorderManager();
+    }
+
+    /**
+     * Sets the audio raw data observer configuration for a specific device.
+     * @param deviceId The ID of the device to set the audio raw data observer configuration for.
+     * @param config The audio raw data observer configuration to set.
+     */
+    // abstract setAudioRawDataConfig(deviceId: string, config: AgoraRtcAudioRawDataConfig): number;
+
+    /**
+     * Checks if the client has screen capture permission.
+     * @returns Whether the client has screen capture permission.
+     */
+    // abstract hasScreenCapturePermission(): boolean;
   }]);
 }();

package/lib/core/rtc/publish-pool.d.ts

@@ -11,6 +11,7 @@ export declare abstract class AgoraRtcStreamPublishPool<TItem extends AgoraRtcSt
     protected onBeforeUpdate(item: TItem): void;
     protected shouldNotifyUpdate(item: TItem): boolean;
     protected shouldNotifyVideoEncoderConfig(item: TItem, wasVideoPublished: boolean): boolean;
+    protected onBeforeJoinChannel(item: TItem): void;
     private getOrCreateItem;
     publishVideo(token: string | undefined, streamId: string, sourceId: string, type: AgoraRtcVideoSourceType, state: AgoraRtcMediaSourceState): number;
     publishAudio(token: string | undefined, streamId: string, sourceId: string, type: AgoraRtcAudioSourceType, state: AgoraRtcMediaSourceState): number;

package/lib/core/rtc/publish-pool.js

@@ -108,6 +108,11 @@ var AgoraRtcStreamPublishPool = exports.AgoraRtcStreamPublishPool = /*#__PURE__*
     value: function shouldNotifyVideoEncoderConfig(item, wasVideoPublished) {
       return false;
     }
+  }, {
+    key: "onBeforeJoinChannel",
+    value: function onBeforeJoinChannel(item) {
+      // To be implemented by subclass if needed
+    }
   }, {
     key: "getOrCreateItem",
     value: function getOrCreateItem(streamId, token) {
@@ -136,6 +141,7 @@ var AgoraRtcStreamPublishPool = exports.AgoraRtcStreamPublishPool = /*#__PURE__*
         this.observable.notifyObservers('onConnectionSetVideoEncoderConfig', item);
       }
       if (!item.isMainConnection && !item.connectionIsJoin && item.token) {
+        this.onBeforeJoinChannel(item);
         this.observable.notifyObservers('onConnectionJoinChannel', item);
         item.connectionIsJoin = true;
         this._itemMap.set(streamId, item);
@@ -162,6 +168,7 @@ var AgoraRtcStreamPublishPool = exports.AgoraRtcStreamPublishPool = /*#__PURE__*
       item.audioSourceState = state;
       item.token = token;
       if (!item.isMainConnection && !item.connectionIsJoin && item.token) {
+        this.onBeforeJoinChannel(item);
         this.observable.notifyObservers('onConnectionJoinChannel', item);
         item.connectionIsJoin = true;
         this._itemMap.set(streamId, item);

package/lib/core/rtc/source-manager.d.ts

@@ -1,4 +1,5 @@
 import { AgoraRtcCameraPosition, AgoraRtcDeviceInfo, AgoraRtcDisplayInfo, AgoraRtcWindowInfo, AgoraRtcScreenCaptureParams, AgoraRtcVideoOrientation, AgoraRtcCameraCaptureParams, AgoraRtcMediaSourceState, AgoraRtcSourceManagerObserver, AgoraRtcScreenCaptureType, AgoraRtcMediaSourceIndex } from './type';
+import { AgoraRteClientRecordingManager } from '../media/type';
 export interface AgoraRtcSourceManager {
     readonly keepRecording: boolean;
     addObserver(observer: AgoraRtcSourceManagerObserver): void;
@@ -126,10 +127,10 @@ export interface AgoraRtcSourceManager {
     startScreenCaptureByWindowIdWithParams(windowId: string, params: AgoraRtcScreenCaptureParams): number;
     /**
      * Starts screen capture by window ID.
-     * @param sourceId The ID of the window to start screen capture for.
-     * @param params The screen capture parameters.
+     * @param windowId The ID of the window to start screen capture for.
+     * @param enableHighLight Whether to enable highlight border (default: true). Set to false for client recording.
      */
-    startScreenCaptureByWindowId(windowId: string): number;
+    startScreenCaptureByWindowId(windowId: string, enableHighLight: boolean): number;
     /**
      * For mobile only.
      * Starts screen capture by screen ID.
@@ -153,8 +154,26 @@ export interface AgoraRtcSourceManager {
      * Stops screen capture.
      * @param sourceId The ID of the screen capture to stop.
      * @param type The type of the screen capture.
+     * @param forceCleanState If true, forcefully reset the internal source state after stopping,
+     *                        without notifying upper layers. Used by client recording to ensure
+     *                        stale enabled state doesn't block subsequent capture starts.
+     */
+    stopScreenCapture(sourceId: string, type: AgoraRtcScreenCaptureType, forceCleanState?: boolean): number;
+    /**
+     * Returns a promise that resolves when the SDK's onLocalVideoStateChanged callback
+     * fires with state=Stopped for VideoSourceScreenPrimary.
+     * Used to wait for the SDK to fully process a screen capture stop before starting a new one.
+     */
+    waitForScreenCaptureStopped(): Promise<void>;
+    /**
+     * Protect a source ID from being closed by onLocalVideoStateChanged callbacks.
+     * Used when recording starts its own window capture while screen share is stopping.
+     */
+    protectSourceId(sourceId: string): void;
+    /**
+     * Remove protection from a source ID.
      */
-    stopScreenCapture(sourceId: string, type: AgoraRtcScreenCaptureType): number;
+    unprotectSourceId(sourceId: string): void;
     /**
      * For PC only.
      * Updates the screen capture exclude window list by display id.
@@ -207,4 +226,10 @@ export interface AgoraRtcSourceManager {
      */
     observeSystemSelectedMicrophoneChanged(enable: boolean): number;
     setLoopbackInstalled(installed: boolean): void;
+    /**
+     * Gets the media recorder manager for client-side recording.
+     * Only available on Electron platform.
+     * @returns The media recorder manager, or undefined if not supported.
+     */
+    getMediaRecorderManager(): AgoraRteClientRecordingManager | undefined;
 }