Skip to content

Jitsi Meet - Secure, Simple and Scalable Video Conferences that you use as a standalone app or embed in your web application.

18.5 KB
Raw Blame
import { Alert, NativeModules, Platform } from 'react-native';
import { AnyAction } from 'redux';
import { v4 as uuidv4 } from 'uuid';

import { createTrackMutedEvent } from '../../analytics/AnalyticsEvents';
import { sendAnalytics } from '../../analytics/functions';
import { appNavigate } from '../../app/actions.native';
import { IReduxState, IStore } from '../../app/types';
import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../../base/app/actionTypes';
import {
    CONFERENCE_CONNECTION_ESTABLISHED,
    CONFERENCE_FAILED,
    CONFERENCE_JOIN_IN_PROGRESS,
    CONFERENCE_LEFT,
    CONFERENCE_WILL_LEAVE
} from '../../base/conference/actionTypes';
import {
    getConferenceName,
    getCurrentConference
} from '../../base/conference/functions';
import { IJitsiConference } from '../../base/conference/reducer';
import { getInviteURL } from '../../base/connection/functions';
import { SET_LOW_BANDWIDTH_MODE } from '../../base/low-bandwidth-mode/actionTypes';
import { setAudioMuted } from '../../base/media/actions';
import { MEDIA_TYPE } from '../../base/media/constants';
import { isVideoMutedByLowBandwidthMode } from '../../base/media/functions';
import MiddlewareRegistry from '../../base/redux/MiddlewareRegistry';
import {
    TRACK_ADDED,
    TRACK_REMOVED,
    TRACK_UPDATED
} from '../../base/tracks/actionTypes';
import { isLocalTrackMuted } from '../../base/tracks/functions.native';

import CallKit from './CallKit';
import ConnectionService from './ConnectionService';
import { _SET_CALL_INTEGRATION_SUBSCRIPTIONS } from './actionTypes';
import { isCallIntegrationEnabled } from './functions';

const { AudioMode } = NativeModules;
const CallIntegration = CallKit || ConnectionService;

/**
 * Middleware that captures system actions and hooks up CallKit.
 *
 * @param {Store} store - The redux store.
 * @returns {Function}
 */
CallIntegration && MiddlewareRegistry.register(store => next => action => {
    switch (action.type) {
    case _SET_CALL_INTEGRATION_SUBSCRIPTIONS:
        return _setCallKitSubscriptions(store, next, action);

    case APP_WILL_MOUNT:
        return _appWillMount(store, next, action);

    case APP_WILL_UNMOUNT:
        store.dispatch({
            type: _SET_CALL_INTEGRATION_SUBSCRIPTIONS,
            subscriptions: undefined
        });
        break;

    case CONFERENCE_FAILED:
        return _conferenceFailed(store, next, action);

    // If a conference is being left in a graceful manner then
    // the CONFERENCE_WILL_LEAVE fires as soon as the conference starts
    // disconnecting. We need to destroy the call on the native side as soon
    // as possible, because the disconnection process is asynchronous and
    // Android not always supports two simultaneous calls at the same time
    // (even though it should according to the spec).
    case CONFERENCE_LEFT:
    case CONFERENCE_WILL_LEAVE:
        return _conferenceLeft(store, next, action);

    case CONFERENCE_JOIN_IN_PROGRESS:
        return _conferenceWillJoin(store, next, action);

    case CONFERENCE_CONNECTION_ESTABLISHED:
        return _conferenceConnectionEstablished(store, next, action);

    case SET_LOW_BANDWIDTH_MODE:
        return _setLowBandwidthMode(store, next, action);

    case TRACK_ADDED:
    case TRACK_REMOVED:
    case TRACK_UPDATED:
        return _syncTrackState(store, next, action);
    }

    return next(action);
});

