@stream-io/react-native-callingx 0.1.0-beta.4 → 0.1.0-beta.6

package/ios/CallingxImpl.swift

@@ -31,25 +31,23 @@ import stream_react_native_webrtc
     @objc public static var sharedProvider: CXProvider?
     @objc public static var uuidStorage: UUIDStorage?
     @objc public static weak var sharedInstance: CallingxImpl?
+    /// Events stored before the module instance exists (e.g. VoIP from killed state). Drained in getInitialEvents().
+    private static var delayedEvents: [[String: Any]] = []
     
     // MARK: - Instance Properties
     @objc public var callKeepCallController: CXCallController?
     @objc public var callKeepProvider: CXProvider?
     @objc public weak var eventEmitter: CallingxEventEmitter?
+    @objc public weak var webRTCModule: WebRTCModule?
     
     private var canSendEvents: Bool = false
     private var isSetup: Bool = false
-    private var isSelfAnswered: Bool = false
-    private var isSelfEnded: Bool = false
-    private var isSelfMuted: Bool = false
-    private var delayedEvents: [[String: Any]] = []
     
     // MARK: - Initialization
     @objc public override init() {
         super.init()
 
         isSetup = false
-        delayedEvents = []
         canSendEvents = false
         
         NotificationCenter.default.addObserver(
@@ -74,7 +72,6 @@ import stream_react_native_webrtc
         callKeepProvider?.invalidate()
         CallingxImpl.sharedProvider = nil
         canSendEvents = false
-        delayedEvents = []
         isSetup = false
     }
     
@@ -99,9 +96,10 @@ import stream_react_native_webrtc
         supportsDTMF: Bool,
         supportsGrouping: Bool,
         supportsUngrouping: Bool,
-        fromPushKit: Bool,
         payload: [String: Any]?,
-        completion: (() -> Void)?
+        completion: (() -> Void)?,
+        resolve: RCTPromiseResolveBlock?,
+        reject: RCTPromiseRejectBlock?
     ) {
         initializeIfNeeded()
         
@@ -112,6 +110,7 @@ import stream_react_native_webrtc
             print("[Callingx][reportNewIncomingCall] callId already exists")
             #endif
             completion?()
+            resolve?(true)
             return
         }
         
@@ -144,16 +143,28 @@ import stream_react_native_webrtc
                 "supportsDTMF": supportsDTMF ? "1" : "0",
                 "supportsGrouping": supportsGrouping ? "1" : "0",
                 "supportsUngrouping": supportsUngrouping ? "1" : "0",
-                "fromPushKit": fromPushKit ? "1" : "0",
                 "payload": payload ?? ""
             ]
             
-            sharedInstance?.sendEvent(CallingxEvents.didDisplayIncomingCall, body: body)
+            if let instance = sharedInstance {
+                instance.sendEvent(CallingxEvents.didDisplayIncomingCall, body: body)
+            } else {
+                let dictionary: [String: Any] = [
+                    "eventName": CallingxEvents.didDisplayIncomingCall,
+                    "params": body
+                ]
+                DispatchQueue.main.async {
+                    CallingxImpl.delayedEvents.append(dictionary)
+                }
+            }
             
             if error == nil {
                 #if DEBUG
                 print("[Callingx][reportNewIncomingCall] success callId = \(callId)")
                 #endif
+                resolve?(true)
+            } else {
+              reject?("DISPLAY_INCOMING_CALL_ERROR", error?.localizedDescription, error)
             }
             
             completion?()
@@ -196,17 +207,19 @@ import stream_react_native_webrtc
         print("[Callingx][endCall] callId = \(callId) reason = \(reason)")
         #endif
         
-        guard let uuid = uuidStorage?.getUUID(forCid: callId) else {
+        guard let call = uuidStorage?.getCall(forCid: callId) else {
             #if DEBUG
             print("[Callingx][endCall] callId not found")
             #endif
             return
         }
         
+        call.markEnded()
+        
         // CXCallEndedReason raw values: failed=1, remoteEnded=2, unanswered=3, answeredElsewhere=4, declinedElsewhere=5
         let endedReason = CXCallEndedReason(rawValue: reason) ?? .failed
         
-        sharedProvider?.reportCall(with: uuid, endedAt: Date(), reason: endedReason)
+        sharedProvider?.reportCall(with: call.uuid, endedAt: call.endedAt ?? Date(), reason: endedReason)
         uuidStorage?.removeCid(callId)
     }
     
@@ -242,9 +255,13 @@ import stream_react_native_webrtc
                 print("[Callingx][requestTransaction] Error requesting transaction (\(transaction.actions)): (\(error))")
                 #endif
 
-                self?.isSelfAnswered = false
-                self?.isSelfEnded = false
-                self?.isSelfMuted = false
+                // Reset per-call action-source flags for all actions in the failed transaction
+                for action in transaction.actions {
+                    if let callAction = action as? CXCallAction,
+                       let call = CallingxImpl.uuidStorage?.getCallByUUID(callAction.callUUID) {
+                        call.resetAllSelfFlags()
+                    }
+                }
             } else {
                 #if DEBUG
                 print("[Callingx][requestTransaction] Requested transaction successfully")
@@ -280,9 +297,9 @@ import stream_react_native_webrtc
             if self.canSendEvents {
                 self.eventEmitter?.emitEvent(dictionary)
             } else {
-                self.delayedEvents.append(dictionary)
+                CallingxImpl.delayedEvents.append(dictionary)
                 #if DEBUG
-                print("[Callingx] delayedEvents: \(self.delayedEvents)")
+                print("[Callingx] delayedEvents: \(CallingxImpl.delayedEvents)")
                 #endif
             }
         }
@@ -329,11 +346,11 @@ import stream_react_native_webrtc
         var events: [[String: Any]] = []
         let action = {
             #if DEBUG
-            print("[Callingx][getInitialEvents] delayedEvents = \(self.delayedEvents)")
+            print("[Callingx][getInitialEvents] delayedEvents = \(CallingxImpl.delayedEvents)")
             #endif
             
-            events = self.delayedEvents
-            self.delayedEvents = []
+            events = CallingxImpl.delayedEvents
+            CallingxImpl.delayedEvents = []
             self.canSendEvents = true
         }
 
@@ -354,15 +371,25 @@ import stream_react_native_webrtc
         print("[Callingx][answerIncomingCall] callId = \(callId)")
         #endif
         
-        guard let uuid = CallingxImpl.uuidStorage?.getUUID(forCid: callId) else {
+        guard let call = CallingxImpl.uuidStorage?.getCall(forCid: callId) else {
             #if DEBUG
             print("[Callingx][answerIncomingCall] callId not found")
             #endif
             return false
         }
         
-        isSelfAnswered = true
-        let answerCallAction = CXAnswerCallAction(call: uuid)
+        // Guard: already answered or ended — prevent duplicate CXAnswerCallAction transactions
+        if call.isAnswered || call.hasEnded {
+            #if DEBUG
+            print("[Callingx][answerIncomingCall] callId already answered/ended, skipping")
+            #endif
+            return true
+        }
+        
+        call.markSelfAnswered()
+        call.markStartedConnecting() // internal state: incoming call is now connecting
+        
+        let answerCallAction = CXAnswerCallAction(call: call.uuid)
         let transaction = CXTransaction()
         transaction.addAction(answerCallAction)
         
@@ -374,8 +401,10 @@ import stream_react_native_webrtc
         callId: String,
         phoneNumber: String,
         callerName: String,
-        hasVideo: Bool
-    ) -> Bool {
+        hasVideo: Bool,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
         let uuid = CallingxImpl.uuidStorage?.getUUID(forCid: callId)
         CallingxImpl.reportNewIncomingCall(
             callId: callId,
@@ -387,9 +416,10 @@ import stream_react_native_webrtc
             supportsDTMF: false,
             supportsGrouping: false,
             supportsUngrouping: false,
-            fromPushKit: false,
             payload: nil,
-            completion: nil
+            completion: nil,
+            resolve: resolve,
+            reject: reject
         )
         
         let wasAlreadyAnswered = uuid != nil
@@ -406,7 +436,6 @@ import stream_react_native_webrtc
                 }
             }
         }
-        return true
     }
     
     @objc public func endCall(_ callId: String) -> Bool {
@@ -414,25 +443,35 @@ import stream_react_native_webrtc
         print("[Callingx][endCall] callId = \(callId)")
         #endif
         
-        guard let uuid = CallingxImpl.uuidStorage?.getUUID(forCid: callId) else {
+        guard let call = CallingxImpl.uuidStorage?.getCall(forCid: callId) else {
             #if DEBUG
             print("[Callingx][endCall] callId not found")
             #endif
             return false
         }
         
-        isSelfEnded = true
-        let endCallAction = CXEndCallAction(call: uuid)
+        // Guard: already ended — prevent duplicate CXEndCallAction transactions
+        if call.hasEnded {
+            #if DEBUG
+            print("[Callingx][endCall] callId already ended, skipping")
+            #endif
+            return true
+        }
+        
+        call.markSelfEnded()
+        call.markEnded()
+        
+        let endCallAction = CXEndCallAction(call: call.uuid)
         let transaction = CXTransaction(action: endCallAction)
         
         requestTransaction(transaction)
         return true
     }
     
-    @objc public func isCallRegistered(_ callId: String) -> Bool {
+    @objc public func isCallTracked(_ callId: String) -> Bool {
         guard let uuid = CallingxImpl.uuidStorage?.getUUID(forCid: callId) else {
             #if DEBUG
-            print("[Callingx][isCallRegistered] callId not found")
+            print("[Callingx][isCallTracked] callId not found")
             #endif
             return false
         }
@@ -451,16 +490,18 @@ import stream_react_native_webrtc
         print("[Callingx][setCurrentCallActive] callId = \(callId)")
         #endif
       
-        guard let uuid = CallingxImpl.uuidStorage?.getUUID(forCid: callId) else {
+        guard let call = CallingxImpl.uuidStorage?.getCall(forCid: callId) else {
             #if DEBUG
             print("[Callingx][setCurrentCallActive] callId not found")
             #endif
             return false
         }
         
-        //consider to split this into to calls startedConnectingAt with startCall, connectedAt with setCurrentCallActive
-        callKeepProvider?.reportOutgoingCall(with: uuid, startedConnectingAt: Date())
-        callKeepProvider?.reportOutgoingCall(with: uuid, connectedAt: Date())
+        call.markConnected()
+        
+        // Report connected timestamp to CallKit.
+        // startedConnectingAt is reported separately in the CXStartCallAction delegate.
+        callKeepProvider?.reportOutgoingCall(with: call.uuid, connectedAt: call.connectedAt ?? Date())
         return true
     }
     
@@ -469,15 +510,15 @@ import stream_react_native_webrtc
         print("[Callingx][setMutedCall] muted = \(isMuted)")
         #endif
         
-        guard let uuid = CallingxImpl.uuidStorage?.getUUID(forCid: callId) else {
+        guard let call = CallingxImpl.uuidStorage?.getCall(forCid: callId) else {
             #if DEBUG
             print("[Callingx][setMutedCall] callId not found")
             #endif
             return false
         }
         
-        isSelfMuted = true
-        let setMutedAction = CXSetMutedCallAction(call: uuid, muted: isMuted)
+        call.markSelfMuted()
+        let setMutedAction = CXSetMutedCallAction(call: call.uuid, muted: isMuted)
         let transaction = CXTransaction()
         transaction.addAction(setMutedAction)
         
@@ -524,10 +565,12 @@ import stream_react_native_webrtc
           return
         }
         
+        let call = storage.getOrCreateCall(forCid: callId, isOutgoing: true)
+        call.markStartedConnecting() // outgoing: will be reported via reportOutgoingCall(startedConnectingAt:)
+        
         let handleType = Settings.getHandleType("generic")
-        let uuid = storage.getOrCreateUUID(forCid: callId)
         let callHandle = CXHandle(type: handleType, value: phoneNumber)
-        let startCallAction = CXStartCallAction(call: uuid, handle: callHandle)
+        let startCallAction = CXStartCallAction(call: call.uuid, handle: callHandle)
         startCallAction.isVideo = hasVideo
         startCallAction.contactIdentifier = callerName
         
@@ -568,7 +611,7 @@ import stream_react_native_webrtc
         print("[Callingx][CXProviderDelegate][provider:performStartCallAction]")
         #endif
         
-        guard let callId = CallingxImpl.uuidStorage?.getCid(forUUID: action.callUUID) else {    
+        guard let call = CallingxImpl.uuidStorage?.getCallByUUID(action.callUUID) else {
             #if DEBUG
             print("[Callingx][CXProviderDelegate][provider:performStartCallAction] callId not found")
             #endif
@@ -576,22 +619,23 @@ import stream_react_native_webrtc
             return
         }
         
+        getAudioDeviceModule()?.reset()
         AudioSessionManager.createAudioSessionIfNeeded()
         
         sendEvent(CallingxEvents.didReceiveStartCallAction, body: [
-            "callId": callId,
+            "callId": call.cid,
             "handle": action.handle.value
         ])
         
         action.fulfill()
+        
+        // Report startedConnectingAt to CallKit now that the action is fulfilled.
+        // The timestamp was set in startCall when the call was created.
+        callKeepProvider?.reportOutgoingCall(with: call.uuid, startedConnectingAt: call.startedConnectingAt ?? Date())
     }
     
     public func provider(_ provider: CXProvider, perform action: CXAnswerCallAction) {
-        #if DEBUG
-        print("[Callingx][CXProviderDelegate][provider:performAnswerCallAction] isSelfAnswered: \(isSelfAnswered)")
-        #endif
-        
-        guard let callId = CallingxImpl.uuidStorage?.getCid(forUUID: action.callUUID) else {
+        guard let call = CallingxImpl.uuidStorage?.getCallByUUID(action.callUUID) else {
             #if DEBUG
             print("[Callingx][CXProviderDelegate][provider:performAnswerCallAction] callId not found")
             #endif
@@ -599,24 +643,29 @@ import stream_react_native_webrtc
             return
         }
         
+        #if DEBUG
+        print("[Callingx][CXProviderDelegate][provider:performAnswerCallAction] isSelfAnswered: \(call.isSelfAnswered)")
+        #endif
+        
+        getAudioDeviceModule()?.reset()
         AudioSessionManager.createAudioSessionIfNeeded()
         
-        let source = isSelfAnswered ? "app" : "sys"
+        let source = call.isSelfAnswered ? "app" : "sys"
         sendEvent(CallingxEvents.performAnswerCallAction, body: [
-            "callId": callId,
+            "callId": call.cid,
             "source": source
         ])
         
-        isSelfAnswered = false
+        call.resetSelfAnswered()
+        call.markConnected() // incoming: call is now connected
+        // TODO: Use action.fulfill(withDateConnected: call.connectedAt ?? Date()) instead of bare
+        // action.fulfill() to give CallKit more accurate call duration tracking in the system call log.
+        // to be done with pending action fulfillment
         action.fulfill()
     }
     
     public func provider(_ provider: CXProvider, perform action: CXEndCallAction) {
-        #if DEBUG
-        print("[Callingx][CXProviderDelegate][provider:performEndCallAction] isSelfEnded: \(isSelfEnded)")
-        #endif
-        
-        guard let callId = CallingxImpl.uuidStorage?.getCid(forUUID: action.callUUID) else {
+        guard let call = CallingxImpl.uuidStorage?.getCallByUUID(action.callUUID) else {
             #if DEBUG
             print("[Callingx][CXProviderDelegate][provider:performEndCallAction] callId not found")
             #endif
@@ -624,14 +673,19 @@ import stream_react_native_webrtc
             return
         }
         
-        let source = isSelfEnded ? "app" : "sys"
+        #if DEBUG
+        print("[Callingx][CXProviderDelegate][provider:performEndCallAction] isSelfEnded: \(call.isSelfEnded)")
+        #endif
+        
+        let source = call.isSelfEnded ? "app" : "sys"
         sendEvent(CallingxEvents.performEndCallAction, body: [
-            "callId": callId,
+            "callId": call.cid,
             "source": source
         ])
         
-        isSelfEnded = false
-        CallingxImpl.uuidStorage?.removeCid(callId)
+        call.resetSelfEnded()
+        call.markEnded()
+        CallingxImpl.uuidStorage?.removeCid(call.cid)
         
         action.fulfill()
     }
@@ -658,14 +712,7 @@ import stream_react_native_webrtc
     }
     
     public func provider(_ provider: CXProvider, perform action: CXSetMutedCallAction) {
-        let isAppInitiated = isSelfMuted
-        isSelfMuted = false
-        
-        #if DEBUG
-        print("[Callingx][CXProviderDelegate][provider:performSetMutedCallAction] \(action.isMuted) isAppInitiated: \(isAppInitiated)")
-        #endif
-        
-        guard let callId = CallingxImpl.uuidStorage?.getCid(forUUID: action.callUUID) else {
+        guard let call = CallingxImpl.uuidStorage?.getCallByUUID(action.callUUID) else {
             #if DEBUG
             print("[Callingx][CXProviderDelegate][provider:performSetMutedCallAction] callId not found")
             #endif
@@ -673,6 +720,13 @@ import stream_react_native_webrtc
             return
         }
         
+        let isAppInitiated = call.isSelfMuted
+        call.resetSelfMuted()
+        
+        #if DEBUG
+        print("[Callingx][CXProviderDelegate][provider:performSetMutedCallAction] \(action.isMuted) isAppInitiated: \(isAppInitiated)")
+        #endif
+        
         // Only send the event to JS when the mute was initiated by the system
         // (e.g. user tapped mute on the native CallKit UI).
         // Skip app-initiated actions to prevent the feedback loop:
@@ -680,7 +734,7 @@ import stream_react_native_webrtc
         if !isAppInitiated {
             sendEvent(CallingxEvents.didPerformSetMutedCallAction, body: [
                 "muted": action.isMuted,
-                "callId": callId
+                "callId": call.cid
             ])
         }
         
@@ -731,6 +785,7 @@ import stream_react_native_webrtc
 
         // When CallKit deactivates the AVAudioSession, inform WebRTC as well.
         RTCAudioSession.sharedInstance().audioSessionDidDeactivate(audioSession)
+        getAudioDeviceModule()?.reset()
 
         // Disable wake lock when the call ends
         DispatchQueue.main.async {
@@ -753,5 +808,16 @@ import stream_react_native_webrtc
 
         sendEvent(CallingxEvents.providerReset, body: nil)
     }
+    
+    // MARK: - Helper Methods
+    private func getAudioDeviceModule() -> AudioDeviceModule? {
+        guard let adm = webRTCModule?.audioDeviceModule else {
+            #if DEBUG
+            print("[Callingx] WebRTCModule is not available. Ensure it was injected from the TurboModule host.")
+            #endif
+            return nil
+        }
+        return adm
+    }
 }
 

package/ios/CallingxPublic.h

@@ -21,9 +21,8 @@ NS_ASSUME_NONNULL_BEGIN
  *                    supportsDTMF:NO
  *                supportsGrouping:NO
  *              supportsUngrouping:NO
- *                     fromPushKit:YES
  *                         payload:payload
- *           withCompletionHandler:^{ }];
+ *           withCompletionHandler:^(void){ }];
  * ```
  */
 @interface Callingx : NSObject
@@ -41,9 +40,8 @@ NS_ASSUME_NONNULL_BEGIN
  * @param supportsDTMF Whether the call supports DTMF tones
  * @param supportsGrouping Whether the call can be grouped with other calls
  * @param supportsUngrouping Whether the call can be ungrouped
- * @param fromPushKit Whether this call is from a PushKit notification
  * @param payload Optional payload data from the push notification
- * @param completion Completion handler called after the call is reported
+ * @param completion Completion handler called after the call is reported, with an error if the call could not be displayed
  */
 + (void)reportNewIncomingCall:(NSString *)callId
                        handle:(NSString *)handle
@@ -54,7 +52,6 @@ NS_ASSUME_NONNULL_BEGIN
                  supportsDTMF:(BOOL)supportsDTMF
              supportsGrouping:(BOOL)supportsGrouping
            supportsUngrouping:(BOOL)supportsUngrouping
-                  fromPushKit:(BOOL)fromPushKit
                       payload:(NSDictionary * _Nullable)payload
         withCompletionHandler:(void (^_Nullable)(void))completion;
 

package/ios/UUIDStorage.swift

@@ -1,34 +1,78 @@
 import Foundation
 
 @objcMembers public class UUIDStorage: NSObject {
-    private var uuidDict: [String: String] = [:]
-    private var cidDict: [String: String] = [:]
+    /// Primary storage: cid -> CallingxCall
+    private var callsByCid: [String: CallingxCall] = [:]
+    /// Reverse lookup: lowercased UUID string -> CallingxCall
+    private var callsByUUID: [String: CallingxCall] = [:]
     private let queue = DispatchQueue(label: "com.stream.uuidstorage", attributes: [])
 
     public override init() {
         super.init()
     }
 
+    // MARK: - CallingxCall-based API (new)
+
+    /// Returns the existing call for the given cid, or creates a new one.
+    public func getOrCreateCall(forCid cid: String, isOutgoing: Bool = false) -> CallingxCall {
+        return queue.sync {
+            if let existing = callsByCid[cid] {
+                #if DEBUG
+                print("[UUIDStorage] getOrCreateCall: found existing \(existing)")
+                #endif
+                return existing
+            }
+
+            let uuid = UUID()
+            let call = CallingxCall(uuid: uuid, cid: cid, isOutgoing: isOutgoing)
+            let uuidString = uuid.uuidString.lowercased()
+            callsByCid[cid] = call
+            callsByUUID[uuidString] = call
+            #if DEBUG
+            print("[UUIDStorage] getOrCreateCall: created \(call)")
+            #endif
+            return call
+        }
+    }
+
+    /// Returns the call for the given cid, or nil if not found.
+    public func getCall(forCid cid: String) -> CallingxCall? {
+        return queue.sync {
+            return callsByCid[cid]
+        }
+    }
+
+    /// Returns the call for the given UUID, or nil if not found.
+    public func getCallByUUID(_ uuid: UUID) -> CallingxCall? {
+        return queue.sync {
+            let uuidString = uuid.uuidString.lowercased()
+            return callsByUUID[uuidString]
+        }
+    }
+
+    // MARK: - Legacy API (preserved for backward compatibility)
+
     public func allUUIDs() -> [UUID] {
         return queue.sync {
-            return uuidDict.values.compactMap { UUID(uuidString: $0.lowercased()) }
+            return callsByCid.values.map { $0.uuid }
         }
     }
 
+    /// Returns the existing UUID for the given cid, or creates a new CallingxCall and returns its UUID.
     public func getOrCreateUUID(forCid cid: String) -> UUID {
         return queue.sync {
-            // Check if cid exists (inlined to avoid nested sync call)
-            if let existingUUID = uuidDict[cid] {
+            if let existing = callsByCid[cid] {
                 #if DEBUG
-                print("[UUIDStorage] getUUIDForCid: found existing UUID \(existingUUID) for cid \(cid)")
+                print("[UUIDStorage] getUUIDForCid: found existing UUID \(existing.uuid.uuidString.lowercased()) for cid \(cid)")
                 #endif
-                return UUID(uuidString: existingUUID) ?? UUID()
+                return existing.uuid
             }
 
             let uuid = UUID()
+            let call = CallingxCall(uuid: uuid, cid: cid, isOutgoing: false)
             let uuidString = uuid.uuidString.lowercased()
-            uuidDict[cid] = uuidString
-            cidDict[uuidString] = cid
+            callsByCid[cid] = call
+            callsByUUID[uuidString] = call
             #if DEBUG
             print("[UUIDStorage] getUUIDForCid: created new UUID \(uuidString) for cid \(cid)")
             #endif
@@ -38,15 +82,14 @@ import Foundation
 
     public func getUUID(forCid cid: String) -> UUID? {
         return queue.sync {
-            guard let uuidString = uuidDict[cid] else { return nil }
-            return UUID(uuidString: uuidString)
+            return callsByCid[cid]?.uuid
         }
     }
 
     public func getCid(forUUID uuid: UUID) -> String? {
         return queue.sync {
             let uuidString = uuid.uuidString.lowercased()
-            let cid = cidDict[uuidString]
+            let cid = callsByUUID[uuidString]?.cid
             #if DEBUG
             print("[UUIDStorage] getCidForUUID: UUID \(uuidString) -> cid \(cid ?? "(not found)")")
             #endif
@@ -57,11 +100,11 @@ import Foundation
     public func removeCid(forUUID uuid: UUID) {
         queue.sync {
             let uuidString = uuid.uuidString.lowercased()
-            if let cid = cidDict[uuidString] {
-                uuidDict.removeValue(forKey: cid)
-                cidDict.removeValue(forKey: uuidString)
+            if let call = callsByUUID[uuidString] {
+                callsByCid.removeValue(forKey: call.cid)
+                callsByUUID.removeValue(forKey: uuidString)
                 #if DEBUG
-                print("[UUIDStorage] removeCidForUUID: removed cid \(cid) for UUID \(uuidString)")
+                print("[UUIDStorage] removeCidForUUID: removed cid \(call.cid) for UUID \(uuidString)")
                 #endif
             } else {
                 #if DEBUG
@@ -73,9 +116,10 @@ import Foundation
 
     public func removeCid(_ cid: String) {
         queue.sync {
-            if let uuidString = uuidDict[cid] {
-                cidDict.removeValue(forKey: uuidString)
-                uuidDict.removeValue(forKey: cid)
+            if let call = callsByCid[cid] {
+                let uuidString = call.uuid.uuidString.lowercased()
+                callsByUUID.removeValue(forKey: uuidString)
+                callsByCid.removeValue(forKey: cid)
                 #if DEBUG
                 print("[UUIDStorage] removeCid: removed cid \(cid) with UUID \(uuidString)")
                 #endif
@@ -89,9 +133,9 @@ import Foundation
 
     public func removeAllObjects() {
         queue.sync {
-            let count = uuidDict.count
-            uuidDict.removeAll()
-            cidDict.removeAll()
+            let count = callsByCid.count
+            callsByCid.removeAll()
+            callsByUUID.removeAll()
             #if DEBUG
             print("[UUIDStorage] removeAllObjects: cleared \(count) entries")
             #endif
@@ -100,25 +144,26 @@ import Foundation
 
     public func count() -> Int {
         return queue.sync {
-            return uuidDict.count
+            return callsByCid.count
         }
     }
 
     public func containsCid(_ cid: String) -> Bool {
         return queue.sync {
-            return uuidDict[cid] != nil
+            return callsByCid[cid] != nil
         }
     }
 
     public func containsUUID(_ uuid: UUID) -> Bool {
         return queue.sync {
-            return cidDict[uuid.uuidString.lowercased()] != nil
+            return callsByUUID[uuid.uuidString.lowercased()] != nil
         }
     }
 
     public override var description: String {
         return queue.sync {
-            return "UUIDStorage: \(uuidDict)"
+            let entries = callsByCid.map { "\($0.key): \($0.value)" }.joined(separator: ", ")
+            return "UUIDStorage: [\(entries)]"
         }
     }
 }