529 lines
17 KiB
JavaScript
529 lines
17 KiB
JavaScript
/* global APP, $, config, interfaceConfig */
|
|
/*
|
|
* Copyright @ 2015 Atlassian Pty Ltd
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
const logger = require("jitsi-meet-logger").getLogger(__filename);
|
|
|
|
import UIEvents from "../../../service/UI/UIEvents";
|
|
import UIUtil from '../util/UIUtil';
|
|
import VideoLayout from '../videolayout/VideoLayout';
|
|
|
|
import {
|
|
JitsiRecordingStatus
|
|
} from '../../../react/features/base/lib-jitsi-meet';
|
|
import {
|
|
sendEvent
|
|
} from '../../../react/features/analytics';
|
|
import { setToolboxEnabled } from '../../../react/features/toolbox';
|
|
import { setNotificationsEnabled } from '../../../react/features/notifications';
|
|
import {
|
|
hideRecordingLabel,
|
|
updateRecordingState
|
|
} from '../../../react/features/recording';
|
|
|
|
/**
|
|
* Translation keys to use for display in the UI when recording the conference
|
|
* but not streaming live.
|
|
*
|
|
* @private
|
|
* @type {Object}
|
|
*/
|
|
export const RECORDING_TRANSLATION_KEYS = {
|
|
failedToStartKey: 'recording.failedToStart',
|
|
recordingBusy: 'liveStreaming.busy',
|
|
recordingButtonTooltip: 'recording.buttonTooltip',
|
|
recordingErrorKey: 'recording.error',
|
|
recordingOffKey: 'recording.off',
|
|
recordingOnKey: 'recording.on',
|
|
recordingPendingKey: 'recording.pending',
|
|
recordingTitle: 'dialog.recording',
|
|
recordingUnavailable: 'recording.unavailable'
|
|
};
|
|
|
|
/**
|
|
* Translation keys to use for display in the UI when the recording mode is
|
|
* currently streaming live.
|
|
*
|
|
* @private
|
|
* @type {Object}
|
|
*/
|
|
export const STREAMING_TRANSLATION_KEYS = {
|
|
failedToStartKey: 'liveStreaming.failedToStart',
|
|
recordingBusy: 'liveStreaming.busy',
|
|
recordingButtonTooltip: 'liveStreaming.buttonTooltip',
|
|
recordingErrorKey: 'liveStreaming.error',
|
|
recordingOffKey: 'liveStreaming.off',
|
|
recordingOnKey: 'liveStreaming.on',
|
|
recordingPendingKey: 'liveStreaming.pending',
|
|
recordingTitle: 'dialog.liveStreaming',
|
|
recordingUnavailable: 'liveStreaming.unavailable'
|
|
};
|
|
|
|
/**
|
|
* The dialog for user input.
|
|
*/
|
|
let dialog = null;
|
|
|
|
/**
|
|
* Indicates if the recording button should be enabled.
|
|
*
|
|
* @returns {boolean} {true} if the
|
|
* @private
|
|
*/
|
|
function _isRecordingButtonEnabled() {
|
|
return (
|
|
interfaceConfig.TOOLBAR_BUTTONS.indexOf("recording") !== -1
|
|
&& config.enableRecording
|
|
&& APP.conference.isRecordingSupported());
|
|
}
|
|
|
|
/**
|
|
* Request live stream token from the user.
|
|
* @returns {Promise}
|
|
*/
|
|
function _requestLiveStreamId() {
|
|
const cancelButton
|
|
= APP.translation.generateTranslationHTML("dialog.Cancel");
|
|
const backButton = APP.translation.generateTranslationHTML("dialog.Back");
|
|
const startStreamingButton
|
|
= APP.translation.generateTranslationHTML("dialog.startLiveStreaming");
|
|
const streamIdRequired
|
|
= APP.translation.generateTranslationHTML(
|
|
"liveStreaming.streamIdRequired");
|
|
const streamIdHelp
|
|
= APP.translation.generateTranslationHTML(
|
|
"liveStreaming.streamIdHelp");
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
dialog = APP.UI.messageHandler.openDialogWithStates({
|
|
state0: {
|
|
titleKey: "dialog.liveStreaming",
|
|
html:
|
|
`<input class="input-control"
|
|
name="streamId" type="text"
|
|
data-i18n="[placeholder]dialog.streamKey"
|
|
autofocus><div style="text-align: right">
|
|
<a class="helper-link" target="_new"
|
|
href="${interfaceConfig.LIVE_STREAMING_HELP_LINK}">`
|
|
+ streamIdHelp
|
|
+ `</a></div>`,
|
|
persistent: false,
|
|
buttons: [
|
|
{title: cancelButton, value: false},
|
|
{title: startStreamingButton, value: true}
|
|
],
|
|
focus: ':input:first',
|
|
defaultButton: 1,
|
|
submit: function (e, v, m, f) {
|
|
e.preventDefault();
|
|
|
|
if (v) {
|
|
if (f.streamId && f.streamId.length > 0) {
|
|
resolve(UIUtil.escapeHtml(f.streamId));
|
|
dialog.close();
|
|
return;
|
|
}
|
|
else {
|
|
dialog.goToState('state1');
|
|
return false;
|
|
}
|
|
} else {
|
|
reject(APP.UI.messageHandler.CANCEL);
|
|
dialog.close();
|
|
return false;
|
|
}
|
|
}
|
|
},
|
|
|
|
state1: {
|
|
titleKey: "dialog.liveStreaming",
|
|
html: streamIdRequired,
|
|
persistent: false,
|
|
buttons: [
|
|
{title: cancelButton, value: false},
|
|
{title: backButton, value: true}
|
|
],
|
|
focus: ':input:first',
|
|
defaultButton: 1,
|
|
submit: function (e, v) {
|
|
e.preventDefault();
|
|
if (v === 0) {
|
|
reject(APP.UI.messageHandler.CANCEL);
|
|
dialog.close();
|
|
} else {
|
|
dialog.goToState('state0');
|
|
}
|
|
}
|
|
}
|
|
}, {
|
|
close: function () {
|
|
dialog = null;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Request recording token from the user.
|
|
* @returns {Promise}
|
|
*/
|
|
function _requestRecordingToken() {
|
|
let titleKey = "dialog.recordingToken";
|
|
let msgString = (
|
|
`<input name="recordingToken" type="text"
|
|
data-i18n="[placeholder]dialog.token"
|
|
class="input-control"
|
|
autofocus>`
|
|
);
|
|
return new Promise(function (resolve, reject) {
|
|
dialog = APP.UI.messageHandler.openTwoButtonDialog({
|
|
titleKey,
|
|
msgString,
|
|
leftButtonKey: 'dialog.Save',
|
|
submitFunction: function (e, v, m, f) {
|
|
if (v && f.recordingToken) {
|
|
resolve(UIUtil.escapeHtml(f.recordingToken));
|
|
} else {
|
|
reject(APP.UI.messageHandler.CANCEL);
|
|
}
|
|
},
|
|
closeFunction: function () {
|
|
dialog = null;
|
|
},
|
|
focus: ':input:first'
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Shows a prompt dialog to the user when they have toggled off the recording.
|
|
*
|
|
* @param recordingType the recording type
|
|
* @returns {Promise}
|
|
* @private
|
|
*/
|
|
function _showStopRecordingPrompt(recordingType) {
|
|
var title;
|
|
var message;
|
|
var buttonKey;
|
|
if (recordingType === "jibri") {
|
|
title = "dialog.liveStreaming";
|
|
message = "dialog.stopStreamingWarning";
|
|
buttonKey = "dialog.stopLiveStreaming";
|
|
}
|
|
else {
|
|
title = "dialog.recording";
|
|
message = "dialog.stopRecordingWarning";
|
|
buttonKey = "dialog.stopRecording";
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
dialog = APP.UI.messageHandler.openTwoButtonDialog({
|
|
titleKey: title,
|
|
msgKey: message,
|
|
leftButtonKey: buttonKey,
|
|
submitFunction: (e, v) => (v ? resolve : reject)(),
|
|
closeFunction: () => {
|
|
dialog = null;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks whether if the given status is either PENDING or RETRYING
|
|
* @param status {JitsiRecordingStatus} Jibri status to be checked
|
|
* @returns {boolean} true if the condition is met or false otherwise.
|
|
*/
|
|
function isStartingStatus(status) {
|
|
return status === JitsiRecordingStatus.PENDING || status === JitsiRecordingStatus.RETRYING;
|
|
}
|
|
|
|
/**
|
|
* Manages the recording user interface and user experience.
|
|
* @type {{init, initRecordingButton, showRecordingButton, updateRecordingState,
|
|
* updateRecordingUI, checkAutoRecord}}
|
|
*/
|
|
var Recording = {
|
|
/**
|
|
* Initializes the recording UI.
|
|
*/
|
|
init(eventEmitter, recordingType) {
|
|
this.eventEmitter = eventEmitter;
|
|
this.recordingType = recordingType;
|
|
|
|
this.updateRecordingState(APP.conference.getRecordingState());
|
|
|
|
if (recordingType === 'jibri') {
|
|
this.baseClass = "fa fa-play-circle";
|
|
Object.assign(this, STREAMING_TRANSLATION_KEYS);
|
|
}
|
|
else {
|
|
this.baseClass = "icon-recEnable";
|
|
Object.assign(this, RECORDING_TRANSLATION_KEYS);
|
|
}
|
|
|
|
// XXX Due to the React-ification of Toolbox, the HTMLElement with id
|
|
// toolbar_button_record may not exist yet.
|
|
$(document).on(
|
|
'click',
|
|
'#toolbar_button_record',
|
|
ev => this._onToolbarButtonClick(ev));
|
|
|
|
// If I am a recorder then I publish my recorder custom role to notify
|
|
// everyone.
|
|
if (config.iAmRecorder) {
|
|
VideoLayout.enableDeviceAvailabilityIcons(
|
|
APP.conference.getMyUserId(), false);
|
|
VideoLayout.setLocalVideoVisible(false);
|
|
APP.store.dispatch(setToolboxEnabled(false));
|
|
APP.store.dispatch(setNotificationsEnabled(false));
|
|
APP.UI.messageHandler.enablePopups(false);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Initialise the recording button.
|
|
*/
|
|
initRecordingButton() {
|
|
const selector = $('#toolbar_button_record');
|
|
|
|
selector.addClass(this.baseClass);
|
|
selector.attr("data-i18n", "[content]" + this.recordingButtonTooltip);
|
|
APP.translation.translateElement(selector);
|
|
},
|
|
|
|
/**
|
|
* Shows or hides the 'recording' button.
|
|
* @param show {true} to show the recording button, {false} to hide it
|
|
*/
|
|
showRecordingButton(show) {
|
|
let shouldShow = show && _isRecordingButtonEnabled();
|
|
let id = 'toolbar_button_record';
|
|
|
|
UIUtil.setVisible(id, shouldShow);
|
|
},
|
|
|
|
/**
|
|
* Updates the recording state UI.
|
|
* @param recordingState gives us the current recording state
|
|
*/
|
|
updateRecordingState(recordingState) {
|
|
// I'm the recorder, so I don't want to see any UI related to states.
|
|
if (config.iAmRecorder)
|
|
return;
|
|
|
|
// If there's no state change, we ignore the update.
|
|
if (!recordingState || this.currentState === recordingState)
|
|
return;
|
|
|
|
this.updateRecordingUI(recordingState);
|
|
},
|
|
|
|
/**
|
|
* Sets the state of the recording button.
|
|
* @param recordingState gives us the current recording state
|
|
*/
|
|
updateRecordingUI(recordingState) {
|
|
|
|
let oldState = this.currentState;
|
|
this.currentState = recordingState;
|
|
|
|
let labelDisplayConfiguration;
|
|
|
|
switch (recordingState) {
|
|
case JitsiRecordingStatus.ON:
|
|
case JitsiRecordingStatus.RETRYING: {
|
|
labelDisplayConfiguration = {
|
|
centered: false,
|
|
key: this.recordingOnKey,
|
|
showSpinner: recordingState === JitsiRecordingStatus.RETRYING
|
|
};
|
|
|
|
this._setToolbarButtonToggled(true);
|
|
|
|
break;
|
|
}
|
|
|
|
case JitsiRecordingStatus.OFF:
|
|
case JitsiRecordingStatus.BUSY:
|
|
case JitsiRecordingStatus.FAILED:
|
|
case JitsiRecordingStatus.UNAVAILABLE: {
|
|
const wasInStartingStatus = isStartingStatus(oldState);
|
|
|
|
// We don't want UI changes if this is an availability change.
|
|
if (oldState !== JitsiRecordingStatus.ON && !wasInStartingStatus) {
|
|
APP.store.dispatch(updateRecordingState({ recordingState }));
|
|
return;
|
|
}
|
|
|
|
labelDisplayConfiguration = {
|
|
centered: true,
|
|
key: wasInStartingStatus
|
|
? this.failedToStartKey
|
|
: this.recordingOffKey
|
|
};
|
|
|
|
this._setToolbarButtonToggled(false);
|
|
|
|
setTimeout(function(){
|
|
APP.store.dispatch(hideRecordingLabel());
|
|
}, 5000);
|
|
|
|
break;
|
|
}
|
|
|
|
case JitsiRecordingStatus.PENDING: {
|
|
labelDisplayConfiguration = {
|
|
centered: true,
|
|
key: this.recordingPendingKey
|
|
};
|
|
|
|
this._setToolbarButtonToggled(false);
|
|
|
|
break;
|
|
}
|
|
|
|
case JitsiRecordingStatus.ERROR: {
|
|
labelDisplayConfiguration = {
|
|
centered: true,
|
|
key: this.recordingErrorKey
|
|
};
|
|
|
|
this._setToolbarButtonToggled(false);
|
|
|
|
break;
|
|
}
|
|
|
|
// Return an empty label display configuration to indicate no label
|
|
// should be displayed. The JitsiRecordingStatus.AVAIABLE case is handled here.
|
|
default: {
|
|
labelDisplayConfiguration = null;
|
|
}
|
|
}
|
|
|
|
APP.store.dispatch(updateRecordingState({
|
|
labelDisplayConfiguration,
|
|
recordingState
|
|
}));
|
|
},
|
|
|
|
// checks whether recording is enabled and whether we have params
|
|
// to start automatically recording
|
|
checkAutoRecord() {
|
|
if (_isRecordingButtonEnabled && config.autoRecord) {
|
|
this.predefinedToken = UIUtil.escapeHtml(config.autoRecordToken);
|
|
this.eventEmitter.emit(UIEvents.RECORDING_TOGGLED,
|
|
this.predefinedToken);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Handles {@code click} on {@code toolbar_button_record}.
|
|
*
|
|
* @returns {void}
|
|
*/
|
|
_onToolbarButtonClick() {
|
|
if (dialog) {
|
|
return;
|
|
}
|
|
|
|
sendEvent('recording.clicked');
|
|
switch (this.currentState) {
|
|
case JitsiRecordingStatus.ON:
|
|
case JitsiRecordingStatus.RETRYING:
|
|
case JitsiRecordingStatus.PENDING: {
|
|
_showStopRecordingPrompt(this.recordingType).then(
|
|
() => {
|
|
this.eventEmitter.emit(UIEvents.RECORDING_TOGGLED);
|
|
sendEvent('recording.stopped');
|
|
},
|
|
() => {});
|
|
break;
|
|
}
|
|
case JitsiRecordingStatus.AVAILABLE:
|
|
case JitsiRecordingStatus.OFF: {
|
|
if (this.recordingType === 'jibri')
|
|
_requestLiveStreamId().then(streamId => {
|
|
this.eventEmitter.emit(
|
|
UIEvents.RECORDING_TOGGLED,
|
|
{ streamId });
|
|
sendEvent('recording.started');
|
|
}).catch(reason => {
|
|
if (reason !== APP.UI.messageHandler.CANCEL)
|
|
logger.error(reason);
|
|
else
|
|
sendEvent('recording.canceled');
|
|
});
|
|
else {
|
|
if (this.predefinedToken) {
|
|
this.eventEmitter.emit(
|
|
UIEvents.RECORDING_TOGGLED,
|
|
{ token: this.predefinedToken });
|
|
sendEvent('recording.started');
|
|
return;
|
|
}
|
|
|
|
_requestRecordingToken().then((token) => {
|
|
this.eventEmitter.emit(
|
|
UIEvents.RECORDING_TOGGLED,
|
|
{ token });
|
|
sendEvent('recording.started');
|
|
}).catch(reason => {
|
|
if (reason !== APP.UI.messageHandler.CANCEL)
|
|
logger.error(reason);
|
|
else
|
|
sendEvent('recording.canceled');
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case JitsiRecordingStatus.BUSY: {
|
|
dialog = APP.UI.messageHandler.openMessageDialog(
|
|
this.recordingTitle,
|
|
this.recordingBusy,
|
|
null,
|
|
() => {
|
|
dialog = null;
|
|
}
|
|
);
|
|
break;
|
|
}
|
|
default: {
|
|
dialog = APP.UI.messageHandler.openMessageDialog(
|
|
this.recordingTitle,
|
|
this.recordingUnavailable,
|
|
null,
|
|
() => {
|
|
dialog = null;
|
|
}
|
|
);
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Sets the toggled state of the recording toolbar button.
|
|
*
|
|
* @param {boolean} isToggled indicates if the button should be toggled
|
|
* or not
|
|
*/
|
|
_setToolbarButtonToggled(isToggled) {
|
|
$("#toolbar_button_record").toggleClass("toggled", isToggled);
|
|
}
|
|
};
|
|
|
|
export default Recording;
|