Cleanup how we setup the CallKit provider and have it be used for outgoing calls as well (#2967)

- tear down ElementCall screens when ending the call from the CXCallController
- make the call UI available in the task manager and lock screen
- Fix broken hang up widget message format

ElementX/Sources/Application/AppCoordinator.swift

@@ -149,10 +149,10 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
             .receive(on: DispatchQueue.main)
             .sink { [weak self] action in
                 switch action {
-                case .answerCall(let roomID):
+                case .startCall(let roomID):
                     self?.handleAppRoute(.call(roomID: roomID))
-                case .declineCall:
-                    break
+                case .endCall:
+                    break // Handled internally in the UserSessionFlowCoordinator
                 }
             }
             .store(in: &cancellables)

ElementX/Sources/FlowCoordinators/UserSessionFlowCoordinator.swift

@@ -168,6 +168,18 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
                 }
             }
             .store(in: &cancellables)
+        
+        elementCallService.actions
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] action in
+                switch action {
+                case .startCall:
+                    break
+                case .endCall:
+                    self?.dismissCallScreenIfNeeded()
+                }
+            }
+            .store(in: &cancellables)
     }
     
     func start() {
@@ -569,6 +581,14 @@ class UserSessionFlowCoordinator: FlowCoordinatorProtocol {
         presentCallScreen(roomProxy: roomProxy)
     }
     
+    private func dismissCallScreenIfNeeded() {
+        guard navigationSplitCoordinator.sheetCoordinator is CallScreenCoordinator else {
+            return
+        }
+        
+        navigationSplitCoordinator.setSheetCoordinator(nil)
+    }
+    
     // MARK: Secure backup confirmation
     
     private func presentSecureBackupLogoutConfirmationScreen() {

ElementX/Sources/Mocks/ElementCallServiceMock.swift

@@ -0,0 +1,28 @@
+//
+// Copyright 2024 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Combine
+import Foundation
+
+struct ElementCallServiceMockConfiguration { }
+
+extension ElementCallServiceMock {
+    convenience init(_ configuration: ElementCallServiceMockConfiguration) {
+        self.init()
+        
+        underlyingActions = PassthroughSubject().eraseToAnyPublisher()
+    }
+}

ElementX/Sources/Mocks/Generated/GeneratedMocks.swift

@@ -4697,15 +4697,15 @@ class ElementCallServiceMock: ElementCallServiceProtocol {
 
     //MARK: - setupCallSession
 
-    var setupCallSessionTitleUnderlyingCallsCount = 0
-    var setupCallSessionTitleCallsCount: Int {
+    var setupCallSessionRoomIDRoomDisplayNameUnderlyingCallsCount = 0
+    var setupCallSessionRoomIDRoomDisplayNameCallsCount: Int {
         get {
             if Thread.isMainThread {
-                return setupCallSessionTitleUnderlyingCallsCount
+                return setupCallSessionRoomIDRoomDisplayNameUnderlyingCallsCount
             } else {
                 var returnValue: Int? = nil
                 DispatchQueue.main.sync {
-                    returnValue = setupCallSessionTitleUnderlyingCallsCount
+                    returnValue = setupCallSessionRoomIDRoomDisplayNameUnderlyingCallsCount
                 }
 
                 return returnValue!
@@ -4713,28 +4713,28 @@ class ElementCallServiceMock: ElementCallServiceProtocol {
         }
         set {
             if Thread.isMainThread {
-                setupCallSessionTitleUnderlyingCallsCount = newValue
+                setupCallSessionRoomIDRoomDisplayNameUnderlyingCallsCount = newValue
             } else {
                 DispatchQueue.main.sync {
-                    setupCallSessionTitleUnderlyingCallsCount = newValue
+                    setupCallSessionRoomIDRoomDisplayNameUnderlyingCallsCount = newValue
                 }
             }
         }
     }
-    var setupCallSessionTitleCalled: Bool {
-        return setupCallSessionTitleCallsCount > 0
+    var setupCallSessionRoomIDRoomDisplayNameCalled: Bool {
+        return setupCallSessionRoomIDRoomDisplayNameCallsCount > 0
     }
-    var setupCallSessionTitleReceivedTitle: String?
-    var setupCallSessionTitleReceivedInvocations: [String] = []
-    var setupCallSessionTitleClosure: ((String) async -> Void)?
+    var setupCallSessionRoomIDRoomDisplayNameReceivedArguments: (roomID: String, roomDisplayName: String)?
+    var setupCallSessionRoomIDRoomDisplayNameReceivedInvocations: [(roomID: String, roomDisplayName: String)] = []
+    var setupCallSessionRoomIDRoomDisplayNameClosure: ((String, String) async -> Void)?
 
-    func setupCallSession(title: String) async {
-        setupCallSessionTitleCallsCount += 1
-        setupCallSessionTitleReceivedTitle = title
+    func setupCallSession(roomID: String, roomDisplayName: String) async {
+        setupCallSessionRoomIDRoomDisplayNameCallsCount += 1
+        setupCallSessionRoomIDRoomDisplayNameReceivedArguments = (roomID: roomID, roomDisplayName: roomDisplayName)
         DispatchQueue.main.async {
-            self.setupCallSessionTitleReceivedInvocations.append(title)
+            self.setupCallSessionRoomIDRoomDisplayNameReceivedInvocations.append((roomID: roomID, roomDisplayName: roomDisplayName))
         }
-        await setupCallSessionTitleClosure?(title)
+        await setupCallSessionRoomIDRoomDisplayNameClosure?(roomID, roomDisplayName)
     }
     //MARK: - tearDownCallSession
 

ElementX/Sources/Screens/CallScreen/CallScreenViewModel.swift

@@ -102,7 +102,7 @@ class CallScreenViewModel: CallScreenViewModelType, CallScreenViewModelProtocol
                 return
             }
             
-            await elementCallService.setupCallSession(title: roomProxy.roomTitle)
+            await elementCallService.setupCallSession(roomID: roomProxy.id, roomDisplayName: roomProxy.roomTitle)
             
             let _ = await roomProxy.sendCallNotificationIfNeeeded()
         }
@@ -128,15 +128,15 @@ class CallScreenViewModel: CallScreenViewModelType, CallScreenViewModelProtocol
     
     private func hangUp() async {
         let hangUpMessage = """
-        "api":"toWidget",
+        {"api":"fromWidget",
         "widgetId":"\(widgetDriver.widgetID)",
         "requestId":"widgetapi-\(UUID())",
         "action":"im.vector.hangup",
-        "data":{}
+        "data":{}}
         """
         
         let result = await widgetDriver.sendMessage(hangUpMessage)
-        MXLog.error("Result yo: \(result)")
+        MXLog.info("Sent hangUp message with result: \(result)")
     }
 
     private static let eventHandlerName = "elementx"

ElementX/Sources/Screens/CallScreen/View/CallScreen.swift

@@ -181,7 +181,7 @@ struct CallScreen_Previews: PreviewProvider {
         
         roomProxy.elementCallWidgetDriverReturnValue = widgetDriver
         
-        return CallScreenViewModel(elementCallService: ElementCallServiceMock(),
+        return CallScreenViewModel(elementCallService: ElementCallServiceMock(.init()),
                                    roomProxy: roomProxy,
                                    callBaseURL: "https://call.element.io",
                                    clientID: "io.element.elementx")

ElementX/Sources/Services/ElementCall/ElementCallService.swift

@@ -19,19 +19,36 @@ import CallKit
 import Combine
 import Foundation
 import PushKit
+import UIKit
 
 class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDelegate, CXProviderDelegate {
+    private struct CallID: Equatable {
+        let callKitID: UUID
+        let roomID: String
+    }
+    
     private let pushRegistry: PKPushRegistry
-    
     private let callController = CXCallController()
-
-    private var callProvider: CXProvider?
-    private var ongoingCallID: UUID?
-    
-    private var incomingCallRoomID: String?
+    private let callProvider: CXProvider = {
+        let configuration = CXProviderConfiguration()
+        configuration.supportsVideo = true
+        configuration.includesCallsInRecents = true
+        
+        if let callKitIcon = UIImage(named: "images/app-logo") {
+            configuration.iconTemplateImageData = callKitIcon.pngData()
+        }
+        
+        // https://stackoverflow.com/a/46077628/730924
+        configuration.supportedHandleTypes = [.generic]
+        
+        return CXProvider(configuration: configuration)
+    }()
     
+    private var incomingCallID: CallID?
     private var endUnansweredCallTask: Task<Void, Never>?
     
+    private var ongoingCallID: CallID?
+    
     private let actionsSubject: PassthroughSubject<ElementCallServiceAction, Never> = .init()
     var actions: AnyPublisher<ElementCallServiceAction, Never> {
         actionsSubject.eraseToAnyPublisher()
@@ -44,47 +61,47 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
         
         pushRegistry.delegate = self
         pushRegistry.desiredPushTypes = [.voIP]
+        
+        callProvider.setDelegate(self, queue: nil)
     }
     
-    func setupCallSession(title: String) async {
-        guard ongoingCallID == nil else {
-            return
+    func setupCallSession(roomID: String, roomDisplayName: String) async {
+        // Drop any ongoing calls when starting a new one
+        if ongoingCallID != nil {
+            tearDownCallSession()
         }
-                
-        let callID = UUID()
+        
+        // If this starting from a ring reuse those identifiers
+        // Make sure the roomID matches
+        let callID = if let incomingCallID, incomingCallID.roomID == roomID {
+            incomingCallID
+        } else {
+            CallID(callKitID: UUID(), roomID: roomID)
+        }
+        
+        incomingCallID = nil
         ongoingCallID = callID
         
-        let handle = CXHandle(type: .generic, value: title)
-        let startCallAction = CXStartCallAction(call: callID, handle: handle)
+        let handle = CXHandle(type: .generic, value: roomDisplayName)
+        let startCallAction = CXStartCallAction(call: callID.callKitID, handle: handle)
         startCallAction.isVideo = true
         
-        let transaction = CXTransaction(action: startCallAction)
-        
         do {
-            try await callController.request(transaction)
+            try await callController.request(CXTransaction(action: startCallAction))
+        } catch {
+            MXLog.error("Failed requesting start call action with error: \(error)")
+        }
+        
+        do { // Setup the audio session even if setting up CallKit failed, ElementCall **is** running at this point
             try AVAudioSession.sharedInstance().setCategory(.playAndRecord, mode: .videoChat, options: [])
             try AVAudioSession.sharedInstance().setActive(true, options: .notifyOthersOnDeactivation)
         } catch {
-            MXLog.error("Failed setting up VoIP session with error: \(error)")
-            tearDownCallSession()
+            MXLog.error("Failed setting up audio session with error: \(error)")
         }
     }
     
     func tearDownCallSession() {
-        guard let ongoingCallID else {
-            return
-        }
-        
-        try? AVAudioSession.sharedInstance().setActive(false)
-            
-        let endCallAction = CXEndCallAction(call: ongoingCallID)
-        let transaction = CXTransaction(action: endCallAction)
-        
-        callController.request(transaction) { error in
-            if let error {
-                MXLog.error("Failed transaction with error: \(error)")
-            }
-        }
+        tearDownCallSession(sendEndCallAction: true)
     }
 
     // MARK: - PKPushRegistryDelegate
@@ -97,31 +114,18 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
             return
         }
         
-        let callID = UUID()
-        ongoingCallID = callID
+        let callID = CallID(callKitID: UUID(), roomID: roomID)
+        incomingCallID = callID
         
-        incomingCallRoomID = roomID
-        
-        let configuration = CXProviderConfiguration()
-        configuration.supportsVideo = true
-        configuration.includesCallsInRecents = true
-        // Provide image icon if available
-        configuration.iconTemplateImageData = nil
-        
-        // https://stackoverflow.com/a/46077628/730924
-        configuration.supportedHandleTypes = [.generic]
+        let roomDisplayName = payload.dictionaryPayload[ElementCallServiceNotificationKey.roomDisplayName.rawValue] as? String
         
         let update = CXCallUpdate()
         update.hasVideo = true
-        
-        update.localizedCallerName = payload.dictionaryPayload[ElementCallServiceNotificationKey.roomDisplayName.rawValue] as? String
-        
+        update.localizedCallerName = roomDisplayName
         // https://stackoverflow.com/a/41230020/730924
         update.remoteHandle = .init(type: .generic, value: roomID)
         
-        let callProvider = CXProvider(configuration: configuration)
-        callProvider.setDelegate(self, queue: nil)
-        callProvider.reportNewIncomingCall(with: callID, update: update) { error in
+        callProvider.reportNewIncomingCall(with: callID.callKitID, update: update) { error in
             if let error {
                 MXLog.error("Failed reporting new incoming call with error: \(error)")
             }
@@ -129,14 +133,15 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
             completion()
         }
         
-        endUnansweredCallTask = Task { [weak self, callProvider, callID] in
+        endUnansweredCallTask = Task { [weak self] in
             try? await Task.sleep(for: .seconds(15))
-            guard !Task.isCancelled else {
+            
+            guard let self, !Task.isCancelled else {
                 return
             }
             
-            if let ongoingCallID = self?.ongoingCallID, ongoingCallID == callID {
-                callProvider.reportCall(with: callID, endedAt: .now, reason: .unanswered)
+            if let incomingCallID, incomingCallID.callKitID == callID.callKitID {
+                callProvider.reportCall(with: incomingCallID.callKitID, endedAt: nil, reason: .unanswered)
             }
         }
     }
@@ -147,29 +152,57 @@ class ElementCallService: NSObject, ElementCallServiceProtocol, PKPushRegistryDe
         MXLog.info("Call provider did reset: \(provider)")
     }
     
+    func provider(_ provider: CXProvider, perform action: CXStartCallAction) {
+        if let ongoingCallID {
+            provider.reportOutgoingCall(with: ongoingCallID.callKitID, connectedAt: nil)
+        } else {
+            MXLog.error("Failed starting call, missing ongoingCallID")
+        }
+
+        action.fulfill()
+    }
+    
     func provider(_ provider: CXProvider, perform action: CXAnswerCallAction) {
-        if let incomingCallRoomID {
-            Task {
-                // Dispatch to next run loop so it doesn't conflict with `setupCallSession`
-                actionsSubject.send(.answerCall(roomID: incomingCallRoomID))
-            }
-            self.incomingCallRoomID = nil
+        if let incomingCallID {
+            actionsSubject.send(.startCall(roomID: incomingCallID.roomID))
             endUnansweredCallTask?.cancel()
         } else {
-            MXLog.error("Failed answering incoming call, missing room ID")
+            MXLog.error("Failed answering incoming call, missing incomingCallID")
         }
         
         action.fulfill()
     }
     
+    func provider(_ provider: CXProvider, perform action: CXSetMutedCallAction) {
+        // Forward this to the widget somehow
+        // webView.evaluateJavaScript("groupCall.setLocalVideoMuted(!groupCall.isLocalVideoMuted())")
+        // webView.evaluateJavaScript("groupCall.setMicrophoneMuted(!groupCall.isMicrophoneMuted())"
+    }
+    
     func provider(_ provider: CXProvider, perform action: CXEndCallAction) {
-        if let incomingCallRoomID {
-            actionsSubject.send(.declineCall(roomID: incomingCallRoomID))
-            self.incomingCallRoomID = nil
-        } else {
-            MXLog.error("Failed declining incoming call, missing room ID")
+        if let ongoingCallID {
+            actionsSubject.send(.endCall(roomID: ongoingCallID.roomID))
         }
-
+        
+        tearDownCallSession(sendEndCallAction: false)
+        
         action.fulfill()
     }
+    
+    // MARK: - Private
+    
+    func tearDownCallSession(sendEndCallAction: Bool = true) {
+        try? AVAudioSession.sharedInstance().setActive(false)
+        
+        if sendEndCallAction, let ongoingCallID {
+            let transaction = CXTransaction(action: CXEndCallAction(call: ongoingCallID.callKitID))
+            callController.request(transaction) { error in
+                if let error {
+                    MXLog.error("Failed transaction with error: \(error)")
+                }
+            }
+        }
+        
+        ongoingCallID = nil
+    }
 }

ElementX/Sources/Services/ElementCall/ElementCallServiceProtocol.swift

@@ -17,8 +17,8 @@
 import Combine
 
 enum ElementCallServiceAction {
-    case answerCall(roomID: String)
-    case declineCall(roomID: String)
+    case startCall(roomID: String)
+    case endCall(roomID: String)
 }
 
 enum ElementCallServiceNotificationKey: String {
@@ -32,7 +32,7 @@ let ElementCallServiceNotificationDiscardDelta = 10.0
 protocol ElementCallServiceProtocol {
     var actions: AnyPublisher<ElementCallServiceAction, Never> { get }
     
-    func setupCallSession(title: String) async
+    func setupCallSession(roomID: String, roomDisplayName: String) async
     
     func tearDownCallSession()
 }

ElementX/Sources/UITests/UITestsAppCoordinator.swift

@@ -525,7 +525,7 @@ class MockScreen: Identifiable {
                                                              appLockService: AppLockService(keychainController: KeychainControllerMock(),
                                                                                             appSettings: ServiceLocator.shared.settings),
                                                              bugReportService: BugReportServiceMock(),
-                                                             elementCallService: ElementCallServiceMock(),
+                                                             elementCallService: ElementCallServiceMock(.init()),
                                                              roomTimelineControllerFactory: RoomTimelineControllerFactoryMock(configuration: .init()),
                                                              appMediator: AppMediatorMock.default,
                                                              appSettings: appSettings,
@@ -641,7 +641,7 @@ class MockScreen: Identifiable {
                                                              appLockService: AppLockService(keychainController: KeychainControllerMock(),
                                                                                             appSettings: ServiceLocator.shared.settings),
                                                              bugReportService: BugReportServiceMock(),
-                                                             elementCallService: ElementCallServiceMock(),
+                                                             elementCallService: ElementCallServiceMock(.init()),
                                                              roomTimelineControllerFactory: RoomTimelineControllerFactoryMock(configuration: .init(timelineController: timelineController)),
                                                              appMediator: AppMediatorMock.default,
                                                              appSettings: appSettings,