fcr-ui-scene 3.8.1-beta → 3.8.2

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

@@ -0,0 +1,402 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import { FcrVideoSourceType } from 'fcr-core/lib/type';
+import { AgoraObservable } from 'fcr-core/lib/imports';
+import { FcrPermissionAction, FcrStreamPrivilegeOperation, FcrStreamType, FcrUserRole } from 'fcr-core';
+import { FcrPrivilegeUserRole } from 'fcr-core/lib/room-control/privilege-control/type';
+import { hasPermissionWithTargetRoleEnabled, isPermissionWithTargetRoleEnabled } from '../utilities/privilege';
+import { transI18n } from 'agora-ui-foundation/lib/i18n';
+import { getUserRoleI18nLabel } from '../utilities/i18n-common-data';
+export var FcrUIDevicePrivilegeProviderImpl = /*#__PURE__*/function () {
+  function FcrUIDevicePrivilegeProviderImpl(_privilegeControl, _streamControl, _userControl, _deviceProvider, _messageProvider) {
+    var _this = this;
+    _classCallCheck(this, FcrUIDevicePrivilegeProviderImpl);
+    _defineProperty(this, "_firstGetMicrophonePrivilege", true);
+    _defineProperty(this, "_firstGetCameraPrivilege", true);
+    _defineProperty(this, "_observable", new AgoraObservable());
+    _defineProperty(this, "_alwaysHasCameraPrivilege", false);
+    _defineProperty(this, "_alwaysHasMicrophonePrivilege", false);
+    _defineProperty(this, "_autoUpdateVideoStreamPrivilege", true);
+    _defineProperty(this, "_autoUpdateAudioStreamPrivilege", true);
+    this._privilegeControl = _privilegeControl;
+    this._streamControl = _streamControl;
+    this._userControl = _userControl;
+    this._deviceProvider = _deviceProvider;
+    this._messageProvider = _messageProvider;
+    var localUserId = this._userControl.getLocalUser().userId;
+    this._privilegeObserver = {
+      onLocalUserPermissionInfoAdded: function () {
+        var _onLocalUserPermissionInfoAdded = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(roomId, event) {
+          var hasVideoPermission, localStream, hasVideo, hasAudioPermission, _localStream, hasAudio, _t, _t2;
+          return _regeneratorRuntime.wrap(function (_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                if (!_this._autoUpdateVideoStreamPrivilege) {
+                  _context.next = 4;
+                  break;
+                }
+                hasVideoPermission = hasPermissionWithTargetRoleEnabled(event.permissionInfo, FcrPermissionAction.StreamStartVideo, FcrPrivilegeUserRole.SELF);
+                localStream = _this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                  return stream.videoSourceType === FcrVideoSourceType.CAMERA;
+                });
+                hasVideo = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === FcrStreamType.VIDEO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === FcrStreamType.BOTH;
+                if (!hasVideoPermission) {
+                  _context.next = 4;
+                  break;
+                }
+                if (!(!hasVideo && localStream)) {
+                  _context.next = 4;
+                  break;
+                }
+                _context.prev = 1;
+                _context.next = 2;
+                return _this._streamControl.updatePublishPrivilegeOfStreams(_defineProperty({}, localStream.streamId, {
+                  videoPrivilege: FcrStreamPrivilegeOperation.HAS_PRIVILEGE,
+                  audioPrivilege: FcrStreamPrivilegeOperation.NOOPERATION
+                }));
+              case 2:
+                _context.next = 4;
+                break;
+              case 3:
+                _context.prev = 3;
+                _t = _context["catch"](1);
+              case 4:
+                if (!_this._autoUpdateAudioStreamPrivilege) {
+                  _context.next = 8;
+                  break;
+                }
+                hasAudioPermission = hasPermissionWithTargetRoleEnabled(event.permissionInfo, FcrPermissionAction.StreamStartAudio, FcrPrivilegeUserRole.SELF);
+                _localStream = _this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                  return stream.videoSourceType === FcrVideoSourceType.CAMERA;
+                });
+                hasAudio = (_localStream === null || _localStream === void 0 ? void 0 : _localStream.streamType) === FcrStreamType.AUDIO || (_localStream === null || _localStream === void 0 ? void 0 : _localStream.streamType) === FcrStreamType.BOTH;
+                if (!hasAudioPermission) {
+                  _context.next = 8;
+                  break;
+                }
+                if (!(!hasAudio && _localStream)) {
+                  _context.next = 8;
+                  break;
+                }
+                _context.prev = 5;
+                _context.next = 6;
+                return _this._streamControl.updatePublishPrivilegeOfStreams(_defineProperty({}, _localStream.streamId, {
+                  videoPrivilege: FcrStreamPrivilegeOperation.NOOPERATION,
+                  audioPrivilege: FcrStreamPrivilegeOperation.HAS_PRIVILEGE
+                }));
+              case 6:
+                _context.next = 8;
+                break;
+              case 7:
+                _context.prev = 7;
+                _t2 = _context["catch"](5);
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee, null, [[1, 3], [5, 7]]);
+        }));
+        function onLocalUserPermissionInfoAdded(_x, _x2) {
+          return _onLocalUserPermissionInfoAdded.apply(this, arguments);
+        }
+        return onLocalUserPermissionInfoAdded;
+      }()
+    };
+    this._streamObserver = {
+      onStreamsUpdated: function () {
+        var _onStreamsUpdated = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(roomId, events) {
+          var hasVideoPermission, hasAudioPermission;
+          return _regeneratorRuntime.wrap(function (_context2) {
+            while (1) switch (_context2.prev = _context2.next) {
+              case 0:
+                hasVideoPermission = hasPermissionWithTargetRoleEnabled(_this._privilegeControl.getAllLocalUserPermissionInfo(), FcrPermissionAction.StreamStartVideo, FcrPrivilegeUserRole.SELF);
+                hasAudioPermission = hasPermissionWithTargetRoleEnabled(_this._privilegeControl.getAllLocalUserPermissionInfo(), FcrPermissionAction.StreamStartAudio, FcrPrivilegeUserRole.SELF);
+                events.forEach(function (event) {
+                  var stream = event.modifiedStream;
+                  var operatorUser = event.operatorUser;
+                  var operatorUserRole = (operatorUser === null || operatorUser === void 0 ? void 0 : operatorUser.userRole) || FcrUserRole.HOST;
+                  if (stream.owner.userId === localUserId && (operatorUser === null || operatorUser === void 0 ? void 0 : operatorUser.userId) !== localUserId && stream.videoSourceType === FcrVideoSourceType.CAMERA) {
+                    var hasNoVideo = stream.streamType === FcrStreamType.NONE || stream.streamType === FcrStreamType.AUDIO;
+                    var hasNoAudio = stream.streamType === FcrStreamType.NONE || stream.streamType === FcrStreamType.VIDEO;
+                    var hasVideo = stream.streamType === FcrStreamType.VIDEO || stream.streamType === FcrStreamType.BOTH;
+                    var hasAudio = stream.streamType === FcrStreamType.AUDIO || stream.streamType === FcrStreamType.BOTH;
+                    if (!_this._alwaysHasCameraPrivilege) {
+                      _this._observable.notifyObservers('onOpenCameraPrivilegeUpdated', hasVideo);
+                      if (hasNoVideo) {
+                        if (_this._deviceProvider.cameraEnabled) {
+                          _this._messageProvider.showToast({
+                            type: 'error',
+                            message: transI18n('fmt_attendies_tips_receive_video_off_you', {
+                              reason1: getUserRoleI18nLabel(operatorUserRole)
+                            })
+                          });
+                        }
+                        _this._observable.notifyObservers('onCameraNeedClosed');
+                      }
+                    }
+                    if (!_this._alwaysHasMicrophonePrivilege) {
+                      _this._observable.notifyObservers('onOpenMicrophonePrivilegeUpdated', hasAudio);
+                      if (hasNoAudio) {
+                        var _event$operatorUser;
+                        var _operatorUserRole = ((_event$operatorUser = event.operatorUser) === null || _event$operatorUser === void 0 ? void 0 : _event$operatorUser.userRole) || FcrUserRole.HOST;
+                        if (_this._deviceProvider.microphoneEnabled) {
+                          _this._messageProvider.showToast({
+                            type: 'error',
+                            message: transI18n('fmt_attendies_tips_receive_mute_you', {
+                              reason1: getUserRoleI18nLabel(_operatorUserRole)
+                            })
+                          });
+                        }
+                        _this._observable.notifyObservers('onMicrophoneNeedClosed');
+                      }
+                    }
+                    var videoPrivilege = FcrStreamPrivilegeOperation.NOOPERATION;
+                    var audioPrivilege = FcrStreamPrivilegeOperation.NOOPERATION;
+
+                    // 当前流需要变更视频权限
+                    if (hasVideoPermission && !hasVideo) {
+                      if (_this._autoUpdateVideoStreamPrivilege) {
+                        videoPrivilege = hasVideoPermission ? FcrStreamPrivilegeOperation.HAS_PRIVILEGE : FcrStreamPrivilegeOperation.NOOPERATION;
+                      }
+                    }
+                    // 当前流需要变更音频权限
+                    if (hasAudioPermission && !hasAudio) {
+                      if (_this._autoUpdateAudioStreamPrivilege) {
+                        audioPrivilege = hasAudioPermission ? FcrStreamPrivilegeOperation.HAS_PRIVILEGE : FcrStreamPrivilegeOperation.NOOPERATION;
+                      }
+                    }
+                    // 更新流权限
+                    if (videoPrivilege !== FcrStreamPrivilegeOperation.NOOPERATION || audioPrivilege !== FcrStreamPrivilegeOperation.NOOPERATION) {
+                      _this._streamControl.updatePublishPrivilegeOfStreams(_defineProperty({}, stream.streamId, {
+                        videoPrivilege: videoPrivilege,
+                        audioPrivilege: audioPrivilege
+                      }));
+                    }
+                  }
+                });
+              case 1:
+              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 _createClass(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 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var permissionInfo, hasVideoPermission, localUserId, localStream, hasVideo, _t3;
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!this._alwaysHasCameraPrivilege) {
+                _context3.next = 1;
+                break;
+              }
+              return _context3.abrupt("return", true);
+            case 1:
+              permissionInfo = this._privilegeControl.getLocalUserPermissionInfo(FcrPermissionAction.StreamStartVideo);
+              hasVideoPermission = isPermissionWithTargetRoleEnabled(permissionInfo, FcrPrivilegeUserRole.SELF);
+              localUserId = this._userControl.getLocalUser().userId;
+              localStream = this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                return stream.videoSourceType === FcrVideoSourceType.CAMERA;
+              });
+              hasVideo = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === FcrStreamType.VIDEO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === FcrStreamType.BOTH;
+              if (!this._firstGetCameraPrivilege) {
+                _context3.next = 4;
+                break;
+              }
+              this._firstGetCameraPrivilege = false;
+              if (!hasVideo) {
+                _context3.next = 2;
+                break;
+              }
+              return _context3.abrupt("return", true);
+            case 2:
+              return _context3.abrupt("return", false);
+            case 3:
+              _context3.next = 12;
+              break;
+            case 4:
+              if (!hasVideoPermission) {
+                _context3.next = 11;
+                break;
+              }
+              if (!hasVideo) {
+                _context3.next = 5;
+                break;
+              }
+              return _context3.abrupt("return", true);
+            case 5:
+              if (!localStream) {
+                _context3.next = 9;
+                break;
+              }
+              _context3.prev = 6;
+              _context3.next = 7;
+              return this._streamControl.updatePublishPrivilegeOfStreams(_defineProperty({}, localStream.streamId, {
+                videoPrivilege: FcrStreamPrivilegeOperation.HAS_PRIVILEGE,
+                audioPrivilege: FcrStreamPrivilegeOperation.NOOPERATION
+              }));
+            case 7:
+              _context3.next = 9;
+              break;
+            case 8:
+              _context3.prev = 8;
+              _t3 = _context3["catch"](6);
+              return _context3.abrupt("return", false);
+            case 9:
+              return _context3.abrupt("return", true);
+            case 10:
+              _context3.next = 12;
+              break;
+            case 11:
+              return _context3.abrupt("return", false);
+            case 12:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[6, 8]]);
+      }));
+      function hasOpenCameraPrivilege() {
+        return _hasOpenCameraPrivilege.apply(this, arguments);
+      }
+      return hasOpenCameraPrivilege;
+    }()
+  }, {
+    key: "hasOpenMicrophonePrivilege",
+    value: function () {
+      var _hasOpenMicrophonePrivilege = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        var permissionInfo, hasAudioPermission, localUserId, localStream, hasAudio, _t4;
+        return _regeneratorRuntime.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              if (!this._alwaysHasMicrophonePrivilege) {
+                _context4.next = 1;
+                break;
+              }
+              return _context4.abrupt("return", true);
+            case 1:
+              permissionInfo = this._privilegeControl.getLocalUserPermissionInfo(FcrPermissionAction.StreamStartAudio);
+              hasAudioPermission = isPermissionWithTargetRoleEnabled(permissionInfo, FcrPrivilegeUserRole.SELF);
+              localUserId = this._userControl.getLocalUser().userId;
+              localStream = this._streamControl.getStreamsByUserId(localUserId).find(function (stream) {
+                return stream.videoSourceType === FcrVideoSourceType.CAMERA;
+              });
+              hasAudio = (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === FcrStreamType.AUDIO || (localStream === null || localStream === void 0 ? void 0 : localStream.streamType) === FcrStreamType.BOTH;
+              if (!this._firstGetMicrophonePrivilege) {
+                _context4.next = 4;
+                break;
+              }
+              this._firstGetMicrophonePrivilege = false;
+              if (!hasAudio) {
+                _context4.next = 2;
+                break;
+              }
+              return _context4.abrupt("return", true);
+            case 2:
+              return _context4.abrupt("return", false);
+            case 3:
+              _context4.next = 12;
+              break;
+            case 4:
+              if (!hasAudioPermission) {
+                _context4.next = 11;
+                break;
+              }
+              if (!hasAudio) {
+                _context4.next = 5;
+                break;
+              }
+              return _context4.abrupt("return", true);
+            case 5:
+              if (!localStream) {
+                _context4.next = 9;
+                break;
+              }
+              _context4.prev = 6;
+              _context4.next = 7;
+              return this._streamControl.updatePublishPrivilegeOfStreams(_defineProperty({}, localStream.streamId, {
+                videoPrivilege: FcrStreamPrivilegeOperation.NOOPERATION,
+                audioPrivilege: FcrStreamPrivilegeOperation.HAS_PRIVILEGE
+              }));
+            case 7:
+              _context4.next = 9;
+              break;
+            case 8:
+              _context4.prev = 8;
+              _t4 = _context4["catch"](6);
+              return _context4.abrupt("return", false);
+            case 9:
+              return _context4.abrupt("return", true);
+            case 10:
+              _context4.next = 12;
+              break;
+            case 11:
+              return _context4.abrupt("return", false);
+            case 12:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[6, 8]]);
+      }));
+      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);
+    }
+  }]);
+}();