/**
 * Notifies the feature callkit that the action {@link APP_WILL_MOUNT} is being
 * dispatched within a specific redux {@code store}.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action {@code APP_WILL_MOUNT} which is
 * being dispatched in the specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _appWillMount({ dispatch, getState }: IStore, next: Function, action: AnyAction) {
    const result = next(action);

    const context = {
        dispatch,
        getState
    };

    const delegate = {
        _onPerformSetMutedCallAction,
        _onPerformEndCallAction
    };

    if (isCallIntegrationEnabled(getState)) {
        const subscriptions = CallIntegration.registerSubscriptions(context, delegate);

        subscriptions && dispatch({
            type: _SET_CALL_INTEGRATION_SUBSCRIPTIONS,
            subscriptions
        });
    }

    return result;
}

/**
 * Notifies the feature callkit that the action {@link CONFERENCE_FAILED} is
 * being dispatched within a specific redux {@code store}.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action {@code CONFERENCE_FAILED} which is
 * being dispatched in the specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _conferenceFailed({ getState }: IStore, next: Function, action: AnyAction) {
    const result = next(action);

    if (!isCallIntegrationEnabled(getState)) {
        return result;
    }

    // XXX Certain CONFERENCE_FAILED errors are recoverable i.e. they have
    // prevented the user from joining a specific conference but the app may be
    // able to eventually join the conference.
    if (!action.error.recoverable) {
        const { callUUID } = action.conference;

        if (callUUID) {
            delete action.conference.callUUID;

            CallIntegration.reportCallFailed(callUUID);
        }
    }

    return result;
}

/**
 * Notifies the feature callkit that the action {@link CONFERENCE_CONNECTION_ESTABLISHED}
 * is being dispatched. Reports the outgoing call connected when its ICE connection (media)
 * is up, so CallKit gets a real connecting->connected transition.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action {@code CONFERENCE_CONNECTION_ESTABLISHED}
 * which is being dispatched in the specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _conferenceConnectionEstablished({ getState }: IStore, next: Function, action: AnyAction) {
    // Report connected once; this action also fires on CONNECTION_RESTORED mid-call.
    const wasConnected = getState()['features/base/conference'].iceConnected;
    const result = next(action);

    if (!isCallIntegrationEnabled(getState) || wasConnected) {
        return result;
    }

    const { conference } = action;
    const { callUUID } = conference;

    if (callUUID) {
        CallIntegration.reportConnectedOutgoingCall(callUUID)
            .then(() => {
                // iOS 13 doesn't like the mute state to be false before the call is started
                // so we update it here in case the user selected startWithAudioMuted.
                if (Platform.OS === 'ios') {
                    _updateCallIntegrationMuted(conference, getState());
                }
            })
            .catch(() => {
                // Currently errors here are only emitted by Android.
                //
                // Some Samsung devices will fail to fully engage ConnectionService if no SIM card
                // was ever installed on the device. We could check for it, but it would require
                // the CALL_PHONE permission, which is not something we want to do, so fallback to
                // not using ConnectionService.
                _handleConnectionServiceFailure(getState());
            });
    }

    return result;
}

/**
 * Notifies the feature callkit that the action {@link CONFERENCE_LEFT} is being
 * dispatched within a specific redux {@code store}. No-ops when call integration
 * is disabled or when the action carries no {@code conference} (as dispatched by
 * the generic {@code hangup()}, in which case there is no callUUID to report).
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action {@code CONFERENCE_LEFT} which is
 * being dispatched in the specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _conferenceLeft({ getState }: IStore, next: Function, action: AnyAction) {
    const result = next(action);

    if (!isCallIntegrationEnabled(getState)) {
        return result;
    }

    const { callUUID } = action.conference;

    if (callUUID) {
        delete action.conference.callUUID;

        CallIntegration.endCall(callUUID);
    }

    return result;
}

/**
 * Notifies the feature callkit that the action {@link CONFERENCE_JOIN_IN_PROGRESS}
 * is being dispatched. Starts the outgoing call (reports connecting); connected is
 * reported later on {@link CONFERENCE_CONNECTION_ESTABLISHED}.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action {@code CONFERENCE_JOIN_IN_PROGRESS}
 * which is being dispatched in the specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _conferenceWillJoin({ dispatch, getState }: IStore, next: Function, action: AnyAction) {
    const result = next(action);

    if (!isCallIntegrationEnabled(getState)) {
        return result;
    }

    const { conference } = action;
    const state = getState();
    const { callHandle, callUUID } = state['features/base/config'];
    const url = getInviteURL(state);
    const handle = callHandle || url.toString();
    const hasVideo = !isVideoMutedByLowBandwidthMode(state);

    // If we already have a callUUID set, don't start a new call.
    if (conference.callUUID) {
        return result;
    }

    // When assigning the callUUID, do so in upper case, since iOS will return
    // it upper-cased.
    conference.callUUID = (callUUID || uuidv4()).toUpperCase();

    CallIntegration.startCall(conference.callUUID, handle, hasVideo)
        .then(() => {
            const displayName = getConferenceName(state);

            CallIntegration.updateCall(
                conference.callUUID,
                {
                    displayName,
                    hasVideo
                });

            // iOS 13 doesn't like the mute state to be false before the call is started
            // so delay it until the conference was joined.
            if (Platform.OS !== 'ios') {
                _updateCallIntegrationMuted(conference, state);
            }
        })
        .catch((error: any) => {
            // Currently this error codes are emitted only by Android.
            //
            if (error.code === 'CREATE_OUTGOING_CALL_FAILED') {
                // We're not tracking the call anymore - it doesn't exist on
                // the native side.
                delete conference.callUUID;

                dispatch(appNavigate(undefined));
                Alert.alert(
                    'Call aborted',
                    'There\'s already another call in progress.'
                        + ' Please end it first and try again.',
                    [
                        { text: 'OK' }
                    ],
                    { cancelable: false });
            } else {
                // Some devices fail because the CALL_PHONE permission is not granted, which is
                // nonsense, because it's not needed for self-managed connections.
                // Some other devices fail because ConnectionService is not supported.
                // Be that as it may, fallback to non-ConnectionService audio device handling.

                _handleConnectionServiceFailure(state);
            }
        });

    return result;
}

/**
 * Handles a ConnectionService fatal error by falling back to non-ConnectionService device management.
 *
 * @param {Object} state - Redux store.
 * @returns {void}
 */
