jiti-meet/react/features/base/conference/actions.js

743 lines
21 KiB
JavaScript

// @flow
import type { Dispatch } from 'redux';
import {
createStartMutedConfigurationEvent,
sendAnalytics
} from '../../analytics';
import { getName } from '../../app/functions';
import { endpointMessageReceived } from '../../subtitles';
import { JITSI_CONNECTION_CONFERENCE_KEY } from '../connection';
import { JitsiConferenceEvents } from '../lib-jitsi-meet';
import { setAudioMuted, setVideoMuted } from '../media';
import {
dominantSpeakerChanged,
getLocalParticipant,
getNormalizedDisplayName,
participantConnectionStatusChanged,
participantKicked,
participantMutedUs,
participantPresenceChanged,
participantRoleChanged,
participantUpdated
} from '../participants';
import { getLocalTracks, trackAdded, trackRemoved } from '../tracks';
import {
getBackendSafePath,
getBackendSafeRoomName,
getJitsiMeetGlobalNS
} from '../util';
import {
AUTH_STATUS_CHANGED,
CONFERENCE_FAILED,
CONFERENCE_JOINED,
CONFERENCE_LEFT,
CONFERENCE_SUBJECT_CHANGED,
CONFERENCE_TIMESTAMP_CHANGED,
CONFERENCE_WILL_JOIN,
CONFERENCE_WILL_LEAVE,
DATA_CHANNEL_OPENED,
KICKED_OUT,
LOCK_STATE_CHANGED,
P2P_STATUS_CHANGED,
SEND_TONES,
SET_DESKTOP_SHARING_ENABLED,
SET_FOLLOW_ME,
SET_PASSWORD,
SET_PASSWORD_FAILED,
SET_ROOM,
SET_PENDING_SUBJECT_CHANGE,
SET_START_MUTED_POLICY
} from './actionTypes';
import {
AVATAR_ID_COMMAND,
AVATAR_URL_COMMAND,
EMAIL_COMMAND,
JITSI_CONFERENCE_URL_KEY
} from './constants';
import {
_addLocalTracksToConference,
commonUserJoinedHandling,
commonUserLeftHandling,
getCurrentConference,
sendLocalParticipant
} from './functions';
import logger from './logger';
declare var APP: Object;
/**
* Adds conference (event) listeners.
*
* @param {JitsiConference} conference - The JitsiConference instance.
* @param {Dispatch} dispatch - The Redux dispatch function.
* @private
* @returns {void}
*/
function _addConferenceListeners(conference, dispatch) {
// A simple logger for conference errors received through
// the listener. These errors are not handled now, but logged.
conference.on(JitsiConferenceEvents.CONFERENCE_ERROR,
error => logger.error('Conference error.', error));
// Dispatches into features/base/conference follow:
conference.on(
JitsiConferenceEvents.CONFERENCE_FAILED,
(...args) => dispatch(conferenceFailed(conference, ...args)));
conference.on(
JitsiConferenceEvents.CONFERENCE_JOINED,
(...args) => dispatch(conferenceJoined(conference, ...args)));
conference.on(
JitsiConferenceEvents.CONFERENCE_LEFT,
(...args) => {
dispatch(conferenceTimestampChanged(0));
dispatch(conferenceLeft(conference, ...args));
});
conference.on(JitsiConferenceEvents.SUBJECT_CHANGED,
(...args) => dispatch(conferenceSubjectChanged(...args)));
conference.on(JitsiConferenceEvents.CONFERENCE_CREATED_TIMESTAMP,
(...args) => dispatch(conferenceTimestampChanged(...args)));
conference.on(
JitsiConferenceEvents.KICKED,
(...args) => dispatch(kickedOut(conference, ...args)));
conference.on(
JitsiConferenceEvents.PARTICIPANT_KICKED,
(kicker, kicked) => dispatch(participantKicked(kicker, kicked)));
conference.on(
JitsiConferenceEvents.LOCK_STATE_CHANGED,
(...args) => dispatch(lockStateChanged(conference, ...args)));
// Dispatches into features/base/media follow:
conference.on(
JitsiConferenceEvents.STARTED_MUTED,
() => {
const audioMuted = Boolean(conference.startAudioMuted);
const videoMuted = Boolean(conference.startVideoMuted);
sendAnalytics(createStartMutedConfigurationEvent(
'remote', audioMuted, videoMuted));
logger.log(`Start muted: ${audioMuted ? 'audio, ' : ''}${
videoMuted ? 'video' : ''}`);
// XXX Jicofo tells lib-jitsi-meet to start with audio and/or video
// muted i.e. Jicofo expresses an intent. Lib-jitsi-meet has turned
// Jicofo's intent into reality by actually muting the respective
// tracks. The reality is expressed in base/tracks already so what
// is left is to express Jicofo's intent in base/media.
// TODO Maybe the app needs to learn about Jicofo's intent and
// transfer that intent to lib-jitsi-meet instead of lib-jitsi-meet
// acting on Jicofo's intent without the app's knowledge.
dispatch(setAudioMuted(audioMuted));
dispatch(setVideoMuted(videoMuted));
});
// Dispatches into features/base/tracks follow:
conference.on(
JitsiConferenceEvents.TRACK_ADDED,
t => t && !t.isLocal() && dispatch(trackAdded(t)));
conference.on(
JitsiConferenceEvents.TRACK_REMOVED,
t => t && !t.isLocal() && dispatch(trackRemoved(t)));
conference.on(
JitsiConferenceEvents.TRACK_MUTE_CHANGED,
(_, participantThatMutedUs) => {
if (participantThatMutedUs) {
dispatch(participantMutedUs(participantThatMutedUs));
}
});
// Dispatches into features/base/participants follow:
conference.on(
JitsiConferenceEvents.DISPLAY_NAME_CHANGED,
(id, displayName) => dispatch(participantUpdated({
conference,
id,
name: getNormalizedDisplayName(displayName)
})));
conference.on(
JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
id => dispatch(dominantSpeakerChanged(id, conference)));
conference.on(
JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED,
(...args) => dispatch(endpointMessageReceived(...args)));
conference.on(
JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
(...args) => dispatch(participantConnectionStatusChanged(...args)));
conference.on(
JitsiConferenceEvents.USER_JOINED,
(id, user) => commonUserJoinedHandling({ dispatch }, conference, user));
conference.on(
JitsiConferenceEvents.USER_LEFT,
(id, user) => commonUserLeftHandling({ dispatch }, conference, user));
conference.on(
JitsiConferenceEvents.USER_ROLE_CHANGED,
(...args) => dispatch(participantRoleChanged(...args)));
conference.on(
JitsiConferenceEvents.USER_STATUS_CHANGED,
(...args) => dispatch(participantPresenceChanged(...args)));
conference.on(
JitsiConferenceEvents.BOT_TYPE_CHANGED,
(id, botType) => dispatch(participantUpdated({
conference,
id,
botType
})));
conference.addCommandListener(
AVATAR_ID_COMMAND,
(data, id) => dispatch(participantUpdated({
conference,
id,
avatarID: data.value
})));
conference.addCommandListener(
AVATAR_URL_COMMAND,
(data, id) => dispatch(participantUpdated({
conference,
id,
avatarURL: data.value
})));
conference.addCommandListener(
EMAIL_COMMAND,
(data, id) => dispatch(participantUpdated({
conference,
id,
email: data.value
})));
}
/**
* Updates the current known state of server-side authentication.
*
* @param {boolean} authEnabled - Whether or not server authentication is
* enabled.
* @param {string} authLogin - The current name of the logged in user, if any.
* @returns {{
* type: AUTH_STATUS_CHANGED,
* authEnabled: boolean,
* authLogin: string
* }}
*/
export function authStatusChanged(authEnabled: boolean, authLogin: string) {
return {
type: AUTH_STATUS_CHANGED,
authEnabled,
authLogin
};
}
/**
* Signals that a specific conference has failed.
*
* @param {JitsiConference} conference - The JitsiConference that has failed.
* @param {string} error - The error describing/detailing the cause of the
* failure.
* @param {any} params - Rest of the params that we receive together with the event.
* @returns {{
* type: CONFERENCE_FAILED,
* conference: JitsiConference,
* error: Error
* }}
* @public
*/
export function conferenceFailed(conference: Object, error: string, ...params: any) {
return {
type: CONFERENCE_FAILED,
conference,
// Make the error resemble an Error instance (to the extent that
// jitsi-meet needs it).
error: {
name: error,
params,
recoverable: undefined
}
};
}
/**
* Signals that a specific conference has been joined.
*
* @param {JitsiConference} conference - The JitsiConference instance which was
* joined by the local participant.
* @returns {{
* type: CONFERENCE_JOINED,
* conference: JitsiConference
* }}
*/
export function conferenceJoined(conference: Object) {
return {
type: CONFERENCE_JOINED,
conference
};
}
/**
* Signals that a specific conference has been left.
*
* @param {JitsiConference} conference - The JitsiConference instance which was
* left by the local participant.
* @returns {{
* type: CONFERENCE_LEFT,
* conference: JitsiConference
* }}
*/
export function conferenceLeft(conference: Object) {
return {
type: CONFERENCE_LEFT,
conference
};
}
/**
* Signals that the conference subject has been changed.
*
* @param {string} subject - The new subject.
* @returns {{
* type: CONFERENCE_SUBJECT_CHANGED,
* subject: string
* }}
*/
export function conferenceSubjectChanged(subject: string) {
return {
type: CONFERENCE_SUBJECT_CHANGED,
subject
};
}
/**
* Signals that the conference timestamp has been changed.
*
* @param {number} conferenceTimestamp - The UTC timestamp.
* @returns {{
* type: CONFERENCE_TIMESTAMP_CHANGED,
* conferenceTimestamp
* }}
*/
export function conferenceTimestampChanged(conferenceTimestamp: number) {
return {
type: CONFERENCE_TIMESTAMP_CHANGED,
conferenceTimestamp
};
}
/**
* Adds any existing local tracks to a specific conference before the conference
* is joined. Then signals the intention of the application to have the local
* participant join the specified conference.
*
* @param {JitsiConference} conference - The {@code JitsiConference} instance
* the local participant will (try to) join.
* @returns {Function}
*/
function _conferenceWillJoin(conference: Object) {
return (dispatch: Dispatch<any>, getState: Function) => {
const localTracks
= getLocalTracks(getState()['features/base/tracks'])
.map(t => t.jitsiTrack);
if (localTracks.length) {
_addLocalTracksToConference(conference, localTracks);
}
dispatch(conferenceWillJoin(conference));
};
}
/**
* Signals the intention of the application to have the local participant
* join the specified conference.
*
* @param {JitsiConference} conference - The {@code JitsiConference} instance
* the local participant will (try to) join.
* @returns {{
* type: CONFERENCE_WILL_JOIN,
* conference: JitsiConference
* }}
*/
export function conferenceWillJoin(conference: Object) {
return {
type: CONFERENCE_WILL_JOIN,
conference
};
}
/**
* Signals the intention of the application to have the local participant leave
* a specific conference. Similar in fashion to CONFERENCE_LEFT. Contrary to it
* though, it's not guaranteed because CONFERENCE_LEFT may be triggered by
* lib-jitsi-meet and not the application.
*
* @param {JitsiConference} conference - The JitsiConference instance which will
* be left by the local participant.
* @returns {{
* type: CONFERENCE_LEFT,
* conference: JitsiConference
* }}
*/
export function conferenceWillLeave(conference: Object) {
return {
type: CONFERENCE_WILL_LEAVE,
conference
};
}
/**
* Initializes a new conference.
*
* @returns {Function}
*/
export function createConference() {
return (dispatch: Function, getState: Function) => {
const state = getState();
const { connection, locationURL } = state['features/base/connection'];
if (!connection) {
throw new Error('Cannot create a conference without a connection!');
}
const { password, room } = state['features/base/conference'];
if (!room) {
throw new Error('Cannot join a conference without a room name!');
}
const config = state['features/base/config'];
const { tenant } = state['features/base/jwt'];
const { email, name: nick } = getLocalParticipant(state);
const conference
= connection.initJitsiConference(
getBackendSafeRoomName(room), {
...config,
applicationName: getName(),
getWiFiStatsMethod: getJitsiMeetGlobalNS().getWiFiStats,
confID: `${locationURL.host}${getBackendSafePath(locationURL.pathname)}`,
siteID: tenant,
statisticsDisplayName: config.enableDisplayNameInStats ? nick : undefined,
statisticsId: config.enableEmailInStats ? email : undefined
});
connection[JITSI_CONNECTION_CONFERENCE_KEY] = conference;
conference[JITSI_CONFERENCE_URL_KEY] = locationURL;
dispatch(_conferenceWillJoin(conference));
_addConferenceListeners(conference, dispatch);
sendLocalParticipant(state, conference);
conference.join(password);
};
}
/**
* Will try to join the conference again in case it failed earlier with
* {@link JitsiConferenceErrors.AUTHENTICATION_REQUIRED}. It means that Jicofo
* did not allow to create new room from anonymous domain, but it can be tried
* again later in case authenticated user created it in the meantime.
*
* @returns {Function}
*/
export function checkIfCanJoin() {
return (dispatch: Function, getState: Function) => {
const { authRequired, password }
= getState()['features/base/conference'];
authRequired && dispatch(_conferenceWillJoin(authRequired));
authRequired && authRequired.join(password);
};
}
/**
* Signals the data channel with the bridge has successfully opened.
*
* @returns {{
* type: DATA_CHANNEL_OPENED
* }}
*/
export function dataChannelOpened() {
return {
type: DATA_CHANNEL_OPENED
};
}
/**
* Signals that we've been kicked out of the conference.
*
* @param {JitsiConference} conference - The {@link JitsiConference} instance
* for which the event is being signaled.
* @param {JitsiParticipant} participant - The {@link JitsiParticipant}
* instance which initiated the kick event.
* @returns {{
* type: KICKED_OUT,
* conference: JitsiConference,
* participant: JitsiParticipant
* }}
*/
export function kickedOut(conference: Object, participant: Object) {
return {
type: KICKED_OUT,
conference,
participant
};
}
/**
* Signals that the lock state of a specific JitsiConference changed.
*
* @param {JitsiConference} conference - The JitsiConference which had its lock
* state changed.
* @param {boolean} locked - If the specified conference became locked, true;
* otherwise, false.
* @returns {{
* type: LOCK_STATE_CHANGED,
* conference: JitsiConference,
* locked: boolean
* }}
*/
export function lockStateChanged(conference: Object, locked: boolean) {
return {
type: LOCK_STATE_CHANGED,
conference,
locked
};
}
/**
* Updates the known state of start muted policies.
*
* @param {boolean} audioMuted - Whether or not members will join the conference
* as audio muted.
* @param {boolean} videoMuted - Whether or not members will join the conference
* as video muted.
* @returns {{
* type: SET_START_MUTED_POLICY,
* startAudioMutedPolicy: boolean,
* startVideoMutedPolicy: boolean
* }}
*/
export function onStartMutedPolicyChanged(
audioMuted: boolean, videoMuted: boolean) {
return {
type: SET_START_MUTED_POLICY,
startAudioMutedPolicy: audioMuted,
startVideoMutedPolicy: videoMuted
};
}
/**
* Sets whether or not peer2peer is currently enabled.
*
* @param {boolean} p2p - Whether or not peer2peer is currently active.
* @returns {{
* type: P2P_STATUS_CHANGED,
* p2p: boolean
* }}
*/
export function p2pStatusChanged(p2p: boolean) {
return {
type: P2P_STATUS_CHANGED,
p2p
};
}
/**
* Signals to play touch tones.
*
* @param {string} tones - The tones to play.
* @param {number} [duration] - How long to play each tone.
* @param {number} [pause] - How long to pause between each tone.
* @returns {{
* type: SEND_TONES,
* tones: string,
* duration: number,
* pause: number
* }}
*/
export function sendTones(tones: string, duration: number, pause: number) {
return {
type: SEND_TONES,
tones,
duration,
pause
};
}
/**
* Sets the flag for indicating if desktop sharing is enabled.
*
* @param {boolean} desktopSharingEnabled - True if desktop sharing is enabled.
* @returns {{
* type: SET_DESKTOP_SHARING_ENABLED,
* desktopSharingEnabled: boolean
* }}
*/
export function setDesktopSharingEnabled(desktopSharingEnabled: boolean) {
return {
type: SET_DESKTOP_SHARING_ENABLED,
desktopSharingEnabled
};
}
/**
* Enables or disables the Follow Me feature.
*
* @param {boolean} enabled - Whether or not Follow Me should be enabled.
* @returns {{
* type: SET_FOLLOW_ME,
* enabled: boolean
* }}
*/
export function setFollowMe(enabled: boolean) {
return {
type: SET_FOLLOW_ME,
enabled
};
}
/**
* Sets the password to join or lock a specific JitsiConference.
*
* @param {JitsiConference} conference - The JitsiConference which requires a
* password to join or is to be locked with the specified password.
* @param {Function} method - The JitsiConference method of password protection
* such as join or lock.
* @param {string} password - The password with which the specified conference
* is to be joined or locked.
* @returns {Function}
*/
export function setPassword(
conference: Object,
method: Function,
password: string) {
return (dispatch: Dispatch<any>, getState: Function): ?Promise<void> => {
switch (method) {
case conference.join: {
let state = getState()['features/base/conference'];
dispatch({
type: SET_PASSWORD,
conference,
method,
password
});
// Join the conference with the newly-set password.
// Make sure that the action did set the password.
state = getState()['features/base/conference'];
if (state.password === password
// Make sure that the application still wants the
// conference joined.
&& !state.conference) {
method.call(conference, password);
}
break;
}
case conference.lock: {
const state = getState()['features/base/conference'];
if (state.conference === conference) {
return (
method.call(conference, password)
.then(() => dispatch({
type: SET_PASSWORD,
conference,
method,
password
}))
.catch(error => dispatch({
type: SET_PASSWORD_FAILED,
error
}))
);
}
return Promise.reject();
}
}
};
}
/**
* Sets (the name of) the room of the conference to be joined.
*
* @param {(string|undefined)} room - The name of the room of the conference to
* be joined.
* @returns {{
* type: SET_ROOM,
* room: string
* }}
*/
export function setRoom(room: ?string) {
return {
type: SET_ROOM,
room
};
}
/**
* Sets whether or not members should join audio and/or video muted.
*
* @param {boolean} startAudioMuted - Whether or not members will join the
* conference as audio muted.
* @param {boolean} startVideoMuted - Whether or not members will join the
* conference as video muted.
* @returns {Function}
*/
export function setStartMutedPolicy(
startAudioMuted: boolean, startVideoMuted: boolean) {
return (dispatch: Dispatch<any>, getState: Function) => {
const conference = getCurrentConference(getState());
conference && conference.setStartMutedPolicy({
audio: startAudioMuted,
video: startVideoMuted
});
return dispatch(
onStartMutedPolicyChanged(startAudioMuted, startVideoMuted));
};
}
/**
* Changing conference subject.
*
* @param {string} subject - The new subject.
* @returns {void}
*/
export function setSubject(subject: string) {
return (dispatch: Dispatch<any>, getState: Function) => {
const { conference } = getState()['features/base/conference'];
if (conference) {
conference.setSubject(subject || '');
} else {
dispatch({
type: SET_PENDING_SUBJECT_CHANGE,
subject
});
}
};
}