fcr-ui-scene 3.4.0 → 3.4.2

package/lib/providers/device-privilege-provider.js

@@ -0,0 +1,415 @@
+"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.FcrUIDevicePrivilegeProviderImpl = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.array.find.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/esnext.async-iterator.find.js");
+require("core-js/modules/esnext.async-iterator.for-each.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.find.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/web.dom-collections.for-each.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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _imports = require("fcr-core/lib/imports");
+var _base = require("../base");
+var _fcrCore = require("fcr-core");
+var _type = require("fcr-core/lib/room-control/privilege-control/type");
+var _privilege = require("../utilities/privilege");
+var FcrUIDevicePrivilegeProviderImpl = exports.FcrUIDevicePrivilegeProviderImpl = /*#__PURE__*/function () {
+  function FcrUIDevicePrivilegeProviderImpl(_privilegeControl, _streamControl, _userControl) {
+    var _this = this;
+    (0, _classCallCheck2["default"])(this, FcrUIDevicePrivilegeProviderImpl);
+    (0, _defineProperty2["default"])(this, "_firstGetMicrophonePrivilege", true);
+    (0, _defineProperty2["default"])(this, "_observable", new _imports.AgoraObservable());
+    (0, _defineProperty2["default"])(this, "_alwaysHasCameraPrivilege", false);
+    (0, _defineProperty2["default"])(this, "_alwaysHasMicrophonePrivilege", false);
+    (0, _defineProperty2["default"])(this, "_autoUpdateVideoStreamPrivilege", true);
+    (0, _defineProperty2["default"])(this, "_autoUpdateAudioStreamPrivilege", true);
+    this._privilegeControl = _privilegeControl;
+    this._streamControl = _streamControl;
+    this._userControl = _userControl;
+    var localUserId = this._userControl.getLocalUser().userId;
+    this._privilegeObserver = {
+      onLocalUserPermissionInfoAdded: function () {
+        var _onLocalUserPermissionInfoAdded = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(roomId, event) {
+          var hasVideoPermission, localStream, hasVideo, hasAudioPermission, _localStream, hasAudio;
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                if (!_this._autoUpdateVideoStreamPrivilege) {
+                  _context.next = 13;
+                  break;
+                }
+                hasVideoPermission = (0, _privilege.hasPermissionWithTargetRoleEnabled)(event.permissionInfo, _fcrCore.FcrPermissionAction.StreamStartVideo, _type.FcrPrivilegeUserRole.SELF);
+                localStream = _this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                  return stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA;
+                });
+                hasVideo = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.VIDEO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+                if (!hasVideoPermission) {
+                  _context.next = 13;
+                  break;
+                }
+                if (!(!hasVideo && localStream)) {
+                  _context.next = 13;
+                  break;
+                }
+                _context.prev = 6;
+                _context.next = 9;
+                return _this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                  videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE,
+                  audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+                }));
+              case 9:
+                _context.next = 13;
+                break;
+              case 11:
+                _context.prev = 11;
+                _context.t0 = _context["catch"](6);
+              case 13:
+                if (!_this._autoUpdateAudioStreamPrivilege) {
+                  _context.next = 26;
+                  break;
+                }
+                hasAudioPermission = (0, _privilege.hasPermissionWithTargetRoleEnabled)(event.permissionInfo, _fcrCore.FcrPermissionAction.StreamStartAudio, _type.FcrPrivilegeUserRole.SELF);
+                _localStream = _this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                  return stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA;
+                });
+                hasAudio = (_localStream === null || _localStream === void 0 ? void 0 : _localStream.streamType) === _fcrCore.FcrStreamType.AUDIO || (_localStream === null || _localStream === void 0 ? void 0 : _localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+                if (!hasAudioPermission) {
+                  _context.next = 26;
+                  break;
+                }
+                if (!(!hasAudio && _localStream)) {
+                  _context.next = 26;
+                  break;
+                }
+                _context.prev = 19;
+                _context.next = 22;
+                return _this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, _localStream.streamId, {
+                  videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION,
+                  audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE
+                }));
+              case 22:
+                _context.next = 26;
+                break;
+              case 24:
+                _context.prev = 24;
+                _context.t1 = _context["catch"](19);
+              case 26:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee, null, [[6, 11], [19, 24]]);
+        }));
+        function onLocalUserPermissionInfoAdded(_x, _x2) {
+          return _onLocalUserPermissionInfoAdded.apply(this, arguments);
+        }
+        return onLocalUserPermissionInfoAdded;
+      }()
+      // onLocalUserPermissionInfoDeleted: async (roomId, event) => {
+      //   const localStream = this._streamControl
+      //     .getStreamsByUserId(localUserId)
+      //     .find((stream) => stream.videoSourceType === AgoraRtcVideoSourceType.CAMERA);
+
+      //   let videoPrivilege = FcrStreamPrivilegeOperation.NOOPERATION;
+      //   let audioPrivilege = FcrStreamPrivilegeOperation.NOOPERATION;
+
+      //   if (this._autoUpdateVideoStreamPrivilege) {
+      //     const videoPermissionHasBeenRemoved = event.permissionInfo.find((permissionInfo) => {
+      //       return permissionInfo.info?.action === FcrPermissionAction.StreamStartVideo;
+      //     });
+
+      //     videoPrivilege = videoPermissionHasBeenRemoved
+      //       ? FcrStreamPrivilegeOperation.NOPRIVILEGE
+      //       : FcrStreamPrivilegeOperation.NOOPERATION;
+      //   }
+
+      //   if (this._autoUpdateAudioStreamPrivilege) {
+      //     const audioPermissionHasBeenRemoved = event.permissionInfo.find((permissionInfo) => {
+      //       return permissionInfo.info?.action === FcrPermissionAction.StreamStartAudio;
+      //     });
+
+      //     audioPrivilege = audioPermissionHasBeenRemoved
+      //       ? FcrStreamPrivilegeOperation.NOPRIVILEGE
+      //       : FcrStreamPrivilegeOperation.NOOPERATION;
+      //   }
+
+      //   if (
+      //     localStream &&
+      //     (videoPrivilege !== FcrStreamPrivilegeOperation.NOOPERATION ||
+      //       audioPrivilege !== FcrStreamPrivilegeOperation.NOOPERATION)
+      //   ) {
+      //     try {
+      //       await this._streamControl.updatePublishPrivilegeOfStreams({
+      //         [localStream.streamId]: {
+      //           videoPrivilege,
+      //           audioPrivilege,
+      //         },
+      //       });
+      //     } catch (e) {}
+      //   }
+      // },
+    };
+    this._streamObserver = {
+      onStreamsUpdated: function () {
+        var _onStreamsUpdated = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(roomId, events) {
+          var hasVideoPermission, hasAudioPermission;
+          return _regenerator["default"].wrap(function _callee2$(_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                hasVideoPermission = (0, _privilege.hasPermissionWithTargetRoleEnabled)(_this._privilegeControl.getAllLocalUserPermissionInfo(), _fcrCore.FcrPermissionAction.StreamStartVideo, _type.FcrPrivilegeUserRole.SELF);
+                hasAudioPermission = (0, _privilege.hasPermissionWithTargetRoleEnabled)(_this._privilegeControl.getAllLocalUserPermissionInfo(), _fcrCore.FcrPermissionAction.StreamStartAudio, _type.FcrPrivilegeUserRole.SELF);
+                events.forEach(function (event) {
+                  var stream = event.modifiedStream;
+                  if (stream.owner.userId === localUserId && stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA) {
+                    var hasNoVideo = stream.streamType === _fcrCore.FcrStreamType.NONE || stream.streamType === _fcrCore.FcrStreamType.AUDIO;
+                    var hasNoAudio = stream.streamType === _fcrCore.FcrStreamType.NONE || stream.streamType === _fcrCore.FcrStreamType.VIDEO;
+                    var hasVideo = stream.streamType === _fcrCore.FcrStreamType.VIDEO || stream.streamType === _fcrCore.FcrStreamType.BOTH;
+                    var hasAudio = stream.streamType === _fcrCore.FcrStreamType.AUDIO || stream.streamType === _fcrCore.FcrStreamType.BOTH;
+                    if (!_this._alwaysHasCameraPrivilege) {
+                      _this._observable.notifyObservers('onOpenCameraPrivilegeUpdated', hasVideo);
+                      if (hasNoVideo) {
+                        _this._observable.notifyObservers('onCameraNeedClosed');
+                      }
+                    }
+                    if (!_this._alwaysHasMicrophonePrivilege) {
+                      _this._observable.notifyObservers('onOpenMicrophonePrivilegeUpdated', hasAudio);
+                      if (hasNoAudio) {
+                        _this._observable.notifyObservers('onMicrophoneNeedClosed');
+                      }
+                    }
+                    var videoPrivilege = _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION;
+                    var audioPrivilege = _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION;
+
+                    // 当前流需要变更视频权限
+                    if (hasVideoPermission && !hasVideo) {
+                      if (_this._autoUpdateVideoStreamPrivilege) {
+                        videoPrivilege = hasVideoPermission ? _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE : _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION;
+                      }
+                    }
+                    // 当前流需要变更音频权限
+                    if (hasAudioPermission && !hasAudio) {
+                      if (_this._autoUpdateAudioStreamPrivilege) {
+                        audioPrivilege = hasAudioPermission ? _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE : _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION;
+                      }
+                    }
+                    // 更新流权限
+                    if (videoPrivilege !== _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION || audioPrivilege !== _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION) {
+                      _this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, stream.streamId, {
+                        videoPrivilege: videoPrivilege,
+                        audioPrivilege: audioPrivilege
+                      }));
+                    }
+                  }
+                });
+              case 3:
+              case "end":
+                return _context2.stop();
+            }
+          }, _callee2);
+        }));
+        function onStreamsUpdated(_x3, _x4) {
+          return _onStreamsUpdated.apply(this, arguments);
+        }
+        return onStreamsUpdated;
+      }()
+    };
+    this._privilegeControl.addObserver(this._privilegeObserver);
+    this._streamControl.addObserver(this._streamObserver);
+  }
+  return (0, _createClass2["default"])(FcrUIDevicePrivilegeProviderImpl, [{
+    key: "release",
+    value: function release() {
+      this._privilegeControl.removeObserver(this._privilegeObserver);
+    }
+  }, {
+    key: "setAlwaysHasCameraPrivilege",
+    value: function setAlwaysHasCameraPrivilege(enable) {
+      this._alwaysHasCameraPrivilege = enable;
+    }
+  }, {
+    key: "setAlwaysHasMicrophonePrivilege",
+    value: function setAlwaysHasMicrophonePrivilege(enable) {
+      this._alwaysHasMicrophonePrivilege = enable;
+    }
+  }, {
+    key: "setAutoUpdateVideoStreamPrivilege",
+    value: function setAutoUpdateVideoStreamPrivilege(enable) {
+      this._autoUpdateVideoStreamPrivilege = enable;
+    }
+  }, {
+    key: "setAutoUpdateAudioStreamPrivilege",
+    value: function setAutoUpdateAudioStreamPrivilege(enable) {
+      this._autoUpdateAudioStreamPrivilege = enable;
+    }
+  }, {
+    key: "hasOpenCameraPrivilege",
+    value: function () {
+      var _hasOpenCameraPrivilege = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+        var permissionInfo, hasVideoPermission, localUserId, localStream, hasVideo;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!this._alwaysHasCameraPrivilege) {
+                _context3.next = 2;
+                break;
+              }
+              return _context3.abrupt("return", true);
+            case 2:
+              permissionInfo = this._privilegeControl.getLocalUserPermissionInfo(_fcrCore.FcrPermissionAction.StreamStartVideo);
+              hasVideoPermission = (0, _privilege.isPermissionWithTargetRoleEnabled)(permissionInfo, _type.FcrPrivilegeUserRole.SELF);
+              localUserId = this._userControl.getLocalUser().userId;
+              localStream = this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                return stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA;
+              });
+              hasVideo = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.VIDEO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+              if (!hasVideoPermission) {
+                _context3.next = 24;
+                break;
+              }
+              if (!hasVideo) {
+                _context3.next = 12;
+                break;
+              }
+              return _context3.abrupt("return", true);
+            case 12:
+              if (!localStream) {
+                _context3.next = 21;
+                break;
+              }
+              _context3.prev = 13;
+              _context3.next = 16;
+              return this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE,
+                audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION
+              }));
+            case 16:
+              _context3.next = 21;
+              break;
+            case 18:
+              _context3.prev = 18;
+              _context3.t0 = _context3["catch"](13);
+              return _context3.abrupt("return", false);
+            case 21:
+              return _context3.abrupt("return", true);
+            case 22:
+              _context3.next = 25;
+              break;
+            case 24:
+              return _context3.abrupt("return", false);
+            case 25:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[13, 18]]);
+      }));
+      function hasOpenCameraPrivilege() {
+        return _hasOpenCameraPrivilege.apply(this, arguments);
+      }
+      return hasOpenCameraPrivilege;
+    }()
+  }, {
+    key: "hasOpenMicrophonePrivilege",
+    value: function () {
+      var _hasOpenMicrophonePrivilege = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var permissionInfo, hasAudioPermission, localUserId, localStream, hasAudio;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              if (!this._alwaysHasMicrophonePrivilege) {
+                _context4.next = 2;
+                break;
+              }
+              return _context4.abrupt("return", true);
+            case 2:
+              permissionInfo = this._privilegeControl.getLocalUserPermissionInfo(_fcrCore.FcrPermissionAction.StreamStartAudio);
+              hasAudioPermission = (0, _privilege.isPermissionWithTargetRoleEnabled)(permissionInfo, _type.FcrPrivilegeUserRole.SELF);
+              localUserId = this._userControl.getLocalUser().userId;
+              localStream = this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                return stream.videoSourceType === _imports.AgoraRtcVideoSourceType.CAMERA;
+              });
+              hasAudio = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.AUDIO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === _fcrCore.FcrStreamType.BOTH;
+              if (!this._firstGetMicrophonePrivilege) {
+                _context4.next = 16;
+                break;
+              }
+              this._firstGetMicrophonePrivilege = false;
+              if (!hasAudio) {
+                _context4.next = 13;
+                break;
+              }
+              return _context4.abrupt("return", true);
+            case 13:
+              return _context4.abrupt("return", false);
+            case 14:
+              _context4.next = 34;
+              break;
+            case 16:
+              if (!hasAudioPermission) {
+                _context4.next = 33;
+                break;
+              }
+              if (!hasAudio) {
+                _context4.next = 21;
+                break;
+              }
+              return _context4.abrupt("return", true);
+            case 21:
+              if (!localStream) {
+                _context4.next = 30;
+                break;
+              }
+              _context4.prev = 22;
+              _context4.next = 25;
+              return this._streamControl.updatePublishPrivilegeOfStreams((0, _defineProperty2["default"])({}, localStream.streamId, {
+                videoPrivilege: _fcrCore.FcrStreamPrivilegeOperation.NOOPERATION,
+                audioPrivilege: _fcrCore.FcrStreamPrivilegeOperation.HAS_PRIVILEGE
+              }));
+            case 25:
+              _context4.next = 30;
+              break;
+            case 27:
+              _context4.prev = 27;
+              _context4.t0 = _context4["catch"](22);
+              return _context4.abrupt("return", false);
+            case 30:
+              return _context4.abrupt("return", true);
+            case 31:
+              _context4.next = 34;
+              break;
+            case 33:
+              return _context4.abrupt("return", false);
+            case 34:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[22, 27]]);
+      }));
+      function hasOpenMicrophonePrivilege() {
+        return _hasOpenMicrophonePrivilege.apply(this, arguments);
+      }
+      return hasOpenMicrophonePrivilege;
+    }()
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      this._observable.addObserver(observer);
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      this._observable.removeObserver(observer);
+    }
+  }]);
+}();
+(0, _base.registerDependency)('devicePrivilegeProvider');