function _handleConnectionServiceFailure(state: IReduxState) {
    const conference = getCurrentConference(state);

    if (conference) {
        // We're not tracking the call anymore.
        delete conference.callUUID;

        // ConnectionService has fatally failed. Alas, this also means audio device management would be broken, so
        // fallback to not using ConnectionService.
        // NOTE: We are not storing this in Settings, in case it's a transient issue, as far fetched as
        // that may be.
        if (AudioMode.setUseConnectionService) {
            AudioMode.setUseConnectionService(false);

            // Set the desired audio mode, since we just reset the whole thing.
            AudioMode.setMode(AudioMode.IN_CALL);
        }
    }
}

/**
 * Handles CallKit's event {@code performEndCallAction}.
 *
 * @param {Object} event - The details of the CallKit event
 * {@code performEndCallAction}.
 * @returns {void}
 */
function _onPerformEndCallAction({ callUUID }: { callUUID: string; }) {
    // @ts-ignore
    const { dispatch, getState } = this; // eslint-disable-line @typescript-eslint/no-invalid-this
    const conference = getCurrentConference(getState);

    if (conference?.callUUID === callUUID) {
        // We arrive here when a call is ended by the system, for example, when
        // another incoming call is received and the user selects "End &
        // Accept".
        delete conference.callUUID;

        dispatch(appNavigate(undefined));
    }
}

/**
 * Handles CallKit's event {@code performSetMutedCallAction}.
 *
 * @param {Object} event - The details of the CallKit event
 * {@code performSetMutedCallAction}.
 * @returns {void}
 */
function _onPerformSetMutedCallAction({ callUUID, muted }: { callUUID: string; muted: boolean; }) {
    // @ts-ignore
    const { dispatch, getState } = this; // eslint-disable-line @typescript-eslint/no-invalid-this
    const conference = getCurrentConference(getState);

    if (conference?.callUUID === callUUID) {
        muted = Boolean(muted); // eslint-disable-line no-param-reassign

        sendAnalytics(
            createTrackMutedEvent('audio', 'call-integration', muted));

        dispatch(setAudioMuted(muted, /* ensureTrack */ true));
    }
}

/**
 * Update CallKit with the low bandwidth mode state of the conference. When a
 * conference is in low bandwidth mode we will tell CallKit the call has no
 * video. This affects how the call is saved in the recent calls list.
 *
 * XXX: Note that here we are taking the `lowBandwidthMode` value straight from
 * the action, instead of examining the state. This is intentional, as setting
 * the low bandwidth mode involves multiple actions which will be reflected in
 * the state later, but we are just interested in knowing if the mode is going
 * to be set or not.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action which is being dispatched in the
 * specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _setLowBandwidthMode({ getState }: IStore, next: Function, action: AnyAction) {
    const result = next(action);
    const state = getState();

    if (!isCallIntegrationEnabled(state)) {
        return result;
    }

    const conference = getCurrentConference(state);

    if (conference?.callUUID) {
        CallIntegration.updateCall(
            conference.callUUID,
            { hasVideo: !action.lowBandwidthMode });
    }

    return result;
}

/**
 * Notifies the feature callkit that the action
 * {@link _SET_CALL_INTEGRATION_SUBSCRIPTIONS} is being dispatched within
 * a specific redux {@code store}.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action
 * {@code _SET_CALL_INTEGRATION_SUBSCRIPTIONS} which is being dispatched in
 * the specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _setCallKitSubscriptions({ getState }: IStore, next: Function, action: AnyAction) {
    const { subscriptions } = getState()['features/call-integration'];

    if (subscriptions) {
        for (const subscription of subscriptions) {
            subscription.remove();
        }
    }

    return next(action);
}

/**
 * Synchronize the muted state of tracks with CallKit.
 *
 * @param {Store} store - The redux store in which the specified {@code action}
 * is being dispatched.
 * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the
 * specified {@code action} in the specified {@code store}.
 * @param {Action} action - The redux action which is being dispatched in the
 * specified {@code store}.
 * @private
 * @returns {*} The value returned by {@code next(action)}.
 */
function _syncTrackState({ getState }: IStore, next: Function, action: AnyAction) {
    const result = next(action);

    if (!isCallIntegrationEnabled(getState)) {
        return result;
    }

    const { jitsiTrack } = action.track;
    const state = getState();
    const conference = getCurrentConference(state);

    if (jitsiTrack.isLocal() && conference?.callUUID) {
        switch (jitsiTrack.getType()) {
        case 'audio': {
            _updateCallIntegrationMuted(conference, state);
            break;
        }
        case 'video': {
            CallIntegration.updateCall(
                conference.callUUID,
                { hasVideo: !isVideoMutedByLowBandwidthMode(state) });
            break;
        }

        }
    }

    return result;
}

/**
 * Update the muted state in the native side.
 *
 * @param {Object} conference - The current active conference.
 * @param {Object} state - The redux store state.
 * @private
 * @returns {void}
 */
function _updateCallIntegrationMuted(conference: IJitsiConference, state: IReduxState) {
    const muted = isLocalTrackMuted(state['features/base/tracks'], MEDIA_TYPE.AUDIO);

    CallIntegration.setMuted(conference.callUUID, muted);
}