Listen to call decline to stop ringing when declined from other device

Author: BillCarsonFr

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -9067,6 +9067,76 @@ class JoinedRoomProxyMock: JoinedRoomProxyProtocol, @unchecked Sendable {
             return declineCallNotificationIDReturnValue
         }
     }
+    //MARK: - callDeclineEventPublisher
+
+    var callDeclineEventPublisherNotificationIdUnderlyingCallsCount = 0
+    var callDeclineEventPublisherNotificationIdCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return callDeclineEventPublisherNotificationIdUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = callDeclineEventPublisherNotificationIdUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                callDeclineEventPublisherNotificationIdUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    callDeclineEventPublisherNotificationIdUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    var callDeclineEventPublisherNotificationIdCalled: Bool {
+        return callDeclineEventPublisherNotificationIdCallsCount > 0
+    }
+    var callDeclineEventPublisherNotificationIdReceivedRtcNotificationEventId: String?
+    var callDeclineEventPublisherNotificationIdReceivedInvocations: [String] = []
+
+    var callDeclineEventPublisherNotificationIdUnderlyingReturnValue: AnyPublisher<RtcDeclinedEvent, Never>!
+    var callDeclineEventPublisherNotificationIdReturnValue: AnyPublisher<RtcDeclinedEvent, Never>! {
+        get {
+            if Thread.isMainThread {
+                return callDeclineEventPublisherNotificationIdUnderlyingReturnValue
+            } else {
+                var returnValue: AnyPublisher<RtcDeclinedEvent, Never>? = nil
+                DispatchQueue.main.sync {
+                    returnValue = callDeclineEventPublisherNotificationIdUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                callDeclineEventPublisherNotificationIdUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    callDeclineEventPublisherNotificationIdUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    var callDeclineEventPublisherNotificationIdClosure: ((String) -> AnyPublisher<RtcDeclinedEvent, Never>)?
+
+    func callDeclineEventPublisher(notificationId rtcNotificationEventId: String) -> AnyPublisher<RtcDeclinedEvent, Never> {
+        callDeclineEventPublisherNotificationIdCallsCount += 1
+        callDeclineEventPublisherNotificationIdReceivedRtcNotificationEventId = rtcNotificationEventId
+        DispatchQueue.main.async {
+            self.callDeclineEventPublisherNotificationIdReceivedInvocations.append(rtcNotificationEventId)
+        }
+        if let callDeclineEventPublisherNotificationIdClosure = callDeclineEventPublisherNotificationIdClosure {
+            return callDeclineEventPublisherNotificationIdClosure(rtcNotificationEventId)
+        } else {
+            return callDeclineEventPublisherNotificationIdReturnValue
+        }
+    }
     //MARK: - matrixToPermalink
 
     var matrixToPermalinkUnderlyingCallsCount = 0

ElementX/Sources/Services/ElementCall/ElementCallService.swift

@@ -9,6 +9,7 @@ import AVFoundation
 import CallKit
 import Combine
 import Foundation
+import MatrixRustSDK
 import PushKit
 import UIKit
 
@@ -48,7 +49,10 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
     private var incomingCallRoomInfoCancellable: AnyCancellable?
     private var incomingCallID: CallID? {
         didSet {
-            Task { await observeIncomingCallRoomInfo() }
+            Task {
+                await observeIncomingCallRoomInfo()
+                await observeDeclineEvents()
+            }
         }
     }
 
@@ -68,6 +72,8 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
         actionsSubject.eraseToAnyPublisher()
     }
 
+    private var declineListenerCancellable: AnyCancellable?
+    
     override init() {
         pushRegistry = PKPushRegistry(queue: nil)
 
@@ -354,4 +360,43 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
                 }
             }
     }
+    
+    private func observeDeclineEvents() async {
+        guard let incomingCallID else {
+            MXLog.info("Decline: No incoming call to observe for.")
+            return
+        }
+        
+        guard let clientProxy else {
+            MXLog.warning("Decline: A ClientProxy is needed to fetch the room.")
+            return
+        }
+        
+        guard let rtcNotificationId = incomingCallID.rtcNotificationId else {
+            MXLog.warning("Decline: No RTC notification ID found for the incoming call.")
+            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
+        }
+        let ownUserId = clientProxy.userID
+        
+        MXLog.info("Observe decline events for notification \(rtcNotificationId)")
+        
+        declineListenerCancellable = roomProxy
+            .callDeclineEventPublisher(notificationId: rtcNotificationId)
+            .sink { ev in
+                MXLog.debug("Call declined event received from \(ev.sender)")
+                if ev.sender == ownUserId {
+                    // Stop ringing!
+                    MXLog.debug("Call declined elsewhere")
+                    self.declineListenerCancellable?.cancel()
+                    self.declineListenerCancellable = nil
+                    self.endUnansweredCallTask?.cancel()
+                    self.callProvider.reportCall(with: incomingCallID.callKitID, endedAt: nil, reason: .declinedElsewhere)
+                }
+            }
+    }
 }

ElementX/Sources/Services/Room/JoinedRoomProxy.swift

