in react/features/mobile/external-api/middleware.js [151:415]
url: _normalizeUrl(locationURL)
});
}
break;
}
case ENTER_PICTURE_IN_PICTURE:
sendEvent(store, type, /* data */ {});
break;
case OPEN_CHAT:
case CLOSE_CHAT: {
sendEvent(
store,
CHAT_TOGGLED,
/* data */ {
isOpen: action.type === OPEN_CHAT
});
break;
}
case PARTICIPANT_JOINED:
case PARTICIPANT_LEFT: {
// Skip these events while not in a conference. SDK users can still retrieve them.
const { conference } = store.getState()['features/base/conference'];
if (!conference) {
break;
}
const { participant } = action;
sendEvent(
store,
action.type,
_participantToParticipantInfo(participant) /* data */
);
break;
}
case READY_TO_CLOSE:
sendEvent(store, type, /* data */ {});
break;
case SET_ROOM:
_maybeTriggerEarlyConferenceWillJoin(store, action);
break;
case SET_AUDIO_MUTED:
if (action.muted !== oldAudioMuted) {
sendEvent(
store,
'AUDIO_MUTED_CHANGED',
/* data */ {
muted: action.muted
});
}
break;
case SET_PAGE_RELOAD_OVERLAY_CANCELED:
sendEvent(
store,
CONFERENCE_TERMINATED,
/* data */ {
error: _toErrorString(action.error),
url: _normalizeUrl(store.getState()['features/base/connection'].locationURL)
});
break;
case SET_VIDEO_MUTED:
sendEvent(
store,
'VIDEO_MUTED_CHANGED',
/* data */ {
muted: action.muted
});
break;
}
return result;
});
/**
* Listen for changes to the known media tracks and look
* for updates to screen shares for emitting native events.
* The listener is debounced to avoid state thrashing that might occur,
* especially when switching in or out of p2p.
*/
StateListenerRegistry.register(
/* selector */ state => state['features/base/tracks'],
/* listener */ debounce((tracks, store) => {
const oldScreenShares = store.getState()['features/mobile/external-api'].screenShares || [];
const newScreenShares = tracks
.filter(track => track.mediaType === 'video' && track.videoType === 'desktop')
.map(track => track.participantId);
oldScreenShares.forEach(participantId => {
if (!newScreenShares.includes(participantId)) {
sendEvent(
store,
SCREEN_SHARE_TOGGLED,
/* data */ {
participantId,
sharing: false
});
}
});
newScreenShares.forEach(participantId => {
if (!oldScreenShares.includes(participantId)) {
sendEvent(
store,
SCREEN_SHARE_TOGGLED,
/* data */ {
participantId,
sharing: true
});
}
});
store.dispatch(setParticipantsWithScreenShare(newScreenShares));
}, 100));
/**
* Returns a participant info object based on the passed participant object from redux.
*
* @param {Participant} participant - The participant object from the redux store.
* @returns {Object} - The participant info object.
*/
function _participantToParticipantInfo(participant) {
return {
isLocal: participant.local,
email: participant.email,
name: participant.name,
participantId: participant.id,
displayName: participant.displayName,
avatarUrl: participant.avatarURL,
role: participant.role
};
}
/**
* Registers for events sent from the native side via NativeEventEmitter.
*
* @param {Store} store - The redux store.
* @private
* @returns {void}
*/
function _registerForNativeEvents(store) {
const { getState, dispatch } = store;
eventEmitter.addListener(ExternalAPI.HANG_UP, () => {
dispatch(appNavigate(undefined));
});
eventEmitter.addListener(ExternalAPI.SET_AUDIO_MUTED, ({ muted }) => {
dispatch(muteLocal(muted, MEDIA_TYPE.AUDIO));
});
eventEmitter.addListener(ExternalAPI.SET_VIDEO_MUTED, ({ muted }) => {
dispatch(muteLocal(muted, MEDIA_TYPE.VIDEO));
});
eventEmitter.addListener(ExternalAPI.SEND_ENDPOINT_TEXT_MESSAGE, ({ to, message }) => {
const conference = getCurrentConference(getState());
try {
conference && conference.sendEndpointMessage(to, {
name: ENDPOINT_TEXT_MESSAGE_NAME,
text: message
});
} catch (error) {
logger.warn('Cannot send endpointMessage', error);
}
});
eventEmitter.addListener(ExternalAPI.TOGGLE_SCREEN_SHARE, ({ enabled }) => {
dispatch(toggleScreensharing(enabled));
});
eventEmitter.addListener(ExternalAPI.RETRIEVE_PARTICIPANTS_INFO, ({ requestId }) => {
const participantsInfo = [];
const remoteParticipants = getRemoteParticipants(store);
const localParticipant = getLocalParticipant(store);
participantsInfo.push(_participantToParticipantInfo(localParticipant));
remoteParticipants.forEach(participant => {
if (!participant.isFakeParticipant) {
participantsInfo.push(_participantToParticipantInfo(participant));
}
});
sendEvent(
store,
PARTICIPANTS_INFO_RETRIEVED,
/* data */ {
participantsInfo,
requestId
});
});
eventEmitter.addListener(ExternalAPI.OPEN_CHAT, ({ to }) => {
const participant = getParticipantById(store, to);
dispatch(openChat(participant));
});
eventEmitter.addListener(ExternalAPI.CLOSE_CHAT, () => {
dispatch(closeChat());
});
eventEmitter.addListener(ExternalAPI.SEND_CHAT_MESSAGE, ({ message, to }) => {
const participant = getParticipantById(store, to);
if (participant) {
dispatch(setPrivateMessageRecipient(participant));
}
dispatch(sendMessage(message));
});
}
/**
* Unregister for events sent from the native side via NativeEventEmitter.
*
* @private
* @returns {void}
*/
function _unregisterForNativeEvents() {
eventEmitter.removeAllListeners(ExternalAPI.HANG_UP);
eventEmitter.removeAllListeners(ExternalAPI.SET_AUDIO_MUTED);
eventEmitter.removeAllListeners(ExternalAPI.SET_VIDEO_MUTED);
eventEmitter.removeAllListeners(ExternalAPI.SEND_ENDPOINT_TEXT_MESSAGE);
eventEmitter.removeAllListeners(ExternalAPI.TOGGLE_SCREEN_SHARE);
eventEmitter.removeAllListeners(ExternalAPI.RETRIEVE_PARTICIPANTS_INFO);
eventEmitter.removeAllListeners(ExternalAPI.OPEN_CHAT);
eventEmitter.removeAllListeners(ExternalAPI.CLOSE_CHAT);
eventEmitter.removeAllListeners(ExternalAPI.SEND_CHAT_MESSAGE);
}
/**
* Registers for endpoint messages sent on conference data channel.
*
* @param {Store} store - The redux store.
* @private
* @returns {void}
*/
function _registerForEndpointTextMessages(store) {
const conference = getCurrentConference(store.getState());
conference && conference.on(
JitsiConferenceEvents.ENDPOINT_MESSAGE_RECEIVED,
(...args) => {
if (args && args.length >= 2) {
const [ sender, eventData ] = args;
if (eventData.name === ENDPOINT_TEXT_MESSAGE_NAME) {
sendEvent(
store,
ENDPOINT_TEXT_MESSAGE_RECEIVED,
/* data */ {