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

592 lines
16 KiB
JavaScript
Raw Normal View History

import { NOTIFICATION_TIMEOUT, showNotification } from '../../notifications';
2020-05-20 10:57:03 +00:00
import { set } from '../redux';
import {
DOMINANT_SPEAKER_CHANGED,
HIDDEN_PARTICIPANT_JOINED,
HIDDEN_PARTICIPANT_LEFT,
GRANT_MODERATOR,
KICK_PARTICIPANT,
LOCAL_PARTICIPANT_RAISE_HAND,
MUTE_REMOTE_PARTICIPANT,
PARTICIPANT_ID_CHANGED,
PARTICIPANT_JOINED,
PARTICIPANT_KICKED,
PARTICIPANT_LEFT,
PARTICIPANT_UPDATED,
2019-06-26 14:08:23 +00:00
PIN_PARTICIPANT,
SET_LOADABLE_AVATAR_URL,
RAISE_HAND_UPDATED
} from './actionTypes';
import {
DISCO_REMOTE_CONTROL_FEATURE
} from './constants';
import {
getLocalParticipant,
getNormalizedDisplayName,
2020-11-14 04:09:25 +00:00
getParticipantDisplayName,
getParticipantById
} from './functions';
2020-11-14 04:09:25 +00:00
import logger from './logger';
/**
* Create an action for when dominant speaker changes.
*
* @param {string} dominantSpeaker - Participant ID of the dominant speaker.
* @param {Array<string>} previousSpeakers - Participant IDs of the previous speakers.
Associate remote participant w/ JitsiConference (_UPDATED) The commit message of "Associate remote participant w/ JitsiConference (_JOINED)" explains the motivation for this commit. Practically, _JOINED and _LEFT combined with "Remove remote participants who are no longer of interest" should alleviate the problem with multiplying remote participants to an acceptable level of annoyance. Technically though, a remote participant cannot be identified by an ID only. The ID is (somewhat) "unique" in the context of a single JitsiConference instance. So in order to not have to scratch our heads over an obscure corner, racing case, it's better to always identify remote participants by the pair id-conference. Unfortunately, that's a bit of a high order given the existing source code. So I've implemented the cases which are the easiest so that new source code written with participantUpdated is more likely to identify a remote participant with the pair id-conference. Additionally, the commit "Reduce direct read access to the features/base/participants redux state" brings more control back to the functions of the feature base/participants so that one day we can (if we choose to) do something like, for example: If getParticipants is called with a conference, it returns the participants from features/base/participants who are associated with the specified conference. If no conference is specified in the function call, then default to the conference which is the primary focus of the app at the time of the function call. Added to the above, this should allow us to further reduce the cases in which we're identifying remote participants by id only and get us even closer to a more "predictable" behavior in corner, racing cases.
2018-05-22 21:47:43 +00:00
* @param {JitsiConference} conference - The {@code JitsiConference} associated
* with the participant identified by the specified {@code id}. Only the local
* participant is allowed to not specify an associated {@code JitsiConference}
* instance.
* @returns {{
2017-03-07 16:50:17 +00:00
* type: DOMINANT_SPEAKER_CHANGED,
* participant: {
Associate remote participant w/ JitsiConference (_UPDATED) The commit message of "Associate remote participant w/ JitsiConference (_JOINED)" explains the motivation for this commit. Practically, _JOINED and _LEFT combined with "Remove remote participants who are no longer of interest" should alleviate the problem with multiplying remote participants to an acceptable level of annoyance. Technically though, a remote participant cannot be identified by an ID only. The ID is (somewhat) "unique" in the context of a single JitsiConference instance. So in order to not have to scratch our heads over an obscure corner, racing case, it's better to always identify remote participants by the pair id-conference. Unfortunately, that's a bit of a high order given the existing source code. So I've implemented the cases which are the easiest so that new source code written with participantUpdated is more likely to identify a remote participant with the pair id-conference. Additionally, the commit "Reduce direct read access to the features/base/participants redux state" brings more control back to the functions of the feature base/participants so that one day we can (if we choose to) do something like, for example: If getParticipants is called with a conference, it returns the participants from features/base/participants who are associated with the specified conference. If no conference is specified in the function call, then default to the conference which is the primary focus of the app at the time of the function call. Added to the above, this should allow us to further reduce the cases in which we're identifying remote participants by id only and get us even closer to a more "predictable" behavior in corner, racing cases.
2018-05-22 21:47:43 +00:00
* conference: JitsiConference,
* id: string,
* previousSpeakers: Array<string>
2017-03-07 16:50:17 +00:00
* }
* }}
*/
export function dominantSpeakerChanged(dominantSpeaker, previousSpeakers, conference) {
return {
type: DOMINANT_SPEAKER_CHANGED,
participant: {
Associate remote participant w/ JitsiConference (_UPDATED) The commit message of "Associate remote participant w/ JitsiConference (_JOINED)" explains the motivation for this commit. Practically, _JOINED and _LEFT combined with "Remove remote participants who are no longer of interest" should alleviate the problem with multiplying remote participants to an acceptable level of annoyance. Technically though, a remote participant cannot be identified by an ID only. The ID is (somewhat) "unique" in the context of a single JitsiConference instance. So in order to not have to scratch our heads over an obscure corner, racing case, it's better to always identify remote participants by the pair id-conference. Unfortunately, that's a bit of a high order given the existing source code. So I've implemented the cases which are the easiest so that new source code written with participantUpdated is more likely to identify a remote participant with the pair id-conference. Additionally, the commit "Reduce direct read access to the features/base/participants redux state" brings more control back to the functions of the feature base/participants so that one day we can (if we choose to) do something like, for example: If getParticipants is called with a conference, it returns the participants from features/base/participants who are associated with the specified conference. If no conference is specified in the function call, then default to the conference which is the primary focus of the app at the time of the function call. Added to the above, this should allow us to further reduce the cases in which we're identifying remote participants by id only and get us even closer to a more "predictable" behavior in corner, racing cases.
2018-05-22 21:47:43 +00:00
conference,
id: dominantSpeaker,
previousSpeakers
}
};
}
/**
* Create an action for granting moderator to a participant.
*
* @param {string} id - Participant's ID.
* @returns {{
* type: GRANT_MODERATOR,
* id: string
* }}
*/
export function grantModerator(id) {
return {
type: GRANT_MODERATOR,
id
};
}
2017-10-09 15:03:02 +00:00
/**
* Create an action for removing a participant from the conference.
*
* @param {string} id - Participant's ID.
* @returns {{
* type: KICK_PARTICIPANT,
* id: string
* }}
*/
export function kickParticipant(id) {
return {
type: KICK_PARTICIPANT,
id
};
}
/**
* Creates an action to signal the connection status of the local participant
* has changed.
*
* @param {string} connectionStatus - The current connection status of the local
* participant, as enumerated by the library's participantConnectionStatus
* constants.
* @returns {Function}
*/
export function localParticipantConnectionStatusChanged(connectionStatus) {
return (dispatch, getState) => {
const participant = getLocalParticipant(getState);
if (participant) {
return dispatch(participantConnectionStatusChanged(
2017-10-09 15:03:02 +00:00
participant.id,
connectionStatus));
}
};
}
/**
* Action to signal that the ID of local participant has changed. It happens
* when the local participant joins a new conference or leaves an existing
* conference.
*
* @param {string} id - New ID for local participant.
* @returns {Function}
*/
export function localParticipantIdChanged(id) {
return (dispatch, getState) => {
const participant = getLocalParticipant(getState);
if (participant) {
return dispatch({
type: PARTICIPANT_ID_CHANGED,
// XXX A participant is identified by an id-conference pair.
// Only the local participant is with an undefined conference.
conference: undefined,
newValue: id,
oldValue: participant.id
});
}
};
}
/**
* Action to signal that a local participant has joined.
*
* @param {Participant} participant={} - Information about participant.
* @returns {{
2017-03-07 16:50:17 +00:00
* type: PARTICIPANT_JOINED,
* participant: Participant
* }}
*/
export function localParticipantJoined(participant = {}) {
return participantJoined(set(participant, 'local', true));
}
2017-10-09 15:03:02 +00:00
/**
* Action to remove a local participant.
*
* @returns {Function}
*/
export function localParticipantLeft() {
return (dispatch, getState) => {
const participant = getLocalParticipant(getState);
if (participant) {
return (
dispatch(
participantLeft(
participant.id,
// XXX Only the local participant is allowed to leave
// without stating the JitsiConference instance because
// the local participant is uniquely identified by the
// very fact that there is only one local participant
// (and the fact that the local participant "joins" at
// the beginning of the app and "leaves" at the end of
// the app).
undefined)));
2017-10-09 15:03:02 +00:00
}
};
}
/**
* Action to signal the role of the local participant has changed. It can happen
* when the participant has joined a conference, even before a non-default local
* id has been set, or after a moderator leaves.
*
* @param {string} role - The new role of the local participant.
* @returns {Function}
*/
export function localParticipantRoleChanged(role) {
return (dispatch, getState) => {
const participant = getLocalParticipant(getState);
if (participant) {
return dispatch(participantRoleChanged(participant.id, role));
}
};
}
/**
* Create an action for muting another participant in the conference.
*
* @param {string} id - Participant's ID.
* @param {MEDIA_TYPE} mediaType - The media to mute.
* @returns {{
* type: MUTE_REMOTE_PARTICIPANT,
* id: string,
* mediaType: MEDIA_TYPE
* }}
*/
export function muteRemoteParticipant(id, mediaType) {
return {
type: MUTE_REMOTE_PARTICIPANT,
id,
mediaType
};
}
2017-04-05 09:01:57 +00:00
/**
* Action to update a participant's connection status.
*
* @param {string} id - Participant's ID.
* @param {string} connectionStatus - The new connection status of the
* participant.
* @returns {{
* type: PARTICIPANT_UPDATED,
* participant: {
* connectionStatus: string,
* id: string
* }
* }}
*/
export function participantConnectionStatusChanged(id, connectionStatus) {
return {
type: PARTICIPANT_UPDATED,
participant: {
connectionStatus,
id
}
2017-04-05 09:01:57 +00:00
};
}
/**
* Action to signal that a participant has joined.
*
* @param {Participant} participant - Information about participant.
* @returns {{
* type: PARTICIPANT_JOINED,
* participant: Participant
* }}
*/
export function participantJoined(participant) {
// Only the local participant is not identified with an id-conference pair.
if (participant.local) {
return {
type: PARTICIPANT_JOINED,
participant
};
}
// In other words, a remote participant is identified with an id-conference
// pair.
const { conference } = participant;
if (!conference) {
throw Error(
'A remote participant must be associated with a JitsiConference!');
}
return (dispatch, getState) => {
// A remote participant is only expected to join in a joined or joining
// conference. The following check is really necessary because a
// JitsiConference may have moved into leaving but may still manage to
// sneak a PARTICIPANT_JOINED in if its leave is delayed for any purpose
// (which is not outragous given that leaving involves network
// requests.)
const stateFeaturesBaseConference
= getState()['features/base/conference'];
if (conference === stateFeaturesBaseConference.conference
|| conference === stateFeaturesBaseConference.joining) {
return dispatch({
type: PARTICIPANT_JOINED,
participant
});
}
};
}
2020-11-14 04:09:25 +00:00
/**
* Updates the features of a remote participant.
*
* @param {JitsiParticipant} jitsiParticipant - The ID of the participant.
* @returns {{
* type: PARTICIPANT_UPDATED,
* participant: Participant
* }}
*/
export function updateRemoteParticipantFeatures(jitsiParticipant) {
return (dispatch, getState) => {
if (!jitsiParticipant) {
return;
}
const id = jitsiParticipant.getId();
jitsiParticipant.getFeatures()
.then(features => {
const supportsRemoteControl = features.has(DISCO_REMOTE_CONTROL_FEATURE);
const participant = getParticipantById(getState(), id);
if (!participant || participant.local) {
return;
}
if (participant?.supportsRemoteControl !== supportsRemoteControl) {
return dispatch({
type: PARTICIPANT_UPDATED,
participant: {
id,
supportsRemoteControl
}
});
}
})
.catch(error => {
logger.error(`Failed to get participant features for ${id}!`, error);
});
};
}
/**
* Action to signal that a hidden participant has joined the conference.
*
* @param {string} id - The id of the participant.
* @param {string} displayName - The display name, or undefined when
* unknown.
* @returns {{
* type: HIDDEN_PARTICIPANT_JOINED,
* displayName: string,
* id: string
* }}
*/
export function hiddenParticipantJoined(id, displayName) {
return {
type: HIDDEN_PARTICIPANT_JOINED,
id,
displayName
};
}
/**
* Action to signal that a hidden participant has left the conference.
*
* @param {string} id - The id of the participant.
* @returns {{
* type: HIDDEN_PARTICIPANT_LEFT,
* id: string
* }}
*/
export function hiddenParticipantLeft(id) {
return {
type: HIDDEN_PARTICIPANT_LEFT,
id
};
}
/**
2017-03-07 16:50:17 +00:00
* Action to signal that a participant has left.
*
2017-03-07 16:50:17 +00:00
* @param {string} id - Participant's ID.
* @param {JitsiConference} conference - The {@code JitsiConference} associated
* with the participant identified by the specified {@code id}. Only the local
* participant is allowed to not specify an associated {@code JitsiConference}
* instance.
* @param {boolean} isReplaced - Whether the participant is to be replaced in the meeting.
* @returns {{
2017-03-07 16:50:17 +00:00
* type: PARTICIPANT_LEFT,
* participant: {
* conference: JitsiConference,
2017-03-07 16:50:17 +00:00
* id: string
* }
* }}
*/
export function participantLeft(id, conference, isReplaced) {
return {
type: PARTICIPANT_LEFT,
participant: {
conference,
id,
isReplaced
}
};
}
/**
* Action to signal that a participant's presence status has changed.
*
* @param {string} id - Participant's ID.
* @param {string} presence - Participant's new presence status.
* @returns {{
* type: PARTICIPANT_UPDATED,
* participant: {
* id: string,
* presence: string
* }
* }}
*/
export function participantPresenceChanged(id, presence) {
return participantUpdated({
id,
presence
});
}
/**
2017-03-07 16:50:17 +00:00
* Action to signal that a participant's role has changed.
*
2017-03-07 16:50:17 +00:00
* @param {string} id - Participant's ID.
* @param {PARTICIPANT_ROLE} role - Participant's new role.
* @returns {{
2017-03-07 16:50:17 +00:00
* type: PARTICIPANT_UPDATED,
* participant: {
* id: string,
* role: PARTICIPANT_ROLE
* }
* }}
*/
export function participantRoleChanged(id, role) {
return participantUpdated({
id,
role
});
}
/**
* Action to signal that some of participant properties has been changed.
*
* @param {Participant} participant={} - Information about participant. To
* identify the participant the object should contain either property id with
* value the id of the participant or property local with value true (if the
* local participant hasn't joined the conference yet).
* @returns {{
* type: PARTICIPANT_UPDATED,
* participant: Participant
* }}
*/
export function participantUpdated(participant = {}) {
2019-01-15 11:28:07 +00:00
const participantToUpdate = {
...participant
};
2019-01-13 19:33:28 +00:00
if (participant.name) {
2019-01-15 11:28:07 +00:00
participantToUpdate.name = getNormalizedDisplayName(participant.name);
2019-01-13 19:33:28 +00:00
}
return {
type: PARTICIPANT_UPDATED,
2019-01-15 11:28:07 +00:00
participant: participantToUpdate
};
}
/**
* Action to signal that a participant has muted us.
*
* @param {JitsiParticipant} participant - Information about participant.
* @param {JitsiLocalTrack} track - Information about the track that has been muted.
* @returns {Promise}
*/
export function participantMutedUs(participant, track) {
return (dispatch, getState) => {
if (!participant) {
return;
}
const isAudio = track.isAudioTrack();
dispatch(showNotification({
titleKey: isAudio ? 'notify.mutedRemotelyTitle' : 'notify.videoMutedRemotelyTitle',
titleArguments: {
moderator: getParticipantDisplayName(getState, participant.getId())
}
}));
};
}
/**
* Action to signal that a participant had been kicked.
*
* @param {JitsiParticipant} kicker - Information about participant performing the kick.
* @param {JitsiParticipant} kicked - Information about participant that was kicked.
* @returns {Promise}
*/
export function participantKicked(kicker, kicked) {
return (dispatch, getState) => {
dispatch({
type: PARTICIPANT_KICKED,
kicked: kicked.getId(),
kicker: kicker?.getId()
});
if (kicked.isReplaced && kicked.isReplaced()) {
return;
}
dispatch(showNotification({
titleArguments: {
kicked:
getParticipantDisplayName(getState, kicked.getId()),
kicker:
getParticipantDisplayName(getState, kicker.getId())
},
titleKey: 'notify.kickParticipant'
}, NOTIFICATION_TIMEOUT * 2)); // leave more time for this
};
}
/**
* Create an action which pins a conference participant.
*
* @param {string|null} id - The ID of the conference participant to pin or null
* if none of the conference's participants are to be pinned.
* @returns {{
2017-03-07 16:50:17 +00:00
* type: PIN_PARTICIPANT,
* participant: {
* id: string
* }
* }}
*/
export function pinParticipant(id) {
return {
type: PIN_PARTICIPANT,
participant: {
id
}
};
}
2019-06-26 14:08:23 +00:00
/**
* Creates an action which notifies the app that the loadable URL of the avatar of a participant got updated.
*
* @param {string} participantId - The ID of the participant.
* @param {string} url - The new URL.
* @returns {{
* type: SET_LOADABLE_AVATAR_URL,
* participant: {
* id: string,
* loadableAvatarUrl: string
* }
* }}
*/
export function setLoadableAvatarUrl(participantId, url) {
return {
type: SET_LOADABLE_AVATAR_URL,
participant: {
id: participantId,
loadableAvatarUrl: url
}
};
}
2020-11-14 04:09:25 +00:00
/**
* Raise hand for the local participant.
*
* @param {boolean} enabled - Raise or lower hand.
* @returns {{
* type: LOCAL_PARTICIPANT_RAISE_HAND,
* enabled: boolean
* }}
*/
export function raiseHand(enabled) {
return {
type: LOCAL_PARTICIPANT_RAISE_HAND,
enabled
};
}
/**
* Update raise hand queue of participants.
*
* @param {Object} participant - Participant that updated raised hand.
* @returns {{
* type: RAISE_HAND_UPDATED,
* participant: Object
* }}
*/
export function raiseHandUpdateQueue(participant) {
return {
type: RAISE_HAND_UPDATED,
participant
};
}