From 6f3625f99cc516bf3039e44c20d42f4f734bb9bf Mon Sep 17 00:00:00 2001 From: Audric Ackermann Date: Fri, 19 Nov 2021 10:49:05 +1100 Subject: [PATCH] move the state of calling to its own slice --- .../conversation/ConversationHeader.tsx | 3 +- ts/components/session/SessionInboxView.tsx | 2 + ts/components/session/calling/CallButtons.tsx | 4 +- .../calling/CallInFullScreenContainer.tsx | 4 +- .../calling/DraggableCallContainer.tsx | 7 +- .../calling/InConversationCallContainer.tsx | 2 +- .../session/calling/IncomingCallDialog.tsx | 2 +- ts/components/session/menu/Menu.tsx | 7 +- ts/hooks/useVideoEventListener.ts | 7 +- ts/interactions/conversationInteractions.ts | 2 - ts/models/conversation.ts | 9 - ts/receiver/cache.ts | 4 +- ts/receiver/callMessage.ts | 4 +- ts/receiver/contentMessage.ts | 2 +- ts/receiver/receiver.ts | 2 +- ts/session/sending/MessageSender.ts | 7 +- ts/session/utils/CallManager.ts | 232 ++++++++++-------- ts/state/ducks/call.tsx | 111 +++++++++ ts/state/ducks/conversations.ts | 108 -------- ts/state/reducer.ts | 3 + ts/state/selectors/call.ts | 103 ++++++++ ts/state/selectors/conversations.ts | 93 ------- ts/state/smart/SessionConversation.ts | 2 +- 23 files changed, 378 insertions(+), 342 deletions(-) create mode 100644 ts/state/ducks/call.tsx create mode 100644 ts/state/selectors/call.ts diff --git a/ts/components/conversation/ConversationHeader.tsx b/ts/components/conversation/ConversationHeader.tsx index 697b2fead..122faeeeb 100644 --- a/ts/components/conversation/ConversationHeader.tsx +++ b/ts/components/conversation/ConversationHeader.tsx @@ -14,8 +14,6 @@ import { getConversationHeaderProps, getConversationHeaderTitleProps, getCurrentNotificationSettingText, - getHasIncomingCall, - getHasOngoingCall, getIsSelectedNoteToSelf, getIsSelectedPrivate, getSelectedConversation, @@ -40,6 +38,7 @@ import { resetSelectedMessageIds, } from '../../state/ducks/conversations'; import { callRecipient } from '../../interactions/conversationInteractions'; +import { getHasIncomingCall, getHasOngoingCall } from '../../state/selectors/call'; export interface TimerOption { name: string; diff --git a/ts/components/session/SessionInboxView.tsx b/ts/components/session/SessionInboxView.tsx index fdb34b04d..57fb092c9 100644 --- a/ts/components/session/SessionInboxView.tsx +++ b/ts/components/session/SessionInboxView.tsx @@ -26,6 +26,7 @@ import { PersistGate } from 'redux-persist/integration/react'; import { persistStore } from 'redux-persist'; import { TimerOptionsArray } from '../../state/ducks/timerOptions'; import { getEmptyStagedAttachmentsState } from '../../state/ducks/stagedAttachments'; +import { initialCallState } from '../../state/ducks/call'; // Workaround: A react component's required properties are filtering up through connect() // https://github.com/DefinitelyTyped/DefinitelyTyped/issues/31363 @@ -105,6 +106,7 @@ export class SessionInboxView extends React.Component { timerOptions, }, stagedAttachments: getEmptyStagedAttachmentsState(), + call: initialCallState, }; this.store = createStore(initialState); diff --git a/ts/components/session/calling/CallButtons.tsx b/ts/components/session/calling/CallButtons.tsx index 0469ee810..bfb2b583b 100644 --- a/ts/components/session/calling/CallButtons.tsx +++ b/ts/components/session/calling/CallButtons.tsx @@ -1,11 +1,11 @@ import { SessionIconButton } from '../icon'; import { animation, contextMenu, Item, Menu } from 'react-contexify'; import { InputItem } from '../../../session/utils/CallManager'; -import { setFullScreenCall } from '../../../state/ducks/conversations'; +import { setFullScreenCall } from '../../../state/ducks/call'; import { CallManager, ToastUtils } from '../../../session/utils'; import React from 'react'; import { useDispatch, useSelector } from 'react-redux'; -import { getHasOngoingCallWithPubkey } from '../../../state/selectors/conversations'; +import { getHasOngoingCallWithPubkey } from '../../../state/selectors/call'; import { DropDownAndToggleButton } from '../icon/DropDownAndToggleButton'; import styled from 'styled-components'; diff --git a/ts/components/session/calling/CallInFullScreenContainer.tsx b/ts/components/session/calling/CallInFullScreenContainer.tsx index 55d03fea6..15aa0f76a 100644 --- a/ts/components/session/calling/CallInFullScreenContainer.tsx +++ b/ts/components/session/calling/CallInFullScreenContainer.tsx @@ -4,11 +4,11 @@ import { useDispatch, useSelector } from 'react-redux'; import useKey from 'react-use/lib/useKey'; import styled from 'styled-components'; import { useVideoCallEventsListener } from '../../../hooks/useVideoEventListener'; -import { setFullScreenCall } from '../../../state/ducks/conversations'; +import { setFullScreenCall } from '../../../state/ducks/call'; import { getCallIsInFullScreen, getHasOngoingCallWithFocusedConvo, -} from '../../../state/selectors/conversations'; +} from '../../../state/selectors/call'; import { CallWindowControls } from './CallButtons'; import { StyledVideoElement } from './DraggableCallContainer'; diff --git a/ts/components/session/calling/DraggableCallContainer.tsx b/ts/components/session/calling/DraggableCallContainer.tsx index 1b543c5f4..7455da648 100644 --- a/ts/components/session/calling/DraggableCallContainer.tsx +++ b/ts/components/session/calling/DraggableCallContainer.tsx @@ -4,11 +4,8 @@ import Draggable, { DraggableData, DraggableEvent } from 'react-draggable'; import styled from 'styled-components'; import _ from 'underscore'; -import { - getHasOngoingCall, - getHasOngoingCallWith, - getSelectedConversationKey, -} from '../../../state/selectors/conversations'; +import { getSelectedConversationKey } from '../../../state/selectors/conversations'; +import { getHasOngoingCall, getHasOngoingCallWith } from '../../../state/selectors/call'; import { openConversationWithMessages } from '../../../state/ducks/conversations'; import { Avatar, AvatarSize } from '../../Avatar'; import { useVideoCallEventsListener } from '../../../hooks/useVideoEventListener'; diff --git a/ts/components/session/calling/InConversationCallContainer.tsx b/ts/components/session/calling/InConversationCallContainer.tsx index 2a2dc4686..d8c748ed0 100644 --- a/ts/components/session/calling/InConversationCallContainer.tsx +++ b/ts/components/session/calling/InConversationCallContainer.tsx @@ -10,7 +10,7 @@ import { getHasOngoingCallWithFocusedConvoIsOffering, getHasOngoingCallWithFocusedConvosIsConnecting, getHasOngoingCallWithPubkey, -} from '../../../state/selectors/conversations'; +} from '../../../state/selectors/call'; import { StyledVideoElement } from './DraggableCallContainer'; import { Avatar, AvatarSize } from '../../Avatar'; diff --git a/ts/components/session/calling/IncomingCallDialog.tsx b/ts/components/session/calling/IncomingCallDialog.tsx index 5e7db9e6f..d022e2c26 100644 --- a/ts/components/session/calling/IncomingCallDialog.tsx +++ b/ts/components/session/calling/IncomingCallDialog.tsx @@ -6,7 +6,7 @@ import _ from 'underscore'; import { useAvatarPath, useConversationUsername } from '../../../hooks/useParamSelector'; import { ed25519Str } from '../../../session/onions/onionPath'; import { CallManager } from '../../../session/utils'; -import { getHasIncomingCall, getHasIncomingCallFrom } from '../../../state/selectors/conversations'; +import { getHasIncomingCall, getHasIncomingCallFrom } from '../../../state/selectors/call'; import { Avatar, AvatarSize } from '../../Avatar'; import { SessionButton, SessionButtonColor } from '../SessionButton'; import { SessionWrapperModal } from '../SessionWrapperModal'; diff --git a/ts/components/session/menu/Menu.tsx b/ts/components/session/menu/Menu.tsx index 5195b77cf..f325086d9 100644 --- a/ts/components/session/menu/Menu.tsx +++ b/ts/components/session/menu/Menu.tsx @@ -1,10 +1,7 @@ import React from 'react'; -import { - getHasIncomingCall, - getHasOngoingCall, - getNumberOfPinnedConversations, -} from '../../../state/selectors/conversations'; +import { getHasIncomingCall, getHasOngoingCall } from '../../../state/selectors/call'; +import { getNumberOfPinnedConversations } from '../../../state/selectors/conversations'; import { getFocusedSection } from '../../../state/selectors/section'; import { Item, Submenu } from 'react-contexify'; import { diff --git a/ts/hooks/useVideoEventListener.ts b/ts/hooks/useVideoEventListener.ts index 203614a8e..401420cde 100644 --- a/ts/hooks/useVideoEventListener.ts +++ b/ts/hooks/useVideoEventListener.ts @@ -8,11 +8,8 @@ import { DEVICE_DISABLED_DEVICE_ID, InputItem, } from '../session/utils/CallManager'; -import { - getCallIsInFullScreen, - getHasOngoingCallWithPubkey, - getSelectedConversationKey, -} from '../state/selectors/conversations'; +import { getSelectedConversationKey } from '../state/selectors/conversations'; +import { getCallIsInFullScreen, getHasOngoingCallWithPubkey } from '../state/selectors/call'; export function useVideoCallEventsListener(uniqueId: string, onSame: boolean) { const selectedConversationKey = useSelector(getSelectedConversationKey); diff --git a/ts/interactions/conversationInteractions.ts b/ts/interactions/conversationInteractions.ts index 16615e1dd..4851f6dc4 100644 --- a/ts/interactions/conversationInteractions.ts +++ b/ts/interactions/conversationInteractions.ts @@ -447,8 +447,6 @@ export async function callRecipient(pubkey: string, canCall: boolean) { } if (convo && convo.isPrivate() && !convo.isMe()) { - convo.callState = 'offering'; - await convo.commit(); await CallManager.USER_callRecipient(convo.id); } } diff --git a/ts/models/conversation.ts b/ts/models/conversation.ts index 6af47dc74..f70fe9f26 100644 --- a/ts/models/conversation.ts +++ b/ts/models/conversation.ts @@ -176,8 +176,6 @@ export const fillConvoAttributesWithDefaults = ( }); }; -export type CallState = 'offering' | 'incoming' | 'connecting' | 'ongoing' | undefined; - export class ConversationModel extends Backbone.Model { public updateLastMessage: () => any; public throttledBumpTyping: () => void; @@ -185,8 +183,6 @@ export class ConversationModel extends Backbone.Model { public markRead: (newestUnreadDate: number, providedOptions?: any) => Promise; public initialPromise: any; - public callState: CallState; - private typingRefreshTimer?: NodeJS.Timeout | null; private typingPauseTimer?: NodeJS.Timeout | null; private typingTimer?: NodeJS.Timeout | null; @@ -441,7 +437,6 @@ export class ConversationModel extends Backbone.Model { const left = !!this.get('left'); const expireTimer = this.get('expireTimer'); const currentNotificationSetting = this.get('triggerNotificationsFor'); - const callState = this.callState; // to reduce the redux store size, only set fields which cannot be undefined // for instance, a boolean can usually be not set if false, etc @@ -546,10 +541,6 @@ export class ConversationModel extends Backbone.Model { text: lastMessageText, }; } - - if (callState) { - toRet.callState = callState; - } return toRet; } diff --git a/ts/receiver/cache.ts b/ts/receiver/cache.ts index a98a79c5b..d6919273a 100644 --- a/ts/receiver/cache.ts +++ b/ts/receiver/cache.ts @@ -15,7 +15,7 @@ import { export async function removeFromCache(envelope: EnvelopePlus) { const { id } = envelope; - window?.log?.info(`removing from cache envelope: ${id}`); + // window?.log?.info(`removing from cache envelope: ${id}`); return removeUnprocessed(id); } @@ -25,7 +25,7 @@ export async function addToCache( messageHash: string ) { const { id } = envelope; - window?.log?.info(`adding to cache envelope: ${id}`); + // window?.log?.info(`adding to cache envelope: ${id}`); const encodedEnvelope = StringUtils.decode(plaintext, 'base64'); const data: UnprocessedParameter = { diff --git a/ts/receiver/callMessage.ts b/ts/receiver/callMessage.ts index d7ef83232..8b0d4122e 100644 --- a/ts/receiver/callMessage.ts +++ b/ts/receiver/callMessage.ts @@ -30,7 +30,7 @@ export async function handleCallMessage( if (CallManager.isCallRejected(callMessage.uuid)) { await removeFromCache(envelope); - window.log.info(`Dropping already rejected call ${callMessage.uuid}`); + window.log.info(`Dropping already rejected call from this device ${callMessage.uuid}`); return; } @@ -65,7 +65,7 @@ export async function handleCallMessage( if (type === SignalService.CallMessage.Type.END_CALL) { await removeFromCache(envelope); - CallManager.handleCallTypeEndCall(sender, callMessage.uuid); + await CallManager.handleCallTypeEndCall(sender, callMessage.uuid); return; } diff --git a/ts/receiver/contentMessage.ts b/ts/receiver/contentMessage.ts index 7e160ca5e..09d4236fa 100644 --- a/ts/receiver/contentMessage.ts +++ b/ts/receiver/contentMessage.ts @@ -210,7 +210,7 @@ async function decryptUnidentifiedSender( envelope: EnvelopePlus, ciphertext: ArrayBuffer ): Promise { - window?.log?.info('received unidentified sender message'); + // window?.log?.info('received unidentified sender message'); try { const userX25519KeyPair = await UserUtils.getIdentityKeyPair(); diff --git a/ts/receiver/receiver.ts b/ts/receiver/receiver.ts index c3a8c0521..b35827ca5 100644 --- a/ts/receiver/receiver.ts +++ b/ts/receiver/receiver.ts @@ -72,7 +72,7 @@ const envelopeQueue = new EnvelopeQueue(); function queueEnvelope(envelope: EnvelopePlus, messageHash?: string) { const id = getEnvelopeId(envelope); - window?.log?.info('queueing envelope', id); + // window?.log?.info('queueing envelope', id); const task = handleEnvelope.bind(null, envelope, messageHash); const taskWithTimeout = createTaskWithTimeout(task, `queueEnvelope ${id}`); diff --git a/ts/session/sending/MessageSender.ts b/ts/session/sending/MessageSender.ts index dde8630de..4cb519130 100644 --- a/ts/session/sending/MessageSender.ts +++ b/ts/session/sending/MessageSender.ts @@ -20,6 +20,7 @@ import { MessageSender } from '.'; import { getMessageById } from '../../../ts/data/data'; import { SNodeAPI } from '../snode_api'; import { getConversationController } from '../conversations'; +import { ed25519Str } from '../onions/onionPath'; const DEFAULT_CONNECTIONS = 1; @@ -129,7 +130,7 @@ export async function TEST_sendMessageToSnode( const data64 = window.dcodeIO.ByteBuffer.wrap(data).toString('base64'); const swarm = await getSwarmFor(pubKey); - window?.log?.debug('Sending envelope with timestamp: ', timestamp, ' to ', pubKey); + window?.log?.debug('Sending envelope with timestamp: ', timestamp, ' to ', ed25519Str(pubKey)); // send parameters const params = { pubKey, @@ -190,7 +191,9 @@ export async function TEST_sendMessageToSnode( } window?.log?.info( - `loki_message:::sendMessage - Successfully stored message to ${pubKey} via ${snode.ip}:${snode.port}` + `loki_message:::sendMessage - Successfully stored message to ${ed25519Str(pubKey)} via ${ + snode.ip + }:${snode.port}` ); } diff --git a/ts/session/utils/CallManager.ts b/ts/session/utils/CallManager.ts index 6389c7197..3ab4e7866 100644 --- a/ts/session/utils/CallManager.ts +++ b/ts/session/utils/CallManager.ts @@ -2,18 +2,18 @@ import _ from 'lodash'; import { MessageUtils, ToastUtils, UserUtils } from '.'; import { getCallMediaPermissionsSettings } from '../../components/session/settings/SessionSettings'; import { getConversationById } from '../../data/data'; -import { ConversationModel } from '../../models/conversation'; import { MessageModelType } from '../../models/messageType'; import { SignalService } from '../../protobuf'; +import { openConversationWithMessages } from '../../state/ducks/conversations'; import { answerCall, callConnected, + CallStatusEnum, endCall, incomingCall, - openConversationWithMessages, setFullScreenCall, startingCallWith, -} from '../../state/ducks/conversations'; +} from '../../state/ducks/call'; import { getConversationController } from '../conversations'; import { CallMessage } from '../messages/outgoing/controlMessage/CallMessage'; import { ed25519Str } from '../onions/onionPath'; @@ -26,6 +26,9 @@ import { setIsRinging } from './RingingManager'; export type InputItem = { deviceId: string; label: string }; +/** + * This uuid is set only once we accepted a call or started one. + */ let currentCallUUID: string | undefined; const rejectedCallUUIDS: Set = new Set(); @@ -571,17 +574,7 @@ async function closeVideoCall() { currentCallUUID = undefined; window.inboxStore?.dispatch(setFullScreenCall(false)); - const convos = getConversationController().getConversations(); - const callingConvos = convos.filter(convo => convo.callState !== undefined); - if (callingConvos.length > 0) { - // reset all convos callState - await Promise.all( - callingConvos.map(async m => { - m.callState = undefined; - await m.commit(); - }) - ); - } + window.inboxStore?.dispatch(endCall()); remoteVideoStreamIsMuted = true; @@ -592,24 +585,26 @@ async function closeVideoCall() { callVideoListeners(); } +function getCallingStateOutsideOfRedux() { + const ongoingCallWith = window.inboxStore?.getState().call.ongoingWith as string | undefined; + const ongoingCallStatus = window.inboxStore?.getState().call.ongoingCallStatus as CallStatusEnum; + return { ongoingCallWith, ongoingCallStatus }; +} + function onDataChannelReceivedMessage(ev: MessageEvent) { try { const parsed = JSON.parse(ev.data); if (parsed.hangup !== undefined) { - const foundEntry = getConversationController() - .getConversations() - .find( - (convo: ConversationModel) => - convo.callState === 'connecting' || - convo.callState === 'offering' || - convo.callState === 'ongoing' - ); - - if (!foundEntry || !foundEntry.id) { - return; + const { ongoingCallStatus, ongoingCallWith } = getCallingStateOutsideOfRedux(); + if ( + (ongoingCallStatus === 'connecting' || + ongoingCallStatus === 'offering' || + ongoingCallStatus === 'ongoing') && + ongoingCallWith + ) { + void handleCallTypeEndCall(ongoingCallWith, currentCallUUID); } - handleCallTypeEndCall(foundEntry.id, currentCallUUID); return; } @@ -761,8 +756,23 @@ export async function USER_acceptIncomingCallRequest(fromSender: string) { await buildAnswerAndSendIt(fromSender); } +export async function rejectCallAlreadyAnotherCall(fromSender: string, forcedUUID: string) { + setIsRinging(false); + window.log.info(`rejectCallAlreadyAnotherCall ${ed25519Str(fromSender)}: ${forcedUUID}`); + rejectedCallUUIDS.add(forcedUUID); + const rejectCallMessage = new CallMessage({ + type: SignalService.CallMessage.Type.END_CALL, + timestamp: Date.now(), + uuid: forcedUUID, + }); + await sendCallMessageAndSync(rejectCallMessage, fromSender); + + // delete all msg not from that uuid only but from that sender pubkey + clearCallCacheFromPubkeyAndUUID(fromSender, forcedUUID); +} + // tslint:disable-next-line: function-name -export async function USER_rejectIncomingCallRequest(fromSender: string, forcedUUID?: string) { +export async function USER_rejectIncomingCallRequest(fromSender: string) { setIsRinging(false); const lastOfferMessage = findLastMessageTypeFromSender( @@ -770,7 +780,7 @@ export async function USER_rejectIncomingCallRequest(fromSender: string, forcedU SignalService.CallMessage.Type.OFFER ); - const aboutCallUUID = forcedUUID || lastOfferMessage?.uuid; + const aboutCallUUID = lastOfferMessage?.uuid; window.log.info(`USER_rejectIncomingCallRequest ${ed25519Str(fromSender)}: ${aboutCallUUID}`); if (aboutCallUUID) { rejectedCallUUIDS.add(aboutCallUUID); @@ -779,29 +789,25 @@ export async function USER_rejectIncomingCallRequest(fromSender: string, forcedU timestamp: Date.now(), uuid: aboutCallUUID, }); - await getMessageQueue().sendToPubKeyNonDurably(PubKey.cast(fromSender), endCallMessage); - + // sync the reject event so our other devices remove the popup too + await sendCallMessageAndSync(endCallMessage, fromSender); // delete all msg not from that uuid only but from that sender pubkey clearCallCacheFromPubkeyAndUUID(fromSender, aboutCallUUID); } + const { ongoingCallStatus, ongoingCallWith } = getCallingStateOutsideOfRedux(); - // if we got a forceUUID, it means we just to deny another user's device incoming call we are already in a call with. - if (!forcedUUID) { - window.inboxStore?.dispatch( - endCall({ - pubkey: fromSender, - }) - ); - - const convos = getConversationController().getConversations(); - const callingConvos = convos.filter(convo => convo.callState !== undefined); - if (callingConvos.length > 0) { - // we just got a new offer from someone we are already in a call with - if (callingConvos.length === 1 && callingConvos[0].id === fromSender) { - await closeVideoCall(); - } - } + // clear the ongoing call if needed + if (ongoingCallWith && ongoingCallStatus && ongoingCallWith === fromSender) { + await closeVideoCall(); } + + // close the popup call + window.inboxStore?.dispatch(endCall()); +} + +async function sendCallMessageAndSync(callmessage: CallMessage, user: string) { + await getMessageQueue().sendToPubKeyNonDurably(PubKey.cast(user), callmessage); + await getMessageQueue().sendToPubKeyNonDurably(UserUtils.getOurPubKeyFromCache(), callmessage); } // tslint:disable-next-line: function-name @@ -821,7 +827,7 @@ export async function USER_hangup(fromSender: string) { void getMessageQueue().sendToPubKeyNonDurably(PubKey.cast(fromSender), endCallMessage); } - window.inboxStore?.dispatch(endCall({ pubkey: fromSender })); + window.inboxStore?.dispatch(endCall()); window.log.info('sending hangup with an END_CALL MESSAGE'); sendHangupViaDataChannel(); @@ -831,7 +837,10 @@ export async function USER_hangup(fromSender: string) { await closeVideoCall(); } -export function handleCallTypeEndCall(sender: string, aboutCallUUID?: string) { +/** + * This can actually be called from either the datachannel or from the receiver END_CALL event + */ +export async function handleCallTypeEndCall(sender: string, aboutCallUUID?: string) { window.log.info('handling callMessage END_CALL:', aboutCallUUID); if (aboutCallUUID) { @@ -839,10 +848,25 @@ export function handleCallTypeEndCall(sender: string, aboutCallUUID?: string) { clearCallCacheFromPubkeyAndUUID(sender, aboutCallUUID); - if (aboutCallUUID === currentCallUUID) { - void closeVideoCall(); + // this is a end call from ourself. We must remove the popup about the incoming call + // if it matches the owner of this callUUID + if (sender === UserUtils.getOurPubKeyStrFromCache()) { + const { ongoingCallStatus, ongoingCallWith } = getCallingStateOutsideOfRedux(); + const ownerOfCall = getOwnerOfCallUUID(aboutCallUUID); - window.inboxStore?.dispatch(endCall({ pubkey: sender })); + if ( + (ongoingCallStatus === 'incoming' || ongoingCallStatus === 'connecting') && + ongoingCallWith === ownerOfCall + ) { + await closeVideoCall(); + window.inboxStore?.dispatch(endCall()); + } + return; + } + + if (aboutCallUUID === currentCallUUID) { + await closeVideoCall(); + window.inboxStore?.dispatch(endCall()); } } } @@ -871,13 +895,8 @@ async function buildAnswerAndSendIt(sender: string) { uuid: currentCallUUID, }); - window.log.info('sending ANSWER MESSAGE'); - - await getMessageQueue().sendToPubKeyNonDurably(PubKey.cast(sender), callAnswerMessage); - await getMessageQueue().sendToPubKeyNonDurably( - UserUtils.getOurPubKeyFromCache(), - callAnswerMessage - ); + window.log.info('sending ANSWER MESSAGE and sync'); + await sendCallMessageAndSync(callAnswerMessage, sender); } } @@ -905,12 +924,17 @@ export async function handleCallTypeOffer( if (currentCallUUID && currentCallUUID !== remoteCallUUID) { // we just got a new offer with a different callUUID. this is a missed call (from either the same sender or another one) if (callCache.get(sender)?.has(currentCallUUID)) { - // this is a missed call from the same sender (another call from another device maybe?) - // just reject it. - await USER_rejectIncomingCallRequest(sender, remoteCallUUID); + // this is a missed call from the same sender but with a different callID. + // another call from another device maybe? just reject it. + await rejectCallAlreadyAnotherCall(sender, remoteCallUUID); return; } + // add a message in the convo with this user about the missed call. await handleMissedCall(sender, incomingOfferTimestamp, false); + // Here, we are in a call, and we got an offer from someone we are in a call with, and not one of his other devices. + // Just hangup automatically the call on the calling side. + + await rejectCallAlreadyAnotherCall(sender, remoteCallUUID); return; } @@ -994,61 +1018,69 @@ export async function handleMissedCall( return; } +function getOwnerOfCallUUID(callUUID: string) { + for (const deviceKey of callCache.keys()) { + for (const callUUIDEntry of callCache.get(deviceKey) as Map< + string, + Array + >) { + if (callUUIDEntry[0] === callUUID) { + return deviceKey; + } + } + } + return null; +} + export async function handleCallTypeAnswer(sender: string, callMessage: SignalService.CallMessage) { if (!callMessage.sdps || callMessage.sdps.length === 0) { - window.log.warn('cannot handle answered message without signal description protols'); + window.log.warn('cannot handle answered message without signal description proto sdps'); return; } - const remoteCallUUID = callMessage.uuid; - if (!remoteCallUUID || remoteCallUUID.length === 0) { + const callMessageUUID = callMessage.uuid; + if (!callMessageUUID || callMessageUUID.length === 0) { window.log.warn('handleCallTypeAnswer has no valid uuid'); return; } - // this is an answer we sent to ourself, this must be about another of our device accepting an incoming call - // if we accepted that call already from the current device, currentCallUUID is set - if (sender === UserUtils.getOurPubKeyStrFromCache() && remoteCallUUID !== currentCallUUID) { - window.log.info(`handling callMessage ANSWER from ourself about call ${remoteCallUUID}`); + // this is an answer we sent to ourself, this must be about another of our device accepting an incoming call. + // if we accepted that call already from the current device, currentCallUUID would be set + if (sender === UserUtils.getOurPubKeyStrFromCache()) { + // when we answer a call, we get this message on all our devices, including the one we just accepted the call with. - let foundOwnerOfCallUUID: string | undefined; - for (const deviceKey of callCache.keys()) { - if (foundOwnerOfCallUUID) { - break; - } - for (const callUUIDEntry of callCache.get(deviceKey) as Map< - string, - Array - >) { - if (callUUIDEntry[0] === remoteCallUUID) { - foundOwnerOfCallUUID = deviceKey; - break; - } - } + const isDeviceWhichJustAcceptedCall = currentCallUUID === callMessageUUID; + + if (isDeviceWhichJustAcceptedCall) { + window.log.info( + `isDeviceWhichJustAcceptedCall: skipping message back ANSWER from ourself about call ${callMessageUUID}` + ); + + return; } + window.log.info(`handling callMessage ANSWER from ourself about call ${callMessageUUID}`); - if (foundOwnerOfCallUUID) { - rejectedCallUUIDS.add(remoteCallUUID); + const { ongoingCallStatus, ongoingCallWith } = getCallingStateOutsideOfRedux(); + const foundOwnerOfCallUUID = getOwnerOfCallUUID(callMessageUUID); - const convos = getConversationController().getConversations(); - const callingConvos = convos.filter(convo => convo.callState !== undefined); - if (callingConvos.length > 0) { - // we just got a new offer from someone we are already in a call with - if (callingConvos.length === 1 && callingConvos[0].id === foundOwnerOfCallUUID) { + if (callMessageUUID !== currentCallUUID) { + // this is an answer we sent from another of our devices + // automatically close that call + if (foundOwnerOfCallUUID) { + rejectedCallUUIDS.add(callMessageUUID); + // if this call is about the one being currently displayed, force close it + if (ongoingCallStatus && ongoingCallWith === foundOwnerOfCallUUID) { await closeVideoCall(); } + + window.inboxStore?.dispatch(endCall()); } - window.inboxStore?.dispatch( - endCall({ - pubkey: foundOwnerOfCallUUID, - }) - ); - return; } + return; } else { - window.log.info(`handling callMessage ANSWER from ${remoteCallUUID}`); + window.log.info(`handling callMessage ANSWER from ${callMessageUUID}`); } - pushCallMessageToCallCache(sender, remoteCallUUID, callMessage); + pushCallMessageToCallCache(sender, callMessageUUID, callMessage); if (!peerConnection) { window.log.info('handleCallTypeAnswer without peer connection. Dropping'); @@ -1066,7 +1098,11 @@ export async function handleCallTypeAnswer(sender: string, callMessage: SignalSe // window.log?.info('Setting remote answer pending'); isSettingRemoteAnswerPending = true; - await peerConnection?.setRemoteDescription(remoteDesc); // SRD rolls back as needed + try { + await peerConnection?.setRemoteDescription(remoteDesc); // SRD rolls back as needed + } catch (e) { + window.log.warn('setRemoteDescription failed:', e); + } isSettingRemoteAnswerPending = false; } diff --git a/ts/state/ducks/call.tsx b/ts/state/ducks/call.tsx new file mode 100644 index 000000000..47e9e3bdb --- /dev/null +++ b/ts/state/ducks/call.tsx @@ -0,0 +1,111 @@ +import { createSlice, PayloadAction } from '@reduxjs/toolkit'; + +export type CallStatusEnum = 'offering' | 'incoming' | 'connecting' | 'ongoing' | undefined; + +export type CallStateType = { + ongoingWith?: string; + ongoingCallStatus?: CallStatusEnum; + callIsInFullScreen: boolean; +}; + +export const initialCallState: CallStateType = { + ongoingWith: undefined, + ongoingCallStatus: undefined, + callIsInFullScreen: false, +}; + +/** + * This slice is the one holding the default joinable rooms fetched once in a while from the default opengroup v2 server. + */ +const callSlice = createSlice({ + name: 'call', + initialState: initialCallState, + reducers: { + incomingCall(state: CallStateType, action: PayloadAction<{ pubkey: string }>) { + const callerPubkey = action.payload.pubkey; + if (state.ongoingWith && state.ongoingWith !== callerPubkey) { + window.log.warn( + `Got an incoming call action for ${callerPubkey} but we are already in a call.` + ); + return state; + } + state.ongoingWith = callerPubkey; + state.ongoingCallStatus = 'incoming'; + return state; + }, + endCall(state: CallStateType) { + state.ongoingCallStatus = undefined; + state.ongoingWith = undefined; + + return state; + }, + answerCall(state: CallStateType, action: PayloadAction<{ pubkey: string }>) { + const callerPubkey = action.payload.pubkey; + + // to answer a call we need an incoming call form that specific pubkey + + if (state.ongoingWith !== callerPubkey || state.ongoingCallStatus !== 'incoming') { + window.log.info('cannot answer a call we are not displaying a dialog with'); + return state; + } + state.ongoingCallStatus = 'connecting'; + state.callIsInFullScreen = false; + return state; + }, + callConnected(state: CallStateType, action: PayloadAction<{ pubkey: string }>) { + const callerPubkey = action.payload.pubkey; + if (callerPubkey !== state.ongoingWith) { + window.log.info('cannot answer a call we did not start or receive first'); + return state; + } + const existingCallState = state.ongoingCallStatus; + + if (existingCallState !== 'connecting' && existingCallState !== 'offering') { + window.log.info( + 'cannot answer a call we are not connecting (and so answered) to or offering a call' + ); + return state; + } + + state.ongoingCallStatus = 'ongoing'; + state.callIsInFullScreen = false; + return state; + }, + startingCallWith(state: CallStateType, action: PayloadAction<{ pubkey: string }>) { + if (state.ongoingWith) { + window.log.warn('cannot start a call with an ongoing call already: ongoingWith'); + return state; + } + if (state.ongoingCallStatus) { + window.log.warn('cannot start a call with an ongoing call already: ongoingCallStatus'); + return state; + } + + const callerPubkey = action.payload.pubkey; + state.ongoingWith = callerPubkey; + state.ongoingCallStatus = 'offering'; + state.callIsInFullScreen = false; + + return state; + }, + setFullScreenCall(state: CallStateType, action: PayloadAction) { + // only set in full screen if we have an ongoing call + if (state.ongoingWith && state.ongoingCallStatus === 'ongoing' && action.payload) { + state.callIsInFullScreen = true; + } + state.callIsInFullScreen = false; + return state; + }, + }, +}); + +const { actions, reducer } = callSlice; +export const { + incomingCall, + endCall, + answerCall, + callConnected, + startingCallWith, + setFullScreenCall, +} = actions; +export const callReducer = reducer; diff --git a/ts/state/ducks/conversations.ts b/ts/state/ducks/conversations.ts index bc00e05fe..177ca87bc 100644 --- a/ts/state/ducks/conversations.ts +++ b/ts/state/ducks/conversations.ts @@ -3,7 +3,6 @@ import { createAsyncThunk, createSlice, PayloadAction } from '@reduxjs/toolkit'; import { getConversationController } from '../../session/conversations'; import { getFirstUnreadMessageIdInConversation, getMessagesByConversation } from '../../data/data'; import { - CallState, ConversationNotificationSettingType, ConversationTypeEnum, } from '../../models/conversation'; @@ -253,7 +252,6 @@ export interface ReduxConversationType { currentNotificationSetting?: ConversationNotificationSettingType; isPinned?: boolean; - callState?: CallState; } export interface NotificationForConvoOption { @@ -277,7 +275,6 @@ export type ConversationsStateType = { quotedMessage?: ReplyingToMessageProps; areMoreMessagesBeingFetched: boolean; haveDoneFirstScroll: boolean; - callIsInFullScreen: boolean; showScrollButton: boolean; animateQuotedMessageId?: string; @@ -372,7 +369,6 @@ export function getEmptyConversationState(): ConversationsStateType { mentionMembers: [], firstUnreadMessageId: undefined, haveDoneFirstScroll: false, - callIsInFullScreen: false, }; } @@ -698,7 +694,6 @@ const conversationsSlice = createSlice({ return { conversationLookup: state.conversationLookup, - callIsInFullScreen: state.callIsInFullScreen, selectedConversation: action.payload.id, areMoreMessagesBeingFetched: false, @@ -762,102 +757,6 @@ const conversationsSlice = createSlice({ state.mentionMembers = action.payload; return state; }, - incomingCall(state: ConversationsStateType, action: PayloadAction<{ pubkey: string }>) { - const callerPubkey = action.payload.pubkey; - const existingCallState = state.conversationLookup[callerPubkey].callState; - if (existingCallState !== undefined) { - return state; - } - const foundConvo = getConversationController().get(callerPubkey); - if (!foundConvo) { - return state; - } - - // we have to update the model itself. - // not the db (as we dont want to store that field in it) - // and not the redux store directly as it gets overriden by the commit() of the conversationModel - foundConvo.callState = 'incoming'; - - void foundConvo.commit(); - return state; - }, - endCall(state: ConversationsStateType, action: PayloadAction<{ pubkey: string }>) { - const callerPubkey = action.payload.pubkey; - const existingCallState = state.conversationLookup[callerPubkey].callState; - if (!existingCallState) { - return state; - } - - const foundConvo = getConversationController().get(callerPubkey); - if (!foundConvo) { - return state; - } - - // we have to update the model itself. - // not the db (as we dont want to store that field in it) - // and not the redux store directly as it gets overriden by the commit() of the conversationModel - foundConvo.callState = undefined; - - void foundConvo.commit(); - return state; - }, - answerCall(state: ConversationsStateType, action: PayloadAction<{ pubkey: string }>) { - const callerPubkey = action.payload.pubkey; - const existingCallState = state.conversationLookup[callerPubkey].callState; - if (!existingCallState || existingCallState !== 'incoming') { - return state; - } - const foundConvo = getConversationController().get(callerPubkey); - if (!foundConvo) { - return state; - } - - // we have to update the model itself. - // not the db (as we dont want to store that field in it) - // and not the redux store directly as it gets overriden by the commit() of the conversationModel - - foundConvo.callState = 'connecting'; - void foundConvo.commit(); - return state; - }, - callConnected(state: ConversationsStateType, action: PayloadAction<{ pubkey: string }>) { - const callerPubkey = action.payload.pubkey; - const existingCallState = state.conversationLookup[callerPubkey].callState; - if (!existingCallState || existingCallState === 'ongoing') { - return state; - } - const foundConvo = getConversationController().get(callerPubkey); - if (!foundConvo) { - return state; - } - // we have to update the model itself. - // not the db (as we dont want to store that field in it) - // and not the redux store directly as it gets overriden by the commit() of the conversationModel - foundConvo.callState = 'ongoing'; - void foundConvo.commit(); - return state; - }, - startingCallWith(state: ConversationsStateType, action: PayloadAction<{ pubkey: string }>) { - const callerPubkey = action.payload.pubkey; - const existingCallState = state.conversationLookup[callerPubkey].callState; - if (existingCallState) { - return state; - } - const foundConvo = getConversationController().get(callerPubkey); - if (!foundConvo) { - return state; - } - // we have to update the model itself. - // not the db (as we dont want to store that field in it) - // and not the redux store directly as it gets overriden by the commit() of the conversationModel - foundConvo.callState = 'offering'; - void foundConvo.commit(); - return state; - }, - setFullScreenCall(state: ConversationsStateType, action: PayloadAction) { - state.callIsInFullScreen = action.payload; - return state; - }, }, extraReducers: (builder: any) => { // Add reducers for additional action types here, and handle loading state as needed @@ -917,13 +816,6 @@ export const { quotedMessageToAnimate, setNextMessageToPlayId, updateMentionsMembers, - // calls - incomingCall, - endCall, - answerCall, - callConnected, - startingCallWith, - setFullScreenCall, } = actions; export async function openConversationWithMessages(args: { diff --git a/ts/state/reducer.ts b/ts/state/reducer.ts index 04b206e3b..4e81828d7 100644 --- a/ts/state/reducer.ts +++ b/ts/state/reducer.ts @@ -6,6 +6,7 @@ import { reducer as user, UserStateType } from './ducks/user'; import { reducer as theme, ThemeStateType } from './ducks/theme'; import { reducer as section, SectionStateType } from './ducks/section'; import { defaultRoomReducer as defaultRooms, DefaultRoomsState } from './ducks/defaultRooms'; +import { callReducer as call, CallStateType } from './ducks/call'; import { defaultOnionReducer as onionPaths, OnionState } from './ducks/onion'; import { modalReducer as modals, ModalState } from './ducks/modalDialog'; @@ -28,6 +29,7 @@ export type StateType = { userConfig: UserConfigState; timerOptions: TimerOptionsState; stagedAttachments: StagedAttachmentsStateType; + call: CallStateType; }; export const reducers = { @@ -42,6 +44,7 @@ export const reducers = { userConfig, timerOptions, stagedAttachments, + call, }; // Making this work would require that our reducer signature supported AnyAction, not diff --git a/ts/state/selectors/call.ts b/ts/state/selectors/call.ts new file mode 100644 index 000000000..819938245 --- /dev/null +++ b/ts/state/selectors/call.ts @@ -0,0 +1,103 @@ +import { createSelector } from 'reselect'; +import { CallStateType } from '../ducks/call'; +import { ConversationsStateType, ReduxConversationType } from '../ducks/conversations'; +import { StateType } from '../reducer'; +import { getConversations, getSelectedConversationKey } from './conversations'; + +export const getCallState = (state: StateType): CallStateType => state.call; + +// --- INCOMING CALLS +export const getHasIncomingCallFrom = createSelector(getCallState, (state: CallStateType): + | string + | undefined => { + return state.ongoingWith && state.ongoingCallStatus === 'incoming' + ? state.ongoingWith + : undefined; +}); + +export const getHasIncomingCall = createSelector( + getHasIncomingCallFrom, + (withConvo: string | undefined): boolean => !!withConvo +); + +// --- ONGOING CALLS +export const getHasOngoingCallWith = createSelector( + getConversations, + getCallState, + (convos: ConversationsStateType, callState: CallStateType): ReduxConversationType | undefined => { + if ( + callState.ongoingWith && + (callState.ongoingCallStatus === 'connecting' || + callState.ongoingCallStatus === 'offering' || + callState.ongoingCallStatus === 'ongoing') + ) { + return convos.conversationLookup[callState.ongoingWith] || undefined; + } + return undefined; + } +); + +export const getHasOngoingCall = createSelector( + getHasOngoingCallWith, + (withConvo: ReduxConversationType | undefined): boolean => !!withConvo +); + +export const getHasOngoingCallWithPubkey = createSelector( + getHasOngoingCallWith, + (withConvo: ReduxConversationType | undefined): string | undefined => withConvo?.id +); + +export const getHasOngoingCallWithFocusedConvo = createSelector( + getHasOngoingCallWithPubkey, + getSelectedConversationKey, + (withPubkey, selectedPubkey) => { + return withPubkey && withPubkey === selectedPubkey; + } +); + +export const getHasOngoingCallWithFocusedConvoIsOffering = createSelector( + getCallState, + getSelectedConversationKey, + (callState: CallStateType, selectedConvoPubkey?: string): boolean => { + if ( + !selectedConvoPubkey || + !callState.ongoingWith || + callState.ongoingCallStatus !== 'offering' || + selectedConvoPubkey !== callState.ongoingWith + ) { + return false; + } + + return true; + } +); + +export const getHasOngoingCallWithFocusedConvosIsConnecting = createSelector( + getCallState, + getSelectedConversationKey, + (callState: CallStateType, selectedConvoPubkey?: string): boolean => { + if ( + !selectedConvoPubkey || + !callState.ongoingWith || + callState.ongoingCallStatus !== 'connecting' || + selectedConvoPubkey !== callState.ongoingWith + ) { + return false; + } + + return true; + } +); + +export const getHasOngoingCallWithNonFocusedConvo = createSelector( + getHasOngoingCallWithPubkey, + getSelectedConversationKey, + (withPubkey, selectedPubkey) => { + return withPubkey && withPubkey !== selectedPubkey; + } +); + +export const getCallIsInFullScreen = createSelector( + getCallState, + (callState): boolean => callState.callIsInFullScreen +); diff --git a/ts/state/selectors/conversations.ts b/ts/state/selectors/conversations.ts index 301ae73d4..de9fc35a4 100644 --- a/ts/state/selectors/conversations.ts +++ b/ts/state/selectors/conversations.ts @@ -95,99 +95,6 @@ export const getConversationById = createSelector( } ); -export const getHasIncomingCallFrom = createSelector( - getConversations, - (state: ConversationsStateType): string | undefined => { - const foundEntry = Object.entries(state.conversationLookup).find( - ([_convoKey, convo]) => convo.callState === 'incoming' - ); - - if (!foundEntry) { - return undefined; - } - return foundEntry[1].id; - } -); - -export const getHasOngoingCallWith = createSelector( - getConversations, - (state: ConversationsStateType): ReduxConversationType | undefined => { - const foundEntry = Object.entries(state.conversationLookup).find( - ([_convoKey, convo]) => - convo.callState === 'connecting' || - convo.callState === 'offering' || - convo.callState === 'ongoing' - ); - - if (!foundEntry) { - return undefined; - } - return foundEntry[1]; - } -); - -export const getHasIncomingCall = createSelector( - getHasIncomingCallFrom, - (withConvo: string | undefined): boolean => !!withConvo -); - -export const getHasOngoingCall = createSelector( - getHasOngoingCallWith, - (withConvo: ReduxConversationType | undefined): boolean => !!withConvo -); - -export const getHasOngoingCallWithPubkey = createSelector( - getHasOngoingCallWith, - (withConvo: ReduxConversationType | undefined): string | undefined => withConvo?.id -); - -export const getHasOngoingCallWithFocusedConvo = createSelector( - getHasOngoingCallWithPubkey, - getSelectedConversationKey, - (withPubkey, selectedPubkey) => { - return withPubkey && withPubkey === selectedPubkey; - } -); - -export const getHasOngoingCallWithFocusedConvoIsOffering = createSelector( - getConversations, - getSelectedConversationKey, - (state: ConversationsStateType, selectedConvoPubkey?: string): boolean => { - if (!selectedConvoPubkey) { - return false; - } - const isOffering = state.conversationLookup[selectedConvoPubkey]?.callState === 'offering'; - - return Boolean(isOffering); - } -); - -export const getHasOngoingCallWithFocusedConvosIsConnecting = createSelector( - getConversations, - getSelectedConversationKey, - (state: ConversationsStateType, selectedConvoPubkey?: string): boolean => { - if (!selectedConvoPubkey) { - return false; - } - const isOffering = state.conversationLookup[selectedConvoPubkey]?.callState === 'connecting'; - - return Boolean(isOffering); - } -); - -export const getHasOngoingCallWithNonFocusedConvo = createSelector( - getHasOngoingCallWithPubkey, - getSelectedConversationKey, - (withPubkey, selectedPubkey) => { - return withPubkey && withPubkey !== selectedPubkey; - } -); - -export const getCallIsInFullScreen = createSelector( - getConversations, - (state: ConversationsStateType): boolean => state.callIsInFullScreen -); - export const getIsTypingEnabled = createSelector( getConversations, getSelectedConversationKey, diff --git a/ts/state/smart/SessionConversation.ts b/ts/state/smart/SessionConversation.ts index 03cc046ff..0cf347fa9 100644 --- a/ts/state/smart/SessionConversation.ts +++ b/ts/state/smart/SessionConversation.ts @@ -4,7 +4,6 @@ import { SessionConversation } from '../../components/session/conversation/Sessi import { StateType } from '../reducer'; import { getTheme } from '../selectors/theme'; import { - getHasOngoingCallWithFocusedConvo, getLightBoxOptions, getSelectedConversation, getSelectedConversationKey, @@ -15,6 +14,7 @@ import { } from '../selectors/conversations'; import { getOurNumber } from '../selectors/user'; import { getStagedAttachmentsForCurrentConversation } from '../selectors/stagedAttachments'; +import { getHasOngoingCallWithFocusedConvo } from '../selectors/call'; const mapStateToProps = (state: StateType) => { return {