@@ -70,7 +70,7 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol {
     var knockRequestsStatePublisher: CurrentValuePublisher<KnockRequestsState, Never> {
         knockRequestsStateSubject.asCurrentValuePublisher()
     }
-    
+
     init(roomListService: RoomListServiceProtocol,
          room: RoomProtocol,
          appSettings: AppSettings) async throws {
@@ -649,6 +649,22 @@ class JoinedRoomProxy: JoinedRoomProxyProtocol {
         }
     }
 
+    /// Subscribe to call decline events from that rtc notification event.
+    func callDeclineEventPublisher(notificationId rtcNotificationEventId: String) -> AnyPublisher<RtcDeclinedEvent, Never> {
+        let publisher = DeclineCallbackPublisher(room: self, eventId: rtcNotificationEventId)
+        return publisher.eraseToAnyPublisher()
+    }
+    
+    func subscribeToCallDeclineEvents(rtcNotificationEventId: String, listener: RoomCallDeclineListener) -> Result<TaskHandle, RoomProxyError> {
+        do {
+            let handle = try room.subscribeToCallDeclineEvents(rtcNotificationEventId: rtcNotificationEventId, listener: listener)
+            return .success(handle)
+        } catch {
+            MXLog.error("Failed observing rtc decline with error: \(error)")
+            return .failure(.sdkError(error))
+        }
+    }
+    
     // MARK: - Permalinks
 
     func matrixToPermalink() async -> Result<URL, RoomProxyError> {
@@ -815,3 +831,57 @@ private final class RoomKnockRequestsListener: KnockRequestsListener {
         onUpdateClosure(joinRequests)
     }
 }
+
+final class RoomCallDeclineListener: CallDeclineListener {
+    private let onUpdateClosure: (RtcDeclinedEvent) -> Void
+    private let notificationId: String
+    
+    init(notificationId: String, onUpdateClosure: @escaping (RtcDeclinedEvent) -> Void) {
+        self.notificationId = notificationId
+        self.onUpdateClosure = onUpdateClosure
+    }
+    
+    func call(declinerUserId: String) {
+        onUpdateClosure(.init(sender: declinerUserId, notificationEventId: notificationId))
+    }
+}
+
+// Helper to transform callback to publisher while correctly retaining the task handle and listener.
+struct DeclineCallbackPublisher: Publisher {
+    typealias Output = RtcDeclinedEvent
+    typealias Failure = Never
+ 
+    let room: JoinedRoomProxy
+    let eventId: String
+    
+    func receive<S>(subscriber: S) where S: Subscriber, Never == S.Failure, RtcDeclinedEvent == S.Input {
+        let subscription = Inner(subscriber: subscriber, room: room, eventId: eventId)
+        subscriber.receive(subscription: subscription)
+    }
+    
+    private final class Inner<S: Subscriber>: Subscription
+        where S.Input == RtcDeclinedEvent, S.Failure == Never {
+        private var subscriber: S?
+        private var handle: TaskHandle?
+        private var listener: RoomCallDeclineListener?
+
+        init(subscriber: S, room: JoinedRoomProxy, eventId: String) {
+            self.subscriber = subscriber
+            listener = RoomCallDeclineListener(notificationId: eventId) { [weak self] ev in
+                _ = self?.subscriber?.receive(ev)
+            }
+            handle = try? room.subscribeToCallDeclineEvents(rtcNotificationEventId: eventId, listener: listener!).get()
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            // nop
+        }
+        
+        func cancel() {
+            handle?.cancel()
+            handle = nil
+            listener = nil
+            subscriber = nil
+        }
+    }
+}

ElementX/Sources/Services/Room/RoomProxyProtocol.swift

@@ -64,6 +64,13 @@ enum KnockRequestsState {
     case loaded([KnockRequestProxyProtocol])
 }
 
+struct RtcDeclinedEvent {
+    /// The sender of the decline event
+    let sender: String
+    /// The rtc.notification event that is beeing declined
+    let notificationEventId: String
+}
+
 // sourcery: AutoMockable
 protocol JoinedRoomProxyProtocol: RoomProxyProtocol {
     var infoPublisher: CurrentValuePublisher<RoomInfoProxyProtocol, Never> { get }
@@ -75,7 +82,7 @@ protocol JoinedRoomProxyProtocol: RoomProxyProtocol {
     var identityStatusChangesPublisher: CurrentValuePublisher<[IdentityStatusChange], Never> { get }
 
     var knockRequestsStatePublisher: CurrentValuePublisher<KnockRequestsState, Never> { get }
-    
+        
     var timeline: TimelineProxyProtocol { get }
 
     var predecessorRoom: PredecessorRoom? { get }
@@ -170,6 +177,7 @@ protocol JoinedRoomProxyProtocol: RoomProxyProtocol {
 
     func elementCallWidgetDriver(deviceID: String) -> ElementCallWidgetDriverProtocol
     func declineCall(notificationID: String) async -> Result<Void, RoomProxyError>
+    func callDeclineEventPublisher(notificationId rtcNotificationEventId: String) -> AnyPublisher<RtcDeclinedEvent, Never>
 
     // MARK: - Permalinks