linx-simulator2/node_modules/mumble-client/lib/user.js

450 lines
13 KiB
JavaScript
Raw Normal View History

2019-09-18 08:11:16 +00:00
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _events = require('events');
var _dropStream = require('drop-stream');
var _dropStream2 = _interopRequireDefault(_dropStream);
var _removeValue = require('remove-value');
var _removeValue2 = _interopRequireDefault(_removeValue);
var _rtimer = require('rtimer');
var _rtimer2 = _interopRequireDefault(_rtimer);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var User = function (_EventEmitter) {
_inherits(User, _EventEmitter);
function User(client, id) {
_classCallCheck(this, User);
var _this = _possibleConstructorReturn(this, (User.__proto__ || Object.getPrototypeOf(User)).call(this));
_this._client = client;
_this._id = id;
_this._haveRequestedTexture = false;
_this._haveRequestedComment = false;
return _this;
}
_createClass(User, [{
key: '_update',
value: function _update(msg) {
var changes = {};
if (msg.name != null) {
changes.username = this._username = msg.name;
}
if (msg.user_id != null) {
changes.uniqueId = this._uniqueId = msg.user_id;
}
if (msg.mute != null) {
changes.mute = this._mute = msg.mute;
}
if (msg.deaf != null) {
changes.deaf = this._deaf = msg.deaf;
}
if (msg.suppress != null) {
changes.suppress = this._suppress = msg.suppress;
}
if (msg.self_mute != null) {
changes.selfMute = this._selfMute = msg.self_mute;
}
if (msg.self_deaf != null) {
changes.selfDeaf = this._selfDeaf = msg.self_deaf;
}
if (msg.texture != null) {
changes.texture = this._texture = msg.texture;
}
if (msg.texture_hash != null) {
changes.textureHash = this._textureHash = msg.texture_hash;
this._haveRequestedTexture = false; // invalidate previous request
}
if (msg.comment != null) {
changes.comment = this._comment = msg.comment;
}
if (msg.comment_hash != null) {
changes.commentHash = this._commentHash = msg.comment_hash;
this._haveRequestedComment = false; // invalidate previous request
}
if (msg.priority_speaker != null) {
changes.prioritySpeaker = this._prioritySpeaker = msg.priority_speaker;
}
if (msg.recording != null) {
changes.recording = this._recording = msg.recording;
}
if (msg.hash != null) {
changes.certHash = this._certHash = msg.hash;
}
if (msg.channel_id != null) {
if (this.channel) {
(0, _removeValue2.default)(this.channel.users, this);
}
this._channelId = msg.channel_id;
if (this.channel) {
this.channel.users.push(this);
}
changes.channel = this.channel;
}
this.emit('update', this._client._userById[msg.actor], changes);
}
}, {
key: '_remove',
value: function _remove(actor, reason, ban) {
if (this.channel) {
(0, _removeValue2.default)(this.channel.users, this);
}
this.emit('remove', actor, reason, ban);
}
}, {
key: '_getOrCreateVoiceStream',
value: function _getOrCreateVoiceStream() {
var _this2 = this;
if (!this._voice) {
// New transmission
if (!this._client._codecs) {
// No codecs available, cannot decode
this._voice = _dropStream2.default.obj();
} else {
this._voice = this._client._codecs.createDecoderStream(this);
}
this._voice.once('close', function () {
_this2._voice = null;
});
this._voiceTimeout = new _rtimer2.default(function () {
_this2._voice.end();
_this2._voice = null;
}, this._client._options.userVoiceTimeout || 200).set();
this.emit('voice', this._voice);
}
return this._voice;
}
}, {
key: '_getDuration',
value: function _getDuration(codec, frames) {
var _this3 = this;
if (this._client._codecs) {
var duration = 0;
frames.forEach(function (frame) {
duration += _this3._client._codecs.getDuration(codec, frame);
});
return duration;
} else {
return frames.length * 10;
}
}
/**
* This method filters and inserts empty frames as needed to accout
* for packet loss and then writes to the {@link #_voice} stream.
* If this is a new transmission it emits the 'voice' event and if
* the transmission has ended it closes the stream.
*/
}, {
key: '_onVoice',
value: function _onVoice(seqNum, codec, target, frames, position, end) {
var _this4 = this;
if (frames.length > 0) {
var duration = this._getDuration(codec, frames);
if (this._voice != null) {
// This is not the first packet in this transmission
// So drop it if it's late
if (this._lastVoiceSeqId > seqNum) {
return;
}
// And make up for lost packets
if (this._lastVoiceSeqId < seqNum - duration / 10) {
var lost = seqNum - this._lastVoiceSeqId - 1;
// Cap at 10 lost frames, the audio will sound broken at that point anyway
if (lost > 10) {
lost = 10;
}
for (var i = 0; i < lost; i++) {
this._getOrCreateVoiceStream().write({
target: target,
codec: codec,
frame: null,
position: position
});
}
}
}
frames.forEach(function (frame) {
_this4._getOrCreateVoiceStream().write({
target: target,
codec: codec,
frame: frame,
position: position
});
});
this._voiceTimeout.set();
this._lastVoiceSeqId = seqNum + duration / 10 - 1;
}
if (end && this._voice) {
this._voiceTimeout.clear();
this._voiceTimeout = null;
this._voice.end();
this._voice = null;
}
}
}, {
key: 'setMute',
value: function setMute(mute) {
var message = {
name: 'UserState',
payload: {
session: this._id,
mute: mute
}
};
if (!mute) message.payload.deaf = false;
this._client._send(message);
}
}, {
key: 'setDeaf',
value: function setDeaf(deaf) {
var message = {
name: 'UserState',
payload: {
session: this._id,
deaf: deaf
}
};
if (deaf) message.payload.mute = true;
this._client._send(message);
}
}, {
key: 'clearComment',
value: function clearComment() {
this._client._send({
name: 'UserState',
payload: {
session: this._id,
comment: ''
}
});
}
}, {
key: 'clearTexture',
value: function clearTexture() {
this._client._send({
name: 'UserState',
payload: {
session: this._id,
texture: ''
}
});
}
}, {
key: 'requestComment',
value: function requestComment() {
if (this._haveRequestedComment) return;
this._client._send({
name: 'RequestBlob',
payload: {
session_comment: this._id
}
});
this._haveRequestedComment = true;
}
}, {
key: 'requestTexture',
value: function requestTexture() {
if (this._haveRequestedTexture) return;
this._client._send({
name: 'RequestBlob',
payload: {
session_texture: this._id
}
});
this._haveRequestedTexture = true;
}
}, {
key: 'register',
value: function register() {
this._client._send({
name: 'UserState',
payload: {
session: this._id,
user_id: 0
}
});
}
}, {
key: 'sendMessage',
value: function sendMessage(message) {
this._client._send({
name: 'TextMessage',
payload: {
session: this._id,
message: message
}
});
}
}, {
key: 'setChannel',
value: function setChannel(channel) {
this._client._send({
name: 'UserState',
payload: {
session: this._id,
channel_id: channel._id
}
});
}
}, {
key: 'id',
get: function get() {
return this._id;
}
}, {
key: 'username',
get: function get() {
return this._username;
},
set: function set(to) {
throw new Error('Cannot set username.');
}
}, {
key: 'uniqueId',
get: function get() {
return this._uniqueId;
},
set: function set(to) {
throw new Error('Cannot set uniqueId. Maybe try #register()?');
}
}, {
key: 'mute',
get: function get() {
return this._mute;
},
set: function set(to) {
throw new Error('Cannot set mute. Use #setMute(mute) instead.');
}
}, {
key: 'deaf',
get: function get() {
return this._deaf;
},
set: function set(to) {
throw new Error('Cannot set deaf. Use #setDeaf(deaf) instead.');
}
}, {
key: 'selfMute',
get: function get() {
return this._selfMute;
},
set: function set(to) {
throw new Error('Cannot set selfMute. Use Client#setSelfMute(mute) instead.');
}
}, {
key: 'selfDeaf',
get: function get() {
return this._selfDeaf;
},
set: function set(to) {
throw new Error('Cannot set selfDeaf. Use Client#setSelfDeaf(deaf) instead.');
}
}, {
key: 'suppress',
get: function get() {
return this._suppress;
},
set: function set(to) {
throw new Error('Cannot set suppress.');
}
}, {
key: 'texture',
get: function get() {
return this._texture;
},
set: function set(to) {
throw new Error('Cannot set texture. Use Client#setSelfTexture(texture) or #clearTexture() instead.');
}
}, {
key: 'textureHash',
get: function get() {
return this._textureHash;
},
set: function set(to) {
throw new Error('Cannot set textureHash.');
}
}, {
key: 'comment',
get: function get() {
return this._comment;
},
set: function set(to) {
throw new Error('Cannot set comment. Use Client#setSelfTexture(texture) or #clearComment() instead.');
}
}, {
key: 'commentHash',
get: function get() {
return this._commentHash;
},
set: function set(to) {
throw new Error('Cannot set commentHash.');
}
}, {
key: 'prioritySpeaker',
get: function get() {
return this._prioritySpeaker;
},
set: function set(to) {
throw new Error('Cannot set prioritySpeaker. Use #setPrioritySpeaker(prioSpeaker) instead.');
}
}, {
key: 'recording',
get: function get() {
return this._recording;
},
set: function set(to) {
throw new Error('Cannot set recording. Use Client#setSelfRecording(recording) instead.');
}
}, {
key: 'certHash',
get: function get() {
return this._certHash;
},
set: function set(to) {
throw new Error('Cannot set certHash.');
}
}, {
key: 'channel',
get: function get() {
if (this._channelId != null) {
return this._client._channelById[this._channelId];
} else {
return null;
}
},
set: function set(to) {
throw new Error('Cannot set channel. Use #setChannel(channel) instead.');
}
}]);
return User;
}(_events.EventEmitter);
exports.default = User;