595 lines
25 KiB
JavaScript
595 lines
25 KiB
JavaScript
// The recording must be fed certain events, and as a simplification to consumers, it will emit state engine transition events.
|
|
// This class automatically watches for server notifications relating to recordings (start/stop), as well as backend events
|
|
// inputs:
|
|
// * startRecording: user wants to start a recording
|
|
// * stopRecording: user wants to stop recording
|
|
//
|
|
// events:
|
|
// * startingRecording: a recording has been requested, but isn't confirmed started
|
|
// * startedRecording: a recording is officially started
|
|
// * stoppingRecording: a stop to the current recording has been requested, but it isn't confirmed yet
|
|
// * stoppedRecording: a recording is not running
|
|
// *
|
|
|
|
(function(context,$) {
|
|
|
|
"use strict";
|
|
|
|
context.JK = context.JK || {};
|
|
var logger = context.JK.logger;
|
|
|
|
context.JK.RecordingModel = function(app, _rest, _jamClient) {
|
|
var currentRecording = null; // the JSON response from the server for a recording
|
|
var currentOrLastRecordingId = null;
|
|
var currentRecordingId = null;
|
|
var thisClientStartedRecording = false; // set by the person who starts it
|
|
var rest = _rest;
|
|
var currentlyRecording = false;
|
|
var startingRecording = false;
|
|
var stoppingRecording = false;
|
|
var waitingOnServerStop = false;
|
|
var waitingOnClientStop = false;
|
|
var waitingOnStopTimer = null;
|
|
var jamClient = _jamClient;
|
|
|
|
var sessionId = null;
|
|
var $self = $(this);
|
|
|
|
function getState() {
|
|
return {
|
|
waitingOnClientStop: waitingOnClientStop,
|
|
waitingOnServerStop: waitingOnServerStop,
|
|
stoppingRecording: stoppingRecording,
|
|
startingRecording: startingRecording
|
|
}
|
|
}
|
|
function isRecording (recordingId) {
|
|
// if you specify recordingId, the check is more exact
|
|
if(recordingId) {
|
|
return recordingId == currentRecordingId;
|
|
}
|
|
else {
|
|
// if you omit recordingId, then we'll just check if we are recording at all
|
|
return currentlyRecording;
|
|
}
|
|
}
|
|
|
|
function getThisClientStartedRecording() {
|
|
return thisClientStartedRecording;
|
|
}
|
|
|
|
/** called every time a session is joined, to ensure clean state */
|
|
function reset(_sessionId) {
|
|
console.log("[RecordingState]: reset")
|
|
currentlyRecording = false;
|
|
waitingOnServerStop = false;
|
|
waitingOnClientStop = false;
|
|
if(waitingOnStopTimer != null) {
|
|
clearTimeout(waitingOnStopTimer);
|
|
waitingOnStopTimer = null;
|
|
}
|
|
currentRecording = null;
|
|
currentRecordingId = null;
|
|
stoppingRecording = false;
|
|
thisClientStartedRecording = false;
|
|
sessionId = _sessionId
|
|
}
|
|
|
|
|
|
|
|
function groupTracksToClient(recording) {
|
|
// group N tracks to the same client Id
|
|
var groupedTracks = {};
|
|
var recordingTracks = recording["recorded_tracks"];
|
|
for (var i = 0; i < recordingTracks.length; i++) {
|
|
var clientId = recordingTracks[i].client_id;
|
|
|
|
var tracksForClient = groupedTracks[clientId];
|
|
if (!tracksForClient) {
|
|
tracksForClient = [];
|
|
groupedTracks[clientId] = tracksForClient;
|
|
}
|
|
tracksForClient.push(recordingTracks[i]);
|
|
}
|
|
return context.JK.dkeys(groupedTracks);
|
|
}
|
|
|
|
function startRecording(recordSettings) {
|
|
const recordVideo = recordSettings.recordingType == context.JK.RECORD_TYPE_BOTH
|
|
//const recordChat = recordSettings.includeChat
|
|
//const recordFramerate = recordSettings.frameRate
|
|
|
|
$self.triggerHandler('startingRecording', {});
|
|
|
|
currentlyRecording = true;
|
|
stoppingRecording = false;
|
|
thisClientStartedRecording = true;
|
|
|
|
context.RecordingActions.startingRecording({isRecording: false})
|
|
|
|
currentRecording = rest.startRecordingPromise({"music_session_id": sessionId, record_video: recordVideo})
|
|
currentRecording
|
|
.then(async function(recording) {
|
|
currentRecordingId = recording.id;
|
|
currentOrLastRecordingId = recording.id;
|
|
|
|
// ask the backend to start the session.
|
|
var groupedTracks = groupTracksToClient(recording);
|
|
//await jamClient.StartRecording(recording["id"], groupedTracks, recordVideo, recordChat, recordFramerate);
|
|
console.log("jamClient#StartMediaRecording", recordSettings)
|
|
await jamClient.StartMediaRecording(recording["id"], groupedTracks, recordSettings)
|
|
})
|
|
.catch(function(jqXHR) {
|
|
console.warn("failed to startRecording due to server issue:", jqXHR.responseJSON)
|
|
var details = { clientId: app.clientId, reason: 'rest', detail: arguments, isRecording: false }
|
|
$self.triggerHandler('startedRecording', details);
|
|
currentlyRecording = false;
|
|
context.RecordingActions.startedRecording(details);
|
|
})
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
/** Nulls can be passed for all 3 currently; that's a user request. */
|
|
async function stopRecording(recordingId, reason, detail) {
|
|
|
|
const userInitiated = recordingId == null && reason == null && detail == null
|
|
const recording = await currentRecording
|
|
|
|
//if(recording.owner.id !== context.JK.currentUserId){
|
|
// return;
|
|
//}
|
|
|
|
console.log(`[RecordingState]: stopRecording userInitiated=${userInitiated} thisClientStartedRecording=${thisClientStartedRecording} reason=${reason} detail=${detail}`)
|
|
|
|
if(stoppingRecording) {
|
|
console.log("ignoring stopRecording because we are already stopping");
|
|
return;
|
|
}
|
|
stoppingRecording = true;
|
|
|
|
|
|
waitingOnServerStop = waitingOnClientStop = true;
|
|
waitingOnStopTimer = setTimeout(timeoutTransitionToStop, 5000);
|
|
|
|
$self.triggerHandler('stoppingRecording', {reason: reason, detail: detail});
|
|
context.RecordingActions.stoppingRecording({reason: reason, detail: detail, isRecording:true})
|
|
|
|
// this path assumes that the currentRecording info has, or can be, retrieved
|
|
// failure for currentRecording is handled elsewhere
|
|
currentRecording
|
|
.then(async function(recording) {
|
|
var groupedTracks = groupTracksToClient(recording);
|
|
|
|
//if(sessionModel.jamTracks() && isRecording()) {
|
|
// console.log("preemptive stop media")
|
|
//context.jamClient.SessionStopPlay();
|
|
//}
|
|
|
|
//await jamClient.StopRecording(recording.id, groupedTracks);
|
|
await jamClient.FrontStopRecording(recording.id, groupedTracks);
|
|
|
|
if(thisClientStartedRecording) {
|
|
rest.stopRecording({"id": recording.id})
|
|
.done(function () {
|
|
waitingOnServerStop = false;
|
|
attemptTransitionToStop(recording.id, reason, detail);
|
|
stoppingRecording = false
|
|
})
|
|
.fail(function (jqXHR) {
|
|
stoppingRecording = false
|
|
if (jqXHR.status == 422) {
|
|
waitingOnServerStop = false;
|
|
attemptTransitionToStop(recording.id, reason, detail);
|
|
} else {
|
|
logger.error("unable to stop recording %o", arguments);
|
|
transitionToStopped();
|
|
var details = {
|
|
'recordingId': recording.id,
|
|
'reason': 'rest',
|
|
'details': arguments,
|
|
isRecording: false
|
|
}
|
|
$self.triggerHandler('stoppedRecording', details);
|
|
context.RecordingActions.stoppedRecording(details)
|
|
stoppingRecording = false
|
|
}
|
|
});
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
async function abortRecording(recordingId, errorReason, errorDetail) {
|
|
await jamClient.AbortRecording(recordingId, {reason: errorReason, detail: errorDetail, success:false});
|
|
}
|
|
|
|
function timeoutTransitionToStop() {
|
|
// doh. couldn't stop
|
|
waitingOnStopTimer = null;
|
|
transitionToStopped();
|
|
$self.triggerHandler('stoppedRecordingFailed', { 'reason' : 'timeout' });
|
|
}
|
|
|
|
// Only tell the user that we've stopped once both server and client agree we've stopped
|
|
function attemptTransitionToStop(recordingId, errorReason, errorDetail) {
|
|
|
|
if(!waitingOnClientStop && !waitingOnServerStop) {
|
|
transitionToStopped();
|
|
var details = {recordingId: recordingId, reason: errorReason, detail: errorDetail, isRecording: false}
|
|
$self.triggerHandler('stoppedRecording', details)
|
|
context.RecordingActions.stoppedRecording(details)
|
|
}
|
|
}
|
|
|
|
function transitionToStopped() {
|
|
console.log("[RecordingState] transitionToStopped")
|
|
currentlyRecording = false;
|
|
currentRecording = null;
|
|
currentRecordingId = null;
|
|
if(waitingOnStopTimer) {
|
|
clearTimeout(waitingOnStopTimer);
|
|
waitingOnStopTimer = null;
|
|
}
|
|
}
|
|
|
|
function onServerStartRecording() {
|
|
//alert("onServerStartRecording")
|
|
var session = context.SessionStore.getCurrentOrLastSession();
|
|
if (!session) {
|
|
console.log("no session, so no recording");
|
|
return;
|
|
}
|
|
context.SessionStore.updateSessionInfo(session, true)
|
|
}
|
|
|
|
function onServerStopRecording(recordingId) {
|
|
console.log("[RecordingState] onServerStopRecording")
|
|
var session = context.SessionStore.getCurrentOrLastSession();
|
|
|
|
if (!session) {
|
|
console.log("no session, so no recording");
|
|
return;
|
|
}
|
|
context.SessionStore.updateSessionInfo(session, true)
|
|
|
|
getCurrentRecordingState().then(function (recordingState) {
|
|
if (recordingState.isRecording && recordingState.thisClientStartedRecording) {
|
|
// we are still recording, so don't transition to stopped
|
|
console.log("recording is still running, so don't transition to stopped");
|
|
return;
|
|
}
|
|
stopRecording(recordingId, null, null);
|
|
});
|
|
|
|
}
|
|
|
|
function handleRecordingStartResult(recordingId, result) {
|
|
console.log("[RecordingState] handleRecordingStartResult", {
|
|
recordingId,
|
|
result,
|
|
currentRecordingId,
|
|
currentlyRecording
|
|
});
|
|
|
|
var success = result.success;
|
|
var reason = result.reason;
|
|
var detail = result.detail
|
|
|
|
if(success) {
|
|
var details = {clientId: app.clientId, isRecording:true}
|
|
$self.triggerHandler('startedRecording', details)
|
|
context.RecordingActions.startedRecording(details)
|
|
}
|
|
else {
|
|
currentlyRecording = false;
|
|
logger.error("unable to start the recording %o, %o", reason, detail);
|
|
var details = { clientId: app.clientId, reason: reason, detail: detail, isRecording: false}
|
|
$self.triggerHandler('startedRecording', details);
|
|
context.RecordingActions.startedRecording(details)
|
|
}
|
|
}
|
|
|
|
function handleRecordingStopResult(recordingId, result) {
|
|
console.log("[RecordingState] handleRecordingStopResult", result)
|
|
var success = result.success;
|
|
var reason = result.reason;
|
|
var detail = result.detail;
|
|
|
|
waitingOnClientStop = false;
|
|
|
|
if(success) {
|
|
attemptTransitionToStop(recordingId, reason, detail);
|
|
}
|
|
else {
|
|
transitionToStopped();
|
|
logger.error("backend unable to stop the recording %o, %o", reason, detail);
|
|
var details = {recordingId: recordingId, reason: reason, detail : detail, isRecording: false}
|
|
$self.triggerHandler('stoppedRecording', details);
|
|
context.RecordingActions.stoppedRecording(details)
|
|
}
|
|
}
|
|
|
|
function postServerRecordingFetch(recording) {
|
|
|
|
if(currentRecordingId == null) {
|
|
currentRecordingId = recording.id;
|
|
currentOrLastRecordingId = recording.id;
|
|
|
|
var details = {recordingId: currentRecordingId, isRecording: false}
|
|
$self.triggerHandler('startingRecording', details);
|
|
context.RecordingActions.startingRecording(details);
|
|
currentlyRecording = true;
|
|
|
|
details = {clientId: app.clientId, recordingId: currentRecordingId, isRecording: true}
|
|
$self.triggerHandler('startedRecording', details);
|
|
context.RecordingActions.startedRecording(details);
|
|
}
|
|
else if (currentRecordingId == recording.id) {
|
|
// noop - we fetched recording but we already know about it
|
|
}
|
|
else {
|
|
console.error("[RecordingState] we've missed the stop of previous recording", currentRecordingId, recording.id);
|
|
context.JK.Banner.showAlert("The JamKazam application is out-of-sync on this recording. " +
|
|
"Please leave the session and re-join to fix the issue.");
|
|
}
|
|
}
|
|
|
|
function handleRecordingStarted(recordingId, result, clientId) {
|
|
reset(sessionId);
|
|
context.RecordingActions.resetRecordingState()
|
|
|
|
console.log("[RecordingState] handleRecordingStarted called", {
|
|
recordingId,
|
|
result,
|
|
clientId,
|
|
currentRecordingId,
|
|
currentlyRecording,
|
|
sessionId
|
|
});
|
|
|
|
var success = result.success;
|
|
var reason = result.reason;
|
|
var detail = result.detail;
|
|
|
|
// in this scenario, we don't know all the tracks of the user.
|
|
// we need to ask sessionModel to populate us with the recording data ASAP
|
|
console.log("[RecordingState] Attempting to fetch recording data from server", {
|
|
recordingId,
|
|
sessionId,
|
|
currentUserId: context.JK.currentUserId
|
|
});
|
|
|
|
currentRecording = rest.getRecordingPromise({id: recordingId})
|
|
currentRecording
|
|
.then(function(recording) {
|
|
console.log("[RecordingState] Successfully fetched recording data from server", {
|
|
recordingId: recording.id,
|
|
ownerId: recording.owner?.id,
|
|
currentUserId: context.JK.currentUserId,
|
|
recordingState: recording
|
|
});
|
|
postServerRecordingFetch(recording)
|
|
})
|
|
.catch(function(error) {
|
|
console.error("[RecordingState] Failed to fetch recording data", {
|
|
recordingId,
|
|
error,
|
|
errorMessage: error.message,
|
|
errorStatus: error.status,
|
|
errorResponse: error.responseJSON,
|
|
sessionId,
|
|
currentUserId: context.JK.currentUserId,
|
|
currentRecordingId,
|
|
currentlyRecording
|
|
});
|
|
});
|
|
}
|
|
|
|
function handleRecordingStopped(recordingId, result) {
|
|
console.log("[RecordingState] handleRecordingStopped event_id=" + recordingId + " current_id=" + currentRecordingId, result)
|
|
var session = context.SessionStore.getCurrentOrLastSession();
|
|
|
|
if(session) {
|
|
context.SessionStore.updateSessionInfo(session, true)
|
|
}
|
|
|
|
if(recordingId == "video") {
|
|
// comes from VideoRecordingStopped
|
|
return;
|
|
}
|
|
|
|
var success = result.success;
|
|
var reason = result.reason;
|
|
var detail = result.detail;
|
|
|
|
|
|
var details = {recordingId: recordingId, reason: reason, detail: detail, isRecording: true }
|
|
$self.triggerHandler('stoppingRecording', details);
|
|
context.RecordingActions.stoppingRecording(details)
|
|
|
|
// the backend says the recording must be stopped.
|
|
// tell the server to stop it too
|
|
if(recordingId == null || recordingId == "") {
|
|
// this occurs when you are told by the backend to stop; i.e., you are a non-creator of the
|
|
// recording. Stop, don't tell the server to stop; you aren't supposed to hve permission to
|
|
transitionToStopped();
|
|
var details = {recordingId: recordingId, reason: reason, detail: detail, isRecording: false}
|
|
context.RecordingActions.stoppedRecording(details);
|
|
return;
|
|
}
|
|
rest.stopRecording({
|
|
id: recordingId
|
|
})
|
|
.always(function() {
|
|
transitionToStopped();
|
|
})
|
|
.fail(function(jqXHR, textStatus, errorMessage) {
|
|
if(jqXHR.status == 422) {
|
|
console.log("recording already stopped %o", arguments);
|
|
var details = {recordingId: recordingId, reason: reason, detail: detail, isRecording: false}
|
|
$self.triggerHandler('stoppedRecording', details);
|
|
context.RecordingActions.stoppedRecording(details)
|
|
}
|
|
else if(jqXHR.status == 404) {
|
|
console.log("recording is already deleted %o", arguments);
|
|
var details = {recordingId: recordingId, reason: reason, detail: detail, isRecording: false}
|
|
$self.triggerHandler('stoppedRecording', details);
|
|
context.RecordingActions.stoppedRecording(details)
|
|
}
|
|
else {
|
|
var details = {recordingId: recordingId, reason: textStatus, detail: errorMessage, isRecording: false}
|
|
$self.triggerHandler('stoppedRecording', details);
|
|
context.RecordingActions.stoppedRecording(details)
|
|
}
|
|
})
|
|
.done(function() {
|
|
var details = {recordingId: recordingId, reason: reason, detail: detail, isRecording: false}
|
|
$self.triggerHandler('stoppedRecording', details);
|
|
context.RecordingActions.stoppedRecording(details)
|
|
})
|
|
}
|
|
|
|
function handleRecordingAborted(recordingId, result) {
|
|
console.log("[RecordingState] handleRecordingAborted")
|
|
if(recordingId == "video") {
|
|
|
|
// comes from AbortedVideoRecording
|
|
recordingId = result;
|
|
if (arguments.length == 2) {
|
|
result = arguments[2]
|
|
}
|
|
console.log("video recording aborted", result)
|
|
context.JK.Banner.showAlert("Video has stopped recording. Audio is still recording.")
|
|
//context.RecordingActions.stopRecording()
|
|
|
|
return;
|
|
}
|
|
|
|
var success = result.success;
|
|
var reason = result.reason;
|
|
var detail = result.detail;
|
|
|
|
stoppingRecording = false;
|
|
|
|
var details = {recordingId: recordingId, reason: reason, detail: detail, isRecording: false }
|
|
$self.triggerHandler('abortedRecording', details);
|
|
context.RecordingActions.abortedRecording(details)
|
|
// the backend says the recording must be stopped.
|
|
// tell the server to stop it too
|
|
rest.stopRecording({
|
|
id: recordingId
|
|
})
|
|
.always(function() {
|
|
currentlyRecording = false;
|
|
})
|
|
}
|
|
|
|
/**
|
|
* If a stop is needed, it will be issued, and the deferred object will fire done()
|
|
* If a stop is not needed (i.e., there is no recording), then the deferred object will fire immediately
|
|
* @returns {$.Deferred} in all cases, only .done() is fired.
|
|
*/
|
|
function stopRecordingIfNeeded() {
|
|
var deferred = new $.Deferred();
|
|
|
|
function resolved() {
|
|
$self.off('stoppedRecording.stopRecordingIfNeeded', resolved);
|
|
deferred.resolve(arguments);
|
|
}
|
|
|
|
if(!currentlyRecording) {
|
|
deferred = new $.Deferred();
|
|
deferred.resolve();
|
|
}
|
|
else {
|
|
// wait for the next stoppedRecording event message
|
|
$self.on('stoppedRecording.stopRecordingIfNeeded', resolved);
|
|
|
|
if(!stopRecording()) {
|
|
// no event is coming, so satisfy the deferred immediately
|
|
$self.off('stoppedRecording.stopRecordingIfNeeded', resolved);
|
|
deferred = new $.Deferred();
|
|
deferred.resolve();
|
|
}
|
|
}
|
|
|
|
return deferred;
|
|
|
|
}
|
|
|
|
/**
|
|
* sync recording state with the client back end
|
|
* Describe exactly when we should fetch recording state from the server
|
|
* 1. If backend sends stopped/stopping/abort event
|
|
* 2. If track changes occurs
|
|
* 3.
|
|
* TOOD: describe exactly when we should fetch recording state from the client
|
|
* TODO: don't couple them into this one method
|
|
*
|
|
*/
|
|
async function getCurrentRecordingState() {
|
|
var recording = null;
|
|
var session = context.SessionStore.getCurrentOrLastSession();
|
|
var recordingId = await context.jamClient.GetCurrentRecordingId();
|
|
|
|
var isRecording = recordingId && recordingId != "";
|
|
|
|
if (session && isRecording) {
|
|
try {
|
|
recording = await rest.getRecordingPromise({ id: recordingId })
|
|
} catch (error) {
|
|
if(error.status != 404) {
|
|
console.error("[RecordingState] Failed to fetch server recording state", {
|
|
recordingId,
|
|
error,
|
|
errorMessage: error.message,
|
|
errorStatus: error.status,
|
|
errorResponse: error.responseJSON,
|
|
sessionId: session.id,
|
|
currentUserId: context.JK.currentUserId
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!session) {
|
|
console.debug("no session, so no recording");
|
|
return { isRecording: false, serverRecording: null, thisClientStartedRecording: false };
|
|
}
|
|
|
|
return {
|
|
isRecording: isRecording,
|
|
isServerRecording: !!recording,
|
|
thisClientStartedRecording: thisClientStartedRecording
|
|
}
|
|
}
|
|
|
|
|
|
this.initialize = function() {
|
|
};
|
|
|
|
this.startRecording = startRecording;
|
|
this.stopRecording = stopRecording;
|
|
this.onServerStopRecording = onServerStopRecording;
|
|
this.onServerStartRecording = onServerStartRecording;
|
|
this.isRecording = isRecording;
|
|
this.getThisClientStartedRecording = getThisClientStartedRecording;
|
|
this.reset = reset;
|
|
this.stopRecordingIfNeeded = stopRecordingIfNeeded;
|
|
this.getState = getState;
|
|
this.currentOrLastRecordingId = function () { return currentOrLastRecordingId; };
|
|
|
|
this.getCurrentRecordingState = getCurrentRecordingState;
|
|
|
|
context.JK.HandleRecordingStartResult = handleRecordingStartResult;
|
|
context.JK.HandleRecordingStopResult = handleRecordingStopResult;
|
|
context.JK.HandleRecordingStopped = handleRecordingStopped;
|
|
context.JK.HandleRecordingStarted = handleRecordingStarted;
|
|
context.JK.HandleRecordingAborted = handleRecordingAborted;
|
|
|
|
|
|
};
|
|
|
|
})(window,jQuery); |