Call: MSC4310 sending RTC decline event and listening for Decline from other sessions

MSC4310 RTC decline event support

features/call/impl/src/main/kotlin/io/element/android/features/call/impl/utils/ActiveCallManager.kt

@@ -180,12 +180,22 @@ class DefaultActiveCallManager(
     }
 
     override suspend fun hungUpCall(callType: CallType) = mutex.withLock {
-        if (activeCall.value?.callType != callType) {
+        Timber.tag(tag).d("Hung up call: $callType")
+        val currentActiveCall = activeCall.value ?: run {
+            Timber.tag(tag).w("No active call, ignoring hang up")
+            return
+        }
+        if (currentActiveCall.callType != callType) {
             Timber.tag(tag).w("Call type $callType does not match the active call type, ignoring")
             return
         }
-
-        Timber.tag(tag).d("Hung up call: $callType")
+        if (currentActiveCall.callState is CallState.Ringing) {
+            // Decline the call
+            val notificationData = currentActiveCall.callState.notificationData
+            matrixClientProvider.getOrRestore(notificationData.sessionId).getOrNull()
+                ?.getRoom(notificationData.roomId)
+                ?.declineCall(notificationData.eventId)
+        }
 
         cancelIncomingCallNotification()
         if (activeWakeLock?.isHeld == true) {
@@ -256,6 +266,43 @@ class DefaultActiveCallManager(
 
     @OptIn(ExperimentalCoroutinesApi::class)
     private fun observeRingingCall() {
+        activeCall
+            .filterNotNull()
+            .filter { it.callState is CallState.Ringing && it.callType is CallType.RoomCall }
+            .flatMapLatest { activeCall ->
+                val callType = activeCall.callType as CallType.RoomCall
+                val ringingInfo = activeCall.callState as CallState.Ringing
+                val client = matrixClientProvider.getOrRestore(callType.sessionId).getOrNull() ?: run {
+                    Timber.tag(tag).d("Couldn't find session for incoming call: $activeCall")
+                    return@flatMapLatest flowOf()
+                }
+                val room = client.getRoom(callType.roomId) ?: run {
+                    Timber.tag(tag).d("Couldn't find room for incoming call: $activeCall")
+                    return@flatMapLatest flowOf()
+                }
+
+                Timber.tag(tag).d("Found room for ringing call: ${room.roomId}")
+
+                // If we have declined from another phone we want to stop ringing.
+                room.subscribeToCallDecline(ringingInfo.notificationData.eventId)
+                    .filter { decliner ->
+                        Timber.tag(tag).d("Call: $activeCall was declined by $decliner")
+                        // only want to listen if the call was declined from another of my sessions,
+                        // (we are ringing for an incoming call in a DM)
+                        decliner == client.sessionId
+                    }
+            }
+            .onEach { decliner ->
+                Timber.tag(tag).d("Call: $activeCall was declined by user from another session")
+                // Remove the active call and cancel the notification
+                activeCall.value = null
+                if (activeWakeLock?.isHeld == true) {
+                    Timber.tag(tag).d("Releasing partial wakelock after call declined from another session")
+                    activeWakeLock.release()
+                }
+                cancelIncomingCallNotification()
+            }
+            .launchIn(coroutineScope)
         // This will observe ringing calls and ensure they're terminated if the room call is cancelled or if the user
         // has joined the call from another session.
         activeCall