EC: Send rtc.decline event when incoming call is declined

Author: BillCarsonFr

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -8997,6 +8997,76 @@ class JoinedRoomProxyMock: JoinedRoomProxyProtocol, @unchecked Sendable {
             return elementCallWidgetDriverDeviceIDReturnValue
         }
     }
+    //MARK: - declineCall
+
+    var declineCallNotificationIdUnderlyingCallsCount = 0
+    var declineCallNotificationIdCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return declineCallNotificationIdUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = declineCallNotificationIdUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                declineCallNotificationIdUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    declineCallNotificationIdUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var declineCallNotificationIdCalled: Bool {
+        return declineCallNotificationIdCallsCount > 0
+    }
+    var declineCallNotificationIdReceivedNotificationId: String?
+    var declineCallNotificationIdReceivedInvocations: [String] = []
+
+    var declineCallNotificationIdUnderlyingReturnValue: Result<Void, RoomProxyError>!
+    var declineCallNotificationIdReturnValue: Result<Void, RoomProxyError>! {
+        get {
+            if Thread.isMainThread {
+                return declineCallNotificationIdUnderlyingReturnValue
+            } else {
+                var returnValue: Result<Void, RoomProxyError>? = nil
+                DispatchQueue.main.sync {
+                    returnValue = declineCallNotificationIdUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                declineCallNotificationIdUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    declineCallNotificationIdUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var declineCallNotificationIdClosure: ((String) async -> Result<Void, RoomProxyError>)?
+
+    func declineCall(notificationId: String) async -> Result<Void, RoomProxyError> {
+        declineCallNotificationIdCallsCount += 1
+        declineCallNotificationIdReceivedNotificationId = notificationId
+        DispatchQueue.main.async {
+            self.declineCallNotificationIdReceivedInvocations.append(notificationId)
+        }
+        if let declineCallNotificationIdClosure = declineCallNotificationIdClosure {
+            return await declineCallNotificationIdClosure(notificationId)
+        } else {
+            return declineCallNotificationIdReturnValue
+        }
+    }
     //MARK: - matrixToPermalink
 
     var matrixToPermalinkUnderlyingCallsCount = 0

ElementX/Sources/Services/ElementCall/ElementCallService.swift

@@ -16,6 +16,7 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
     private struct CallID: Equatable {
         let callKitID: UUID
         let roomID: String
+        let rtcNotificationId: String?
     }
 
     private let pushRegistry: PKPushRegistry
@@ -93,7 +94,7 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
         let callID = if let incomingCallID, incomingCallID.roomID == roomID {
             incomingCallID
         } else {
-            CallID(callKitID: UUID(), roomID: roomID)
+            CallID(callKitID: UUID(), roomID: roomID, rtcNotificationId: nil)
         }
 
         incomingCallID = nil
@@ -146,12 +147,17 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
             return
         }
 
+        guard let rtcNotificationId = payload.dictionaryPayload[ElementCallServiceNotificationKey.rtcNotifyEventId.rawValue] as? String else {
+            MXLog.error("Something went wrong, missing rtc notification event identifier for incoming voip call: \(payload)")
+            return
+        }
+        
         guard ongoingCallID?.roomID != roomID else {
             MXLog.warning("Call already ongoing for room \(roomID), ignoring incoming push")
             return
         }
 
-        let callID = CallID(callKitID: UUID(), roomID: roomID)
+        let callID = CallID(callKitID: UUID(), roomID: roomID, rtcNotificationId: rtcNotificationId)
         incomingCallID = callID
 
         let roomDisplayName = payload.dictionaryPayload[ElementCallServiceNotificationKey.roomDisplayName.rawValue] as? String
@@ -253,6 +259,12 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
             actionsSubject.send(.endCall(roomID: ongoingCallID.roomID))
         }
 
+        if let incomingCallID {
+            Task {
+                await sendDeclineCallEvent(incomingCallID)
+            }
+        }
+        
         tearDownCallSession(sendEndCallAction: false)
 
         action.fulfill()
@@ -274,6 +286,25 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
         ongoingCallID = nil
     }
 
+    private func sendDeclineCallEvent(_ incomingCallID: CallID) async {
+        guard let rtcNotificationId = incomingCallID.rtcNotificationId else {
+            MXLog.info("No rtc notification event to decline.")
+            return
+        }
+        
+        guard let clientProxy else {
+            MXLog.warning("A ClientProxy is needed to fetch the room.")
+            return
+        }
+        
+        guard case let .joined(roomProxy) = await clientProxy.roomForIdentifier(incomingCallID.roomID) else {
+            MXLog.warning("Failed to fetch a joined room for the incoming call.")
+            return
+        }
+        
+        _ = await roomProxy.declineCall(notificationId: rtcNotificationId)
+    }
+    
     private func observeIncomingCallRoomInfo() async {
         incomingCallRoomInfoCancellable = nil
 

ElementX/Sources/Services/ElementCall/ElementCallServiceConstants.swift

@@ -10,6 +10,9 @@ import Foundation
 enum ElementCallServiceNotificationKey: String {
     case roomID
     case roomDisplayName
+    /// When an incoming call is set to ring, there will be a `m.rtc.notification`event  (MSC4075).
+    /// Keep the notification event id as it is needed to decline calls (MSC4310).
+    case rtcNotifyEventId
 }
 
 let ElementCallServiceNotificationDiscardDelta = 15.0

ElementX/Sources/Services/Room/JoinedRoomProxy.swift

@@ -639,6 +639,16 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol {
         ElementCallWidgetDriver(room: room, deviceID: deviceID)
     }
 
+    func declineCall(notificationId: String) async -> Result<Void, RoomProxyError> {
+        do {
+            try await room.declineCall(rtcNotificationEventId: notificationId)
+            return .success(())
+        } catch {
+            MXLog.error("Failed to decline rtc notification \(notificationId) with error: \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
+    
     // MARK: - Permalinks
 
     func matrixToPermalink() async -> Result<URL, RoomProxyError> {

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -169,6 +169,7 @@ protocol JoinedRoomProxyProtocol: RoomProxyProtocol {
     // MARK: - Element Call
 
     func elementCallWidgetDriver(deviceID: String) -> ElementCallWidgetDriverProtocol
+    func declineCall(notificationId: String) async -> Result<Void, RoomProxyError>
 
     // MARK: - Permalinks
 

NSE/Sources/NotificationHandler.swift

@@ -126,6 +126,7 @@ class NotificationHandler {
                 return .processedShouldDiscard
             case .callNotify(let notifyType):
                 return await handleCallNotification(notifyType: notifyType,
+                                                    rtcNotifyEventId: event.eventId(),
                                                     timestamp: event.timestamp(),
                                                     roomID: itemProxy.roomID,
                                                     roomDisplayName: itemProxy.roomDisplayName)
@@ -153,6 +154,7 @@ class NotificationHandler {
     /// Handle incoming call notifications.
     /// - Returns: A boolean indicating whether the notification was handled and should now be discarded.
     private func handleCallNotification(notifyType: NotifyType,
+                                        rtcNotifyEventId: String,
                                         timestamp: Timestamp,
                                         roomID: String,
                                         roomDisplayName: String) async -> NotificationProcessingResult {
@@ -206,7 +208,8 @@ class NotificationHandler {
         }
 
         let payload = [ElementCallServiceNotificationKey.roomID.rawValue: roomID,
-                       ElementCallServiceNotificationKey.roomDisplayName.rawValue: roomDisplayName]
+                       ElementCallServiceNotificationKey.roomDisplayName.rawValue: roomDisplayName,
+                       ElementCallServiceNotificationKey.rtcNotifyEventId.rawValue: rtcNotifyEventId]
 
         do {
             try await CXProvider.reportNewIncomingVoIPPushPayload(payload)