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

package/ios/Callingx.mm

@@ -3,6 +3,7 @@
 
 #import <AVFoundation/AVAudioSession.h>
 #import <CallKit/CallKit.h>
+#import "WebRTCModule.h"
 
 // Import Swift generated header
 #if __has_include("Callingx-Swift.h")
@@ -54,7 +55,6 @@
                  supportsDTMF:(BOOL)supportsDTMF
              supportsGrouping:(BOOL)supportsGrouping
            supportsUngrouping:(BOOL)supportsUngrouping
-                  fromPushKit:(BOOL)fromPushKit
                       payload:(NSDictionary *_Nullable)payload
         withCompletionHandler:(void (^_Nullable)(void))completion {
   
@@ -67,9 +67,11 @@
                                    supportsDTMF:supportsDTMF
                                supportsGrouping:supportsGrouping
                              supportsUngrouping:supportsUngrouping
-                                    fromPushKit:fromPushKit
                                         payload:payload
-                                     completion:completion];
+                                     completion:completion
+                                        resolve:nil
+                                         reject:nil
+  ];
 }
 
 + (BOOL)canRegisterCall {
@@ -127,6 +129,12 @@
   
   [_moduleImpl setupWithOptions:optionsDict];
   
+  // Inject WebRTCModule so CallingxImpl can access AudioDeviceModule.
+  // self.bridge is NOT available on TurboModules — use currentBridge instead,
+  // which returns the real RCTBridge or RCTBridgeProxy (bridgeless interop).
+  WebRTCModule *webrtcModule = [[RCTBridge currentBridge] moduleForName:@"WebRTCModule"];
+  _moduleImpl.webRTCModule = webrtcModule;
+  
   self.callKeepCallController = _moduleImpl.callKeepCallController;
   self.callKeepProvider = _moduleImpl.callKeepProvider;
 }
@@ -161,11 +169,13 @@
              displayOptions:(JS::NativeCallingx::SpecDisplayIncomingCallDisplayOptions &)displayOptions
                     resolve:(nonnull RCTPromiseResolveBlock)resolve
                      reject:(nonnull RCTPromiseRejectBlock)reject {
-  BOOL result = [_moduleImpl displayIncomingCallWithCallId:callId
-                                         phoneNumber:phoneNumber
-                                          callerName:callerName
-                                            hasVideo:hasVideo];
-  resolve(@(result));
+  [_moduleImpl displayIncomingCallWithCallId:callId
+                                 phoneNumber:phoneNumber
+                                  callerName:callerName
+                                    hasVideo:hasVideo
+                                     resolve:resolve
+                                      reject:reject
+  ];
 }
 
 - (void)endCallWithReason:(nonnull NSString *)callId
@@ -183,8 +193,8 @@
   resolve(@(result));
 }
 
-- (NSNumber *)isCallRegistered:(nonnull NSString *)callId {
-  return @([_moduleImpl isCallRegistered:callId]);
+- (NSNumber *)isCallTracked:(nonnull NSString *)callId {
+  return @([_moduleImpl isCallTracked:callId]);
 }
 
 - (NSNumber *)hasRegisteredCall {

package/ios/CallingxCall.swift

@@ -0,0 +1,105 @@
+import Foundation
+
+/// Represents a call tracked by the CallingxImpl module.
+/// Holds per-call lifecycle state to guard against duplicate actions
+/// and to track timestamps for CallKit reporting.
+@objcMembers public class CallingxCall: NSObject {
+    public let uuid: UUID
+    public let cid: String
+    public let isOutgoing: Bool
+
+    // MARK: - Action-source flags
+    // These flags track whether an action was initiated from the app (vs system UI).
+    // They follow a "set-then-read-then-reset" pattern in the CXProviderDelegate methods
+    // to determine the event source ("app" vs "sys") before being reset.
+
+    /// Whether answerIncomingCall was initiated from the app (vs system UI)
+    public private(set) var isSelfAnswered: Bool = false
+    /// Whether endCall was initiated from the app (vs system UI)
+    public private(set) var isSelfEnded: Bool = false
+    /// Whether setMutedCall was initiated from the app (vs system UI)
+    public private(set) var isSelfMuted: Bool = false
+
+    // MARK: - Lifecycle timestamps
+
+    /// When the call started connecting (outgoing: maps to reportOutgoingCall(startedConnectingAt:);
+    /// incoming: set when answerIncomingCall is called, internal-only)
+    public private(set) var startedConnectingAt: Date?
+    /// When the call became connected (outgoing: maps to reportOutgoingCall(connectedAt:);
+    /// incoming: set when CXAnswerCallAction delegate fires, internal-only)
+    public private(set) var connectedAt: Date?
+    /// When the call ended
+    public private(set) var endedAt: Date?
+
+    // MARK: - Derived states
+
+    public var hasStartedConnecting: Bool { startedConnectingAt != nil }
+    public var isConnected: Bool { connectedAt != nil }
+    public var hasEnded: Bool { endedAt != nil }
+    /// Whether the call has been answered (incoming) or started connecting (outgoing).
+    /// Checks both startedConnectingAt (set by answerIncomingCall from app) and connectedAt
+    /// (set by CXAnswerCallAction delegate, which fires even when answered from system UI).
+    /// Used as the primary guard against duplicate answerIncomingCall invocations.
+    public var isAnswered: Bool { startedConnectingAt != nil || connectedAt != nil }
+
+    // MARK: - Initialization
+
+    public init(uuid: UUID, cid: String, isOutgoing: Bool = false) {
+        self.uuid = uuid
+        self.cid = cid
+        self.isOutgoing = isOutgoing
+    }
+
+    // MARK: - Action-source flag methods
+
+    public func markSelfAnswered() { isSelfAnswered = true }
+    public func markSelfEnded() { isSelfEnded = true }
+    public func markSelfMuted() { isSelfMuted = true }
+
+    public func resetSelfAnswered() { isSelfAnswered = false }
+    public func resetSelfEnded() { isSelfEnded = false }
+    public func resetSelfMuted() { isSelfMuted = false }
+
+    /// Resets all action-source flags. Called when a CXTransaction fails.
+    public func resetAllSelfFlags() {
+        isSelfAnswered = false
+        isSelfEnded = false
+        isSelfMuted = false
+    }
+
+    // MARK: - Lifecycle transition methods
+
+    public func markStartedConnecting() {
+        if startedConnectingAt == nil {
+            startedConnectingAt = Date()
+        }
+    }
+
+    public func markConnected() {
+        if connectedAt == nil {
+            connectedAt = Date()
+        }
+    }
+
+    public func markEnded() {
+        if endedAt == nil {
+            endedAt = Date()
+        }
+    }
+
+    // MARK: - Debug description
+
+    public override var description: String {
+        let state: String
+        if hasEnded {
+            state = "ended"
+        } else if isConnected {
+            state = "connected"
+        } else if hasStartedConnecting {
+            state = "connecting"
+        } else {
+            state = "ringing"
+        }
+        return "CallingxCall(cid: \(cid), uuid: \(uuid.uuidString.lowercased()), outgoing: \(isOutgoing), state: \(state))"
+    }
+}

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;