fcr-ui-scene 3.7.4 → 3.7.6

package/lib/providers/screen-share/strategy/browser.js

@@ -0,0 +1,266 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIBrowserScreenShareStrategy = 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.object.to-string.js");
+require("core-js/modules/es.promise.js");
+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 _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _fcrCore = require("fcr-core");
+var _logger = require("../../../utilities/logger");
+var _type = require("./type");
+var _objectManager2 = require("../../../object-manager");
+var _type2 = require("fcr-core/lib/type");
+var _defaultConfig = require("../../../utilities/default-config");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var FcrUIBrowserScreenShareStrategy = exports.FcrUIBrowserScreenShareStrategy = /*#__PURE__*/function (_FcrUIScreenShareStra) {
+  function FcrUIBrowserScreenShareStrategy(_objectManager) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, FcrUIBrowserScreenShareStrategy);
+    _this = _callSuper(this, FcrUIBrowserScreenShareStrategy);
+    (0, _defineProperty2["default"])(_this, "logger", (0, _logger.createLogger)({
+      prefix: 'BrowserScreenShareStrategy'
+    }));
+    (0, _defineProperty2["default"])(_this, "_screenTrack", null);
+    (0, _defineProperty2["default"])(_this, "_loopbackDeviceId", 'default');
+    (0, _defineProperty2["default"])(_this, "_isReplacing", false);
+    _this._objectManager = _objectManager;
+    var engine = _objectManager.getObject(_objectManager2.FcrUIObjectKeys.CORE_ENGINE);
+    _this._mediaControl = engine.getDesktopMediaControl();
+    _this._screenTrackObserver = {
+      onScreenCaptureStateUpdated: function onScreenCaptureStateUpdated(sourceId, state) {
+        if (state === _fcrCore.FcrMediaSourceState.ERROR) {
+          _this._screenTrack = null;
+          _this.observable.notifyObservers('onScreenCaptureError', sourceId, _type.FcrUIScreenShareCaptureError.UNKNOWN);
+        }
+        if (state === _fcrCore.FcrMediaSourceState.CLOSE) {
+          _this._screenTrack = null;
+          if (!_this._isReplacing) {
+            _this.observable.notifyObservers('onScreenCaptureStopped', sourceId);
+          }
+        }
+        if (state === _fcrCore.FcrMediaSourceState.OPEN) {
+          if (!_this._isReplacing) {
+            _this.observable.notifyObservers('onScreenCaptureStarted', sourceId);
+          }
+        }
+      }
+    };
+    return _this;
+  }
+  (0, _inherits2["default"])(FcrUIBrowserScreenShareStrategy, _FcrUIScreenShareStra);
+  return (0, _createClass2["default"])(FcrUIBrowserScreenShareStrategy, [{
+    key: "getScreenTrack",
+    value: function getScreenTrack() {
+      return this._screenTrack;
+    }
+  }, {
+    key: "getLoopbackDeviceId",
+    value: function getLoopbackDeviceId() {
+      return this._loopbackDeviceId;
+    }
+  }, {
+    key: "startLoopbackCapture",
+    value: function startLoopbackCapture(params) {
+      return Promise.resolve();
+    }
+  }, {
+    key: "stopLoopbackCapture",
+    value: function stopLoopbackCapture() {
+      return Promise.resolve();
+    }
+  }, {
+    key: "replaceScreenCaptureSource",
+    value: function () {
+      var _replaceScreenCaptureSource = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_ref) {
+        var sourceId, screenTrack, _t;
+        return _regenerator["default"].wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              sourceId = _ref.sourceId;
+              if (sourceId) {
+                _context.next = 1;
+                break;
+              }
+              throw new Error('sourceId is required');
+            case 1:
+              this._isReplacing = true;
+              screenTrack = this._screenTrack;
+              if (!screenTrack) {
+                _context.next = 2;
+                break;
+              }
+              _context.next = 2;
+              return this._stopTrackAndWaitUntilSuccess(screenTrack);
+            case 2:
+              screenTrack = this._mediaControl.getScreenTrack(sourceId);
+              _context.prev = 3;
+              _context.next = 4;
+              return this._startTrackAndWaitUntilSuccess(screenTrack);
+            case 4:
+              this.observable.notifyObservers('onScreenCaptureReplaced', sourceId);
+              _context.next = 6;
+              break;
+            case 5:
+              _context.prev = 5;
+              _t = _context["catch"](3);
+              this.observable.notifyObservers('onScreenCaptureStopped', sourceId);
+            case 6:
+              this._isReplacing = false;
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[3, 5]]);
+      }));
+      function replaceScreenCaptureSource(_x) {
+        return _replaceScreenCaptureSource.apply(this, arguments);
+      }
+      return replaceScreenCaptureSource;
+    }()
+  }, {
+    key: "startScreenCapture",
+    value: function () {
+      var _startScreenCapture = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(_ref2) {
+        var sourceId, screenTrack;
+        return _regenerator["default"].wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              sourceId = _ref2.sourceId;
+              screenTrack = this._mediaControl.getScreenTrack(sourceId);
+              _context2.next = 1;
+              return this._startTrackAndWaitUntilSuccess(screenTrack);
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function startScreenCapture(_x2) {
+        return _startScreenCapture.apply(this, arguments);
+      }
+      return startScreenCapture;
+    }()
+  }, {
+    key: "stopScreenCapture",
+    value: function () {
+      var _stopScreenCapture = (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._screenTrack) {
+                _context3.next = 1;
+                break;
+              }
+              _context3.next = 1;
+              return this._stopTrackAndWaitUntilSuccess(this._screenTrack);
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function stopScreenCapture() {
+        return _stopScreenCapture.apply(this, arguments);
+      }
+      return stopScreenCapture;
+    }()
+  }, {
+    key: "_startTrackAndWaitUntilSuccess",
+    value: function () {
+      var _startTrackAndWaitUntilSuccess2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(screenTrack) {
+        var _this2 = this;
+        var p;
+        return _regenerator["default"].wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              this._screenTrack = screenTrack;
+              p = new Promise(function (resolve, reject) {
+                var waitObserver = {
+                  onScreenCaptureStateUpdated: function onScreenCaptureStateUpdated(sourceId, state) {
+                    if (state === _fcrCore.FcrMediaSourceState.OPEN) {
+                      screenTrack.removeObserver(waitObserver);
+                      resolve();
+                    }
+                    if (state === _fcrCore.FcrMediaSourceState.ERROR) {
+                      screenTrack.removeObserver(waitObserver);
+                      _this2._screenTrack = null;
+                      reject(new Error('error occurred while starting screen track'));
+                    }
+                  }
+                };
+                screenTrack.addObserver(waitObserver);
+              });
+              screenTrack.addObserver(this._screenTrackObserver);
+              screenTrack.setCaptureParams({
+                withAudio: true,
+                dimensions: _defaultConfig.screenCaptureHighStreamEncoderConfig.dimensions,
+                frameRate: _defaultConfig.screenCaptureHighStreamEncoderConfig.frameRate,
+                bitrate: _defaultConfig.screenCaptureHighStreamEncoderConfig.bitrate
+              });
+              screenTrack.start(_type2.FcrScreenCaptureType.SCREEN, []);
+              _context4.next = 1;
+              return p;
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function _startTrackAndWaitUntilSuccess(_x3) {
+        return _startTrackAndWaitUntilSuccess2.apply(this, arguments);
+      }
+      return _startTrackAndWaitUntilSuccess;
+    }()
+  }, {
+    key: "_stopTrackAndWaitUntilSuccess",
+    value: function () {
+      var _stopTrackAndWaitUntilSuccess2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(screenTrack) {
+        var p;
+        return _regenerator["default"].wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              p = new Promise(function (resolve) {
+                var waitObserver = {
+                  onScreenCaptureStateUpdated: function onScreenCaptureStateUpdated(sourceId, state) {
+                    if (state === _fcrCore.FcrMediaSourceState.CLOSE || state === _fcrCore.FcrMediaSourceState.ERROR) {
+                      screenTrack.removeObserver(waitObserver);
+                      resolve();
+                    }
+                  }
+                };
+                screenTrack.addObserver(waitObserver);
+              });
+              screenTrack.stop();
+              _context5.next = 1;
+              return p;
+            case 1:
+              screenTrack.removeObserver(this._screenTrackObserver);
+              this._screenTrack = null;
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function _stopTrackAndWaitUntilSuccess(_x4) {
+        return _stopTrackAndWaitUntilSuccess2.apply(this, arguments);
+      }
+      return _stopTrackAndWaitUntilSuccess;
+    }()
+  }]);
+}(_type.FcrUIScreenShareStrategy);

package/lib/providers/screen-share/strategy/electron.d.ts

@@ -0,0 +1,22 @@
+import { FcrScreenTrack } from 'fcr-core/lib/media-control/type';
+import { FcrUIScreenCaptureStartParams, FcrUIScreenLoopbackCaptureStartParams, FcrUIScreenShareStrategy } from './type';
+import { FcrUIObjectManager } from '../../../object-manager';
+export declare class FcrUIElectronScreenShareStrategy extends FcrUIScreenShareStrategy {
+    private readonly _objectManager;
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _screenTrackObserver;
+    private _screenTrack;
+    private _loopbackTrack;
+    private _mediaControl;
+    private _isReplacing;
+    constructor(_objectManager: FcrUIObjectManager);
+    startScreenCapture({ sourceId, captureType, excludeWindows, dimensions, frameRate, bitrate, }: FcrUIScreenCaptureStartParams): Promise<void>;
+    stopScreenCapture(): Promise<void>;
+    startLoopbackCapture(params: FcrUIScreenLoopbackCaptureStartParams): Promise<void>;
+    stopLoopbackCapture(): Promise<void>;
+    getScreenTrack(): FcrScreenTrack | null;
+    getLoopbackDeviceId(): string | null;
+    replaceScreenCaptureSource({ sourceId, captureType, excludeWindows, dimensions, frameRate, bitrate, }: FcrUIScreenCaptureStartParams): Promise<void>;
+    private _startTrackAndWaitUntilSuccess;
+    private _stopTrackAndWaitUntilSuccess;
+}

package/lib/providers/screen-share/strategy/electron.js

@@ -0,0 +1,294 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FcrUIElectronScreenShareStrategy = 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.object.to-string.js");
+require("core-js/modules/es.promise.js");
+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 _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _logger = require("../../../utilities/logger");
+var _type = require("./type");
+var _objectManager2 = require("../../../object-manager");
+var _fcrCore = require("fcr-core");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var FcrUIElectronScreenShareStrategy = exports.FcrUIElectronScreenShareStrategy = /*#__PURE__*/function (_FcrUIScreenShareStra) {
+  function FcrUIElectronScreenShareStrategy(_objectManager) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, FcrUIElectronScreenShareStrategy);
+    _this = _callSuper(this, FcrUIElectronScreenShareStrategy);
+    (0, _defineProperty2["default"])(_this, "logger", (0, _logger.createLogger)({
+      prefix: 'ElectronScreenShareStrategy'
+    }));
+    (0, _defineProperty2["default"])(_this, "_screenTrack", null);
+    (0, _defineProperty2["default"])(_this, "_loopbackTrack", null);
+    (0, _defineProperty2["default"])(_this, "_isReplacing", false);
+    _this._objectManager = _objectManager;
+    var engine = _objectManager.getObject(_objectManager2.FcrUIObjectKeys.CORE_ENGINE);
+    _this._mediaControl = engine.getDesktopMediaControl();
+    _this._screenTrackObserver = {
+      onScreenCaptureStateUpdated: function onScreenCaptureStateUpdated(sourceId, state) {
+        if (state === _fcrCore.FcrMediaSourceState.ERROR) {
+          _this._screenTrack = null;
+          _this.observable.notifyObservers('onScreenCaptureError', sourceId, _type.FcrUIScreenShareCaptureError.UNKNOWN);
+        }
+        if (state === _fcrCore.FcrMediaSourceState.CLOSE) {
+          _this._screenTrack = null;
+          if (!_this._isReplacing) {
+            _this.observable.notifyObservers('onScreenCaptureStopped', sourceId);
+          }
+        }
+        if (state === _fcrCore.FcrMediaSourceState.OPEN) {
+          if (_this._isReplacing) {
+            _this._isReplacing = false;
+            _this.observable.notifyObservers('onScreenCaptureReplaced', sourceId);
+          } else {
+            _this.observable.notifyObservers('onScreenCaptureStarted', sourceId);
+          }
+        }
+      }
+    };
+    return _this;
+  }
+  (0, _inherits2["default"])(FcrUIElectronScreenShareStrategy, _FcrUIScreenShareStra);
+  return (0, _createClass2["default"])(FcrUIElectronScreenShareStrategy, [{
+    key: "startScreenCapture",
+    value: function () {
+      var _startScreenCapture = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_ref) {
+        var sourceId, captureType, excludeWindows, dimensions, frameRate, bitrate, screenTrack;
+        return _regenerator["default"].wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              sourceId = _ref.sourceId, captureType = _ref.captureType, excludeWindows = _ref.excludeWindows, dimensions = _ref.dimensions, frameRate = _ref.frameRate, bitrate = _ref.bitrate;
+              if (sourceId) {
+                _context.next = 1;
+                break;
+              }
+              throw new Error('sourceId is required');
+            case 1:
+              screenTrack = this._mediaControl.getScreenTrack(sourceId);
+              _context.next = 2;
+              return this._startTrackAndWaitUntilSuccess(screenTrack, captureType, excludeWindows, dimensions, frameRate, bitrate);
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function startScreenCapture(_x) {
+        return _startScreenCapture.apply(this, arguments);
+      }
+      return startScreenCapture;
+    }()
+  }, {
+    key: "stopScreenCapture",
+    value: function () {
+      var _stopScreenCapture = (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._screenTrack) {
+                _context2.next = 1;
+                break;
+              }
+              _context2.next = 1;
+              return this._stopTrackAndWaitUntilSuccess(this._screenTrack);
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function stopScreenCapture() {
+        return _stopScreenCapture.apply(this, arguments);
+      }
+      return stopScreenCapture;
+    }()
+  }, {
+    key: "startLoopbackCapture",
+    value: function startLoopbackCapture(params) {
+      var loopbackList = this._mediaControl.getLoopbackList();
+      if (loopbackList.length === 0) {
+        this.logger.error('no loopback devices found');
+        return Promise.resolve();
+      }
+      var loopbackDeviceId = loopbackList[0].deviceId;
+      var loopbackTrack = this._mediaControl.getLoopbackTrack(loopbackDeviceId);
+      this._loopbackTrack = loopbackTrack;
+      if (loopbackTrack) {
+        loopbackTrack.start();
+      }
+      return Promise.resolve();
+    }
+  }, {
+    key: "stopLoopbackCapture",
+    value: function stopLoopbackCapture() {
+      if (this._loopbackTrack) {
+        this._loopbackTrack.stop();
+      }
+      return Promise.resolve();
+    }
+  }, {
+    key: "getScreenTrack",
+    value: function getScreenTrack() {
+      return this._screenTrack;
+    }
+  }, {
+    key: "getLoopbackDeviceId",
+    value: function getLoopbackDeviceId() {
+      var loopbackList = this._mediaControl.getLoopbackList();
+      if (loopbackList.length === 0) {
+        this.logger.error('no loopback devices found');
+        return null;
+      }
+      return loopbackList[0].deviceId;
+    }
+  }, {
+    key: "replaceScreenCaptureSource",
+    value: function () {
+      var _replaceScreenCaptureSource = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref2) {
+        var sourceId, captureType, excludeWindows, dimensions, frameRate, bitrate, screenTrack;
+        return _regenerator["default"].wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              sourceId = _ref2.sourceId, captureType = _ref2.captureType, excludeWindows = _ref2.excludeWindows, dimensions = _ref2.dimensions, frameRate = _ref2.frameRate, bitrate = _ref2.bitrate;
+              if (sourceId) {
+                _context3.next = 1;
+                break;
+              }
+              throw new Error('sourceId is required');
+            case 1:
+              this._isReplacing = true;
+              screenTrack = this._screenTrack;
+              if (!screenTrack) {
+                _context3.next = 2;
+                break;
+              }
+              _context3.next = 2;
+              return this._stopTrackAndWaitUntilSuccess(screenTrack);
+            case 2:
+              screenTrack = this._mediaControl.getScreenTrack(sourceId);
+              _context3.next = 3;
+              return this._startTrackAndWaitUntilSuccess(screenTrack, captureType, excludeWindows, dimensions, frameRate, bitrate);
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function replaceScreenCaptureSource(_x2) {
+        return _replaceScreenCaptureSource.apply(this, arguments);
+      }
+      return replaceScreenCaptureSource;
+    }()
+  }, {
+    key: "_startTrackAndWaitUntilSuccess",
+    value: function () {
+      var _startTrackAndWaitUntilSuccess2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(screenTrack, captureType) {
+        var _this2 = this;
+        var excludeWindows,
+          dimensions,
+          frameRate,
+          bitrate,
+          p,
+          _args4 = arguments;
+        return _regenerator["default"].wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              excludeWindows = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : [];
+              dimensions = _args4.length > 3 ? _args4[3] : undefined;
+              frameRate = _args4.length > 4 ? _args4[4] : undefined;
+              bitrate = _args4.length > 5 ? _args4[5] : undefined;
+              this._screenTrack = screenTrack;
+              p = new Promise(function (resolve, reject) {
+                var waitObserver = {
+                  onScreenCaptureStateUpdated: function onScreenCaptureStateUpdated(sourceId, state) {
+                    _this2.logger.info("startTrackAndWaitUntilSuccess, sourceId: ".concat(sourceId, ", state: ").concat(state));
+                    if (state === _fcrCore.FcrMediaSourceState.OPEN) {
+                      screenTrack.removeObserver(waitObserver);
+                      resolve();
+                    }
+                    if (state === _fcrCore.FcrMediaSourceState.ERROR) {
+                      screenTrack.removeObserver(waitObserver);
+                      _this2._screenTrack = null;
+                      reject(new Error('error occurred while starting screen track'));
+                    }
+                  }
+                };
+                screenTrack.addObserver(waitObserver);
+              });
+              screenTrack.addObserver(this._screenTrackObserver);
+              screenTrack.setCaptureParams({
+                withAudio: true,
+                dimensions: dimensions,
+                frameRate: frameRate,
+                bitrate: bitrate
+              });
+              screenTrack.start(captureType, excludeWindows);
+              _context4.next = 1;
+              return p;
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function _startTrackAndWaitUntilSuccess(_x3, _x4) {
+        return _startTrackAndWaitUntilSuccess2.apply(this, arguments);
+      }
+      return _startTrackAndWaitUntilSuccess;
+    }()
+  }, {
+    key: "_stopTrackAndWaitUntilSuccess",
+    value: function () {
+      var _stopTrackAndWaitUntilSuccess2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(screenTrack) {
+        var _this3 = this;
+        var p;
+        return _regenerator["default"].wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              p = new Promise(function (resolve) {
+                var waitObserver = {
+                  onScreenCaptureStateUpdated: function onScreenCaptureStateUpdated(sourceId, state) {
+                    _this3.logger.info("stopTrackAndWaitUntilSuccess, sourceId: ".concat(sourceId, ", state: ").concat(state));
+                    if (state === _fcrCore.FcrMediaSourceState.CLOSE || state === _fcrCore.FcrMediaSourceState.ERROR) {
+                      screenTrack.removeObserver(waitObserver);
+                      resolve();
+                    }
+                  }
+                };
+                screenTrack.addObserver(waitObserver);
+              });
+              screenTrack.stop();
+              _context5.next = 1;
+              return p;
+            case 1:
+              screenTrack.removeObserver(this._screenTrackObserver);
+              this._screenTrack = null;
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function _stopTrackAndWaitUntilSuccess(_x5) {
+        return _stopTrackAndWaitUntilSuccess2.apply(this, arguments);
+      }
+      return _stopTrackAndWaitUntilSuccess;
+    }()
+  }]);
+}(_type.FcrUIScreenShareStrategy);

package/lib/providers/screen-share/strategy/type.d.ts

@@ -0,0 +1,39 @@
+import { AgoraObservable } from 'agora-foundation/lib/utilities/observable';
+import { FcrScreenTrack } from 'fcr-core/lib/media-control/type';
+import { FcrScreenCaptureType } from 'fcr-core/lib/type';
+import { FcrUIManagedObject } from '../../../object-manager';
+export declare enum FcrUIScreenShareCaptureError {
+    UNKNOWN = 0
+}
+export interface FcrUIScreenShareObserver {
+    onScreenCaptureStarted?: (sourceId: string) => void;
+    onScreenCaptureStopped?: (sourceId: string) => void;
+    onScreenCaptureReplaced?: (sourceId: string) => void;
+    onScreenCaptureError?: (sourceId: string, code: FcrUIScreenShareCaptureError) => void;
+}
+export declare abstract class FcrUIScreenShareStrategy implements FcrUIManagedObject {
+    protected observable: AgoraObservable<FcrUIScreenShareObserver>;
+    abstract startScreenCapture(params: FcrUIScreenCaptureStartParams): Promise<void>;
+    abstract stopScreenCapture(): Promise<void>;
+    abstract startLoopbackCapture(params: FcrUIScreenLoopbackCaptureStartParams): Promise<void>;
+    abstract stopLoopbackCapture(): Promise<void>;
+    abstract replaceScreenCaptureSource(params: FcrUIScreenCaptureStartParams): Promise<void>;
+    abstract getScreenTrack(): FcrScreenTrack | null;
+    abstract getLoopbackDeviceId(): string | null;
+    addObserver(observer: FcrUIScreenShareObserver): void;
+    removeObserver(observer: FcrUIScreenShareObserver): void;
+    release(): void;
+}
+export interface FcrUIScreenCaptureStartParams {
+    sourceId: string;
+    captureType: FcrScreenCaptureType;
+    excludeWindows?: string[];
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    frameRate: number;
+    bitrate: number;
+}
+export interface FcrUIScreenLoopbackCaptureStartParams {
+}

package/lib/providers/screen-share/strategy/type.js

@@ -0,0 +1,39 @@
+"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.FcrUIScreenShareStrategy = exports.FcrUIScreenShareCaptureError = void 0;
+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 _observable = require("agora-foundation/lib/utilities/observable");
+var FcrUIScreenShareCaptureError = exports.FcrUIScreenShareCaptureError = /*#__PURE__*/function (FcrUIScreenShareCaptureError) {
+  // NO_SCREEN_RECORDING_PERMISSION = 1,
+  FcrUIScreenShareCaptureError[FcrUIScreenShareCaptureError["UNKNOWN"] = 0] = "UNKNOWN";
+  return FcrUIScreenShareCaptureError;
+}({});
+var FcrUIScreenShareStrategy = exports.FcrUIScreenShareStrategy = /*#__PURE__*/function () {
+  function FcrUIScreenShareStrategy() {
+    (0, _classCallCheck2["default"])(this, FcrUIScreenShareStrategy);
+    (0, _defineProperty2["default"])(this, "observable", new _observable.AgoraObservable());
+  }
+  return (0, _createClass2["default"])(FcrUIScreenShareStrategy, [{
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this.observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this.observable.removeObserver(observer);
+    }
+  }, {
+    key: "release",
+    value: function release() {
+      this.observable.removeAllObservers();
+    }
+  }]);
+}();

package/lib/providers/screen-share/stream-state-sync.d.ts

@@ -0,0 +1,18 @@
+import { FcrUIManagedObject, FcrUIObjectManager } from '../../object-manager';
+import { FcrScreenStreamCreateConfig } from 'fcr-core/lib/room-control/stream-control/type';
+import { FcrVideoEncoderConfig } from 'fcr-core/lib/type';
+import { FcrUIScreenStreamUpdateParams } from './type';
+export declare class FcrUIScreenStreamSync implements FcrUIManagedObject {
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _myCurrentScreenShareStreamId;
+    private _sharingControl;
+    private _streamControl;
+    private _released;
+    constructor(objectManager: FcrUIObjectManager);
+    release(): void;
+    checkIfMyScreenShareStreamExists(): string | null;
+    startScreenStream(createConfig: FcrScreenStreamCreateConfig, encoderConfig: FcrVideoEncoderConfig): Promise<void>;
+    stopScreenStream(): Promise<void>;
+    updateStream({ videoSourceId, audioPublishPrivilege, videoPublishPrivilege, }: FcrUIScreenStreamUpdateParams): Promise<void>;
+    isLocalScreenStreamCreated(): boolean;
+}