jiti-meet/react/features/lobby/middleware.js

253 lines
8.1 KiB
JavaScript
Raw Normal View History

// @flow
import { batch } from 'react-redux';
import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../base/app';
import {
CONFERENCE_FAILED,
CONFERENCE_JOINED,
conferenceWillJoin
} from '../base/conference';
import { JitsiConferenceErrors, JitsiConferenceEvents } from '../base/lib-jitsi-meet';
2020-07-06 14:54:33 +00:00
import { getFirstLoadableAvatarUrl, getParticipantDisplayName } from '../base/participants';
import { MiddlewareRegistry, StateListenerRegistry } from '../base/redux';
import { playSound, registerSound, unregisterSound } from '../base/sounds';
import { isTestModeEnabled } from '../base/testing';
import {
NOTIFICATION_TIMEOUT_TYPE,
NOTIFICATION_TYPE,
showNotification
} from '../notifications';
import { shouldAutoKnock } from '../prejoin/functions';
import { KNOCKING_PARTICIPANT_ARRIVED_OR_UPDATED } from './actionTypes';
import {
2020-05-20 08:25:31 +00:00
hideLobbyScreen,
knockingParticipantLeft,
openLobbyScreen,
participantIsKnockingOrUpdated,
2020-05-20 08:25:31 +00:00
setLobbyModeEnabled,
startKnocking,
setPasswordJoinFailed
} from './actions';
import { KNOCKING_PARTICIPANT_SOUND_ID } from './constants';
import { KNOCKING_PARTICIPANT_FILE } from './sounds';
declare var APP: Object;
MiddlewareRegistry.register(store => next => action => {
switch (action.type) {
case APP_WILL_MOUNT:
store.dispatch(registerSound(KNOCKING_PARTICIPANT_SOUND_ID, KNOCKING_PARTICIPANT_FILE));
break;
case APP_WILL_UNMOUNT:
store.dispatch(unregisterSound(KNOCKING_PARTICIPANT_SOUND_ID));
break;
case CONFERENCE_FAILED:
return _conferenceFailed(store, next, action);
case CONFERENCE_JOINED:
return _conferenceJoined(store, next, action);
case KNOCKING_PARTICIPANT_ARRIVED_OR_UPDATED: {
// We need the full update result to be in the store already
const result = next(action);
_findLoadableAvatarForKnockingParticipant(store, action.participant);
return result;
}
}
return next(action);
});
/**
* Registers a change handler for state['features/base/conference'].conference to
* set the event listeners needed for the lobby feature to operate.
*/
StateListenerRegistry.register(
state => state['features/base/conference'].conference,
2020-07-06 14:54:33 +00:00
(conference, { dispatch, getState }, previousConference) => {
if (conference && !previousConference) {
conference.on(JitsiConferenceEvents.MEMBERS_ONLY_CHANGED, enabled => {
dispatch(setLobbyModeEnabled(enabled));
});
conference.on(JitsiConferenceEvents.LOBBY_USER_JOINED, (id, name) => {
batch(() => {
dispatch(
participantIsKnockingOrUpdated({
id,
name
})
);
dispatch(playSound(KNOCKING_PARTICIPANT_SOUND_ID));
if (typeof APP !== 'undefined') {
APP.API.notifyKnockingParticipant({
id,
name
});
}
});
});
conference.on(JitsiConferenceEvents.LOBBY_USER_UPDATED, (id, participant) => {
dispatch(
participantIsKnockingOrUpdated({
...participant,
id
})
);
});
conference.on(JitsiConferenceEvents.LOBBY_USER_LEFT, id => {
dispatch(knockingParticipantLeft(id));
});
2020-07-06 14:54:33 +00:00
conference.on(JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED, (origin, sender) =>
_maybeSendLobbyNotification(origin, sender, {
dispatch,
getState
})
);
}
}
);
/**
* Function to handle the conference failed event and navigate the user to the lobby screen
* based on the failure reason.
*
* @param {Object} store - The Redux store.
* @param {Function} next - The Redux next function.
* @param {Object} action - The Redux action.
* @returns {Object}
*/
2020-05-20 08:25:31 +00:00
function _conferenceFailed({ dispatch, getState }, next, action) {
const { error } = action;
2020-05-20 08:25:31 +00:00
const state = getState();
const { membersOnly } = state['features/base/conference'];
const nonFirstFailure = Boolean(membersOnly);
if (error.name === JitsiConferenceErrors.MEMBERS_ONLY_ERROR) {
if (typeof error.recoverable === 'undefined') {
error.recoverable = true;
}
2020-05-20 08:25:31 +00:00
const result = next(action);
dispatch(openLobbyScreen());
2020-05-20 08:25:31 +00:00
if (shouldAutoKnock(state)) {
2020-05-20 08:25:31 +00:00
dispatch(startKnocking());
}
2020-05-20 08:25:31 +00:00
// In case of wrong password we need to be in the right state if in the meantime someone allows us to join
if (nonFirstFailure) {
dispatch(conferenceWillJoin(membersOnly));
}
2020-05-20 08:25:31 +00:00
dispatch(setPasswordJoinFailed(nonFirstFailure));
return result;
}
dispatch(hideLobbyScreen());
if (error.name === JitsiConferenceErrors.CONFERENCE_ACCESS_DENIED) {
dispatch(
showNotification({
appearance: NOTIFICATION_TYPE.ERROR,
hideErrorSupportLink: true,
titleKey: 'lobby.joinRejectedMessage'
}, NOTIFICATION_TIMEOUT_TYPE.LONG)
);
}
return next(action);
}
/**
* Handles cleanup of lobby state when a conference is joined.
*
* @param {Object} store - The Redux store.
* @param {Function} next - The Redux next function.
* @param {Object} action - The Redux action.
* @returns {Object}
*/
function _conferenceJoined({ dispatch }, next, action) {
2020-05-20 08:25:31 +00:00
dispatch(hideLobbyScreen());
return next(action);
}
/**
* Finds the loadable avatar URL and updates the participant accordingly.
*
* @param {Object} store - The Redux store.
* @param {Object} participant - The knocking participant.
* @returns {void}
*/
function _findLoadableAvatarForKnockingParticipant(store, { id }) {
const { dispatch, getState } = store;
const updatedParticipant = getState()['features/lobby'].knockingParticipants.find(p => p.id === id);
2020-05-20 08:25:31 +00:00
const { disableThirdPartyRequests } = getState()['features/base/config'];
2020-05-20 08:25:31 +00:00
if (!disableThirdPartyRequests && updatedParticipant && !updatedParticipant.loadableAvatarUrl) {
2021-12-17 00:16:24 +00:00
getFirstLoadableAvatarUrl(updatedParticipant, store).then(result => {
if (result) {
const { isUsingCORS, src } = result;
dispatch(
participantIsKnockingOrUpdated({
2021-12-17 00:16:24 +00:00
loadableAvatarUrl: src,
id,
isUsingCORS
})
);
}
});
}
}
2020-07-06 14:54:33 +00:00
/**
* Check the endpoint message that arrived through the conference and
* sends a lobby notification, if the message belongs to the feature.
*
* @param {Object} origin - The origin (initiator) of the message.
* @param {Object} message - The actual message.
* @param {Object} store - The Redux store.
* @returns {void}
*/
function _maybeSendLobbyNotification(origin, message, { dispatch, getState }) {
if (!origin?._id || message?.type !== 'lobby-notify') {
return;
}
const notificationProps: any = {
descriptionArguments: {
originParticipantName: getParticipantDisplayName(getState, origin._id),
targetParticipantName: message.name
2020-07-06 14:54:33 +00:00
},
titleKey: 'lobby.notificationTitle'
};
switch (message.event) {
case 'LOBBY-ENABLED':
notificationProps.descriptionKey = `lobby.notificationLobby${message.value ? 'En' : 'Dis'}abled`;
break;
case 'LOBBY-ACCESS-GRANTED':
notificationProps.descriptionKey = 'lobby.notificationLobbyAccessGranted';
break;
case 'LOBBY-ACCESS-DENIED':
notificationProps.descriptionKey = 'lobby.notificationLobbyAccessDenied';
break;
}
dispatch(
showNotification(
notificationProps,
isTestModeEnabled(getState()) ? NOTIFICATION_TIMEOUT_TYPE.STICKY : NOTIFICATION_TIMEOUT_TYPE.MEDIUM
)
);
2020-07-06 14:54:33 +00:00
}