134 lines
3.9 KiB
JavaScript
134 lines
3.9 KiB
JavaScript
import { _handleParticipantError } from '../base/conference';
|
|
import {
|
|
MEDIA_TYPE,
|
|
VIDEO_TYPE
|
|
} from '../base/media';
|
|
import {
|
|
getLocalVideoTrack,
|
|
getTrackByMediaTypeAndParticipant
|
|
} from '../base/tracks';
|
|
|
|
import { LARGE_VIDEO_PARTICIPANT_CHANGED } from './actionTypes';
|
|
import './middleware';
|
|
import './reducer';
|
|
|
|
/**
|
|
* Signals conference to select a participant.
|
|
*
|
|
* @returns {Function}
|
|
*/
|
|
export function selectParticipant() {
|
|
return (dispatch, getState) => {
|
|
const state = getState();
|
|
const conference = state['features/base/conference'].jitsiConference;
|
|
|
|
if (conference) {
|
|
const largeVideo = state['features/largeVideo'];
|
|
const tracks = state['features/base/tracks'];
|
|
|
|
const videoTrack = getTrackByMediaTypeAndParticipant(
|
|
tracks, MEDIA_TYPE.VIDEO, largeVideo.participantId);
|
|
|
|
try {
|
|
conference.selectParticipant(
|
|
videoTrack && videoTrack.videoType === VIDEO_TYPE.CAMERA
|
|
? largeVideo.participantId
|
|
: null);
|
|
} catch (err) {
|
|
_handleParticipantError(err);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Action to select the participant to be displayed in LargeVideo based on a
|
|
* variety of factors: if there is a dominant or pinned speaker, or if there are
|
|
* remote tracks etc.
|
|
*
|
|
* @returns {Function}
|
|
*/
|
|
export function selectParticipantInLargeVideo() {
|
|
return (dispatch, getState) => {
|
|
const state = getState();
|
|
const participants = state['features/base/participants'];
|
|
const tracks = state['features/base/tracks'];
|
|
const largeVideo = state['features/largeVideo'];
|
|
const participantId
|
|
= _electParticipantInLargeVideo(participants, tracks);
|
|
|
|
if (participantId !== largeVideo.participantId) {
|
|
dispatch({
|
|
type: LARGE_VIDEO_PARTICIPANT_CHANGED,
|
|
participantId
|
|
});
|
|
|
|
dispatch(selectParticipant());
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Returns the most recent existing video track. It can be local or remote
|
|
* video.
|
|
*
|
|
* @param {Track[]} tracks - All current tracks.
|
|
* @private
|
|
* @returns {(Track|undefined)}
|
|
*/
|
|
function _electLastVisibleVideo(tracks) {
|
|
let videoTrack;
|
|
|
|
// First we try to get most recent remote video track.
|
|
for (let i = tracks.length - 1; i >= 0; i--) {
|
|
if (tracks[i].mediaType === MEDIA_TYPE.VIDEO && !tracks[i].local) {
|
|
videoTrack = tracks[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// And if no remote video tracks are available, we select the local one.
|
|
if (!videoTrack) {
|
|
videoTrack = getLocalVideoTrack(tracks);
|
|
}
|
|
|
|
return videoTrack;
|
|
}
|
|
|
|
/**
|
|
* Returns the participant ID who is to be on the stage i.e. should be displayed
|
|
* in LargeVideo.
|
|
*
|
|
* @param {Participant[]} participants - All participants.
|
|
* @param {Track[]} tracks - All tracks.
|
|
* @private
|
|
* @returns {(string|undefined)}
|
|
*/
|
|
function _electParticipantInLargeVideo(participants, tracks) {
|
|
// First get the pinned participant. If local participant is pinned, he will
|
|
// be shown in LargeVideo.
|
|
let participant = participants.find(p => p.pinned);
|
|
let id = participant ? participant.id : undefined;
|
|
|
|
// If no participant is pinned, get the dominant speaker. But local
|
|
// participant won't be displayed in LargeVideo even if he is the dominant
|
|
// speaker.
|
|
if (!id) {
|
|
participant = participants.find(p => p.speaking && !p.local);
|
|
if (participant) {
|
|
id = participant.id;
|
|
}
|
|
}
|
|
|
|
// If no participant is pinned and no dominant speaker, just get the
|
|
// participant with last visible video track. This may turn out to be local
|
|
// participant.
|
|
if (!id) {
|
|
const videoTrack = _electLastVisibleVideo(tracks);
|
|
|
|
id = videoTrack && videoTrack.participantId;
|
|
}
|
|
|
|
return id;
|
|
}
|