@stream-io/react-native-callingx 0.3.1 → 0.5.0

package/ios/CallingxLog.swift

@@ -0,0 +1,67 @@
+import Foundation
+import os
+
+/// Unified-logging namespace for the Callingx package.
+///
+/// Replaces the previous `NSLog` usage. Each category maps to one of the
+/// `[Tag]` prefixes that used to be hand-built into the log strings, so logs
+/// can be filtered by subsystem/category in Console.app or `log stream`:
+///
+///     log stream --predicate 'subsystem == "io.getstream.callingx"' --level debug
+///
+/// The subsystem matches the queue-label convention already used across this
+/// package (e.g. `io.getstream.callingx.pendingActions`).
+enum CallingxLog {
+    private static let subsystem = "io.getstream.callingx"
+
+    static let core = Logger(subsystem: subsystem, category: "Callingx")
+    static let uuid = Logger(subsystem: subsystem, category: "UUIDStorage")
+    static let voip = Logger(subsystem: subsystem, category: "VoipNotifications")
+    static let push = Logger(subsystem: subsystem, category: "VoipPush")
+    static let settings = Logger(subsystem: subsystem, category: "Settings")
+    static let audio = Logger(subsystem: subsystem, category: "AudioSession")
+    static let js = Logger(subsystem: subsystem, category: "JS")
+}
+
+extension Logger {
+    /// Logs a pre-built message at `.debug`, marking the whole string public so
+    /// values stay readable when streaming logs (incl. release/TestFlight).
+    /// `@autoclosure` keeps construction lazy: when the log is not being
+    /// collected the string is never built.
+    func debugPublic(_ message: @autoclosure @escaping () -> String) {
+        debug("\(message(), privacy: .public)")
+    }
+
+    /// Public-message variant at `.error` (persisted by default in the unified log).
+    func errorPublic(_ message: @autoclosure @escaping () -> String) {
+        error("\(message(), privacy: .public)")
+    }
+}
+
+/// Objective-C bridge so `Callingx.mm` and `VoipPushHandler.m` log through the
+/// same `os.Logger` path. `Logger`'s interpolation API is Swift-only, hence the
+/// thin `@objc` wrapper.
+@objc public final class CallingxLogBridge: NSObject {
+    @objc public static func pushDebug(_ message: String) {
+        CallingxLog.push.debugPublic(message)
+    }
+
+    @objc public static func pushError(_ message: String) {
+        CallingxLog.push.errorPublic(message)
+    }
+
+    /// Routes JS-originated logs (from the `log(message, level)` TurboModule
+    /// method) to the matching os.Logger severity.
+    @objc public static func js(_ message: String, level: String) {
+        switch level {
+        case "error":
+            CallingxLog.js.error("\(message, privacy: .public)")
+        case "warn":
+            CallingxLog.js.warning("\(message, privacy: .public)")
+        case "info":
+            CallingxLog.js.info("\(message, privacy: .public)")
+        default:
+            CallingxLog.js.debug("\(message, privacy: .public)")
+        }
+    }
+}

package/ios/CallingxSessionOwnership.swift

@@ -0,0 +1,37 @@
+import Foundation
+
+/// Cross-package handoff guard. `CallingxImpl` flips `callingxOwnsSession`
+/// to `true` at CX-action entry points (`CXStartCallAction.perform`,
+/// `CXAnswerCallAction.perform`, re-asserted in `provider(_:didActivate:)`)
+/// and back to `false` in `provider(_:didDeactivate:)` when no calls remain
+/// (`UUIDStorage.count() == 0`) or on `providerDidReset`.
+///
+/// `StreamInCallManager` (in `@stream-io/video-react-native-sdk`) consults this
+/// flag from its AudioDeviceModule publisher sink and no-ops when callingx owns
+/// the session, so the two packages don't write conflicting `AVAudioSession`
+/// configurations during the transient overlap when a CallKit call is winding
+/// down and the SDK is about to take over (or vice versa).
+///
+/// Exposed as an `@objcMembers NSObject` with an `@objc class var` so that
+/// react-native-sdk can read it via `NSClassFromString("Callingx.CallingxSessionOwnership")`
+/// + KVC on the class object — `@stream-io/react-native-callingx` is an *optional*
+/// peer dependency of react-native-sdk, so a direct `import Callingx` is not safe.
+@objcMembers
+public class CallingxSessionOwnership: NSObject {
+
+    private static let lock = NSLock()
+    private static var _callingxOwnsSession: Bool = false
+
+    @objc public class var callingxOwnsSession: Bool {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
+            return _callingxOwnsSession
+        }
+        set {
+            lock.lock()
+            defer { lock.unlock() }
+            _callingxOwnsSession = newValue
+        }
+    }
+}

package/ios/Settings.swift

@@ -10,9 +10,7 @@ import UIKit
     }
 
     public static func setSettings(_ options: [String: Any]?) {
-        #if DEBUG
-        NSLog("%@","[Settings][setSettings] options = \(String(describing: options))")
-        #endif
+        CallingxLog.settings.debugPublic("[setSettings] options = \(String(describing: options))")
 
         var settings: [String: Any] = getSettings()
 
@@ -45,9 +43,7 @@ import UIKit
     }
 
     public static func getProviderConfiguration() -> CXProviderConfiguration {
-        #if DEBUG
-        NSLog("%@","[Settings][getProviderConfiguration]")
-        #endif
+        CallingxLog.settings.debugPublic("[getProviderConfiguration]")
       
         let settings = getSettings()
         let providerConfiguration = CXProviderConfiguration()

package/ios/UUIDStorage.swift

@@ -17,9 +17,7 @@ import Foundation
     public func getOrCreateCall(forCid cid: String, isOutgoing: Bool = false) -> CallingxCall {
         return queue.sync {
             if let existing = callsByCid[cid] {
-                #if DEBUG
-                NSLog("%@","[UUIDStorage] getOrCreateCall: found existing \(existing)")
-                #endif
+                CallingxLog.uuid.debugPublic("getOrCreateCall: found existing \(existing)")
                 return existing
             }
 
@@ -28,9 +26,7 @@ import Foundation
             let uuidString = uuid.uuidString.lowercased()
             callsByCid[cid] = call
             callsByUUID[uuidString] = call
-            #if DEBUG
-            NSLog("%@","[UUIDStorage] getOrCreateCall: created \(call)")
-            #endif
+            CallingxLog.uuid.debugPublic("getOrCreateCall: created \(call)")
             return call
         }
     }
@@ -62,9 +58,7 @@ import Foundation
     public func getOrCreateUUID(forCid cid: String) -> UUID {
         return queue.sync {
             if let existing = callsByCid[cid] {
-                #if DEBUG
-                NSLog("%@","[UUIDStorage] getUUIDForCid: found existing UUID \(existing.uuid.uuidString.lowercased()) for cid \(cid)")
-                #endif
+                CallingxLog.uuid.debugPublic("getUUIDForCid: found existing UUID \(existing.uuid.uuidString.lowercased()) for cid \(cid)")
                 return existing.uuid
             }
 
@@ -73,9 +67,7 @@ import Foundation
             let uuidString = uuid.uuidString.lowercased()
             callsByCid[cid] = call
             callsByUUID[uuidString] = call
-            #if DEBUG
-            NSLog("%@","[UUIDStorage] getUUIDForCid: created new UUID \(uuidString) for cid \(cid)")
-            #endif
+            CallingxLog.uuid.debugPublic("getUUIDForCid: created new UUID \(uuidString) for cid \(cid)")
             return uuid
         }
     }
@@ -90,9 +82,7 @@ import Foundation
         return queue.sync {
             let uuidString = uuid.uuidString.lowercased()
             let cid = callsByUUID[uuidString]?.cid
-            #if DEBUG
-            NSLog("%@","[UUIDStorage] getCidForUUID: UUID \(uuidString) -> cid \(cid ?? "(not found)")")
-            #endif
+            CallingxLog.uuid.debugPublic("getCidForUUID: UUID \(uuidString) -> cid \(cid ?? "(not found)")")
             return cid
         }
     }
@@ -103,13 +93,9 @@ import Foundation
             if let call = callsByUUID[uuidString] {
                 callsByCid.removeValue(forKey: call.cid)
                 callsByUUID.removeValue(forKey: uuidString)
-                #if DEBUG
-                NSLog("%@","[UUIDStorage] removeCidForUUID: removed cid \(call.cid) for UUID \(uuidString)")
-                #endif
+                CallingxLog.uuid.debugPublic("removeCidForUUID: removed cid \(call.cid) for UUID \(uuidString)")
             } else {
-                #if DEBUG
-                NSLog("%@","[UUIDStorage] removeCidForUUID: no cid found for UUID \(uuidString)")
-                #endif
+                CallingxLog.uuid.debugPublic("removeCidForUUID: no cid found for UUID \(uuidString)")
             }
         }
     }
@@ -120,13 +106,9 @@ import Foundation
                 let uuidString = call.uuid.uuidString.lowercased()
                 callsByUUID.removeValue(forKey: uuidString)
                 callsByCid.removeValue(forKey: cid)
-                #if DEBUG
-                NSLog("%@","[UUIDStorage] removeCid: removed cid \(cid) with UUID \(uuidString)")
-                #endif
+                CallingxLog.uuid.debugPublic("removeCid: removed cid \(cid) with UUID \(uuidString)")
             } else {
-                #if DEBUG
-                NSLog("%@","[UUIDStorage] removeCid: no UUID found for cid \(cid)")
-                #endif
+                CallingxLog.uuid.debugPublic("removeCid: no UUID found for cid \(cid)")
             }
         }
     }
@@ -136,9 +118,7 @@ import Foundation
             let count = callsByCid.count
             callsByCid.removeAll()
             callsByUUID.removeAll()
-            #if DEBUG
-            NSLog("%@","[UUIDStorage] removeAllObjects: cleared \(count) entries")
-            #endif
+            CallingxLog.uuid.debugPublic("removeAllObjects: cleared \(count) entries")
         }
     }
 

package/ios/VoipNotificationsManager.swift

@@ -20,7 +20,7 @@ typealias RNVoipPushNotificationCompletion = () -> Void
     private static var isVoipRegistered = false
     private static var lastVoipToken = ""
     private static var voipRegistry: PKPushRegistry?
-    
+
     private var canSendEvents: Bool = false
     private var delayedEvents: [[String:Any]] = []
     
@@ -55,41 +55,26 @@ typealias RNVoipPushNotificationCompletion = () -> Void
     
     @objc public static func voipRegistration() {
         if isVoipRegistered {
-            #if DEBUG
-            NSLog("%@","[VoipNotificationsManager] voipRegistration is already registered. return _lastVoipToken = \(lastVoipToken)")
-            #endif
+            CallingxLog.voip.debugPublic("voipRegistration is already registered. return _lastVoipToken = \(lastVoipToken)")
             let voipPushManager = VoipNotificationsManager.shared()
             voipPushManager.sendEventWithNameWrapper(name: VoipNotificationsEvents.registered, body: ["token": lastVoipToken])
-        } else {
-            #if DEBUG
-            NSLog("%@","[VoipNotificationsManager] voipRegistration enter")
-            #endif
-            DispatchQueue.main.async {
-                let voipRegistry = PKPushRegistry(queue: DispatchQueue.main)
-                // Set the registry's delegate to AppDelegate
-                // Note: The original code casts the delegate, but this should be handled by AppDelegate
-                if let appDelegate = RCTSharedApplication()?.delegate as? PKPushRegistryDelegate {
-                    voipRegistry.delegate = appDelegate
-                    // Set the push type to VoIP
-                    // Store the registry to prevent deallocation
-                    voipRegistry.desiredPushTypes = [.voIP]
-                    VoipNotificationsManager.voipRegistry = voipRegistry
-                    
-                    isVoipRegistered = true
-                } else {
-                    #if DEBUG
-                    NSLog("%@","[VoipNotificationsManager] voipRegistration appDelegate not found. return")
-                    #endif
-                }
-            }
+            return
+        }
+
+        CallingxLog.voip.debugPublic("voipRegistration enter")
+
+        DispatchQueue.main.async {
+            let registry = PKPushRegistry(queue: DispatchQueue.main)
+            registry.delegate = VoipPushHandler.sharedInstance()
+            registry.desiredPushTypes = [.voIP]
+            VoipNotificationsManager.voipRegistry = registry
+            isVoipRegistered = true
         }
     }
     
     @objc public static func didUpdatePushCredentials(_ credentials: PKPushCredentials, forType type: String) {
-        #if DEBUG
-        NSLog("%@","[VoipNotificationsManager] didUpdatePushCredentials credentials.token = \(credentials.token), type = \(type)")
-        #endif
-        
+        CallingxLog.voip.debug("didUpdatePushCredentials credentials.token = \(credentials.token, privacy: .private), type = \(type, privacy: .public)")
+
         let voipTokenLength = credentials.token.count
         if voipTokenLength == 0 {
             return
@@ -102,10 +87,8 @@ typealias RNVoipPushNotificationCompletion = () -> Void
     }
     
     @objc public static func didReceiveIncomingPushWithPayload(_ payload: PKPushPayload, forType type: String) {
-        #if DEBUG
-        NSLog("%@","[VoipNotificationsManager] didReceiveIncomingPushWithPayload payload.dictionaryPayload = \(payload.dictionaryPayload), type = \(type)")
-        #endif
-        
+        CallingxLog.voip.debug("didReceiveIncomingPushWithPayload payload.dictionaryPayload = \(payload.dictionaryPayload, privacy: .private), type = \(type, privacy: .public)")
+
         let dictionaryPayload: [String: Any] = Dictionary(uniqueKeysWithValues: payload.dictionaryPayload.map { (key, value) in
             (String(describing: key), value)
         })
@@ -118,9 +101,7 @@ typealias RNVoipPushNotificationCompletion = () -> Void
     @objc public func getInitialEvents() -> [[String: Any]] {
         var events: [[String: Any]] = []
         let action = {
-            #if DEBUG
-            NSLog("%@","[VoipNotificationsManager][getInitialEvents] delayedEvents = \(self.delayedEvents)")
-            #endif
+            CallingxLog.voip.debugPublic("[getInitialEvents] delayedEvents = \(self.delayedEvents)")
             
             events = self.delayedEvents
             self.delayedEvents = []
@@ -147,9 +128,7 @@ typealias RNVoipPushNotificationCompletion = () -> Void
     }
 
     private func sendEventWithNameWrapper(name: String, body: [String: Any]?) {
-        #if DEBUG
-        NSLog("%@","[VoipNotificationsManager] sendEventWithNameWrapper: \(name)")
-        #endif
+        CallingxLog.voip.debugPublic("sendEventWithNameWrapper: \(name)")
         
         let sendEventAction = {
             var dictionary: [String: Any] = ["eventName": name]
@@ -161,9 +140,7 @@ typealias RNVoipPushNotificationCompletion = () -> Void
                 self.eventEmitter?.emitVoipEvent(dictionary)
             } else {
                 self.delayedEvents.append(dictionary)
-                #if DEBUG
-                NSLog("%@","[VoipNotificationsManager] delayedEvents: \(self.delayedEvents)")
-                #endif
+                CallingxLog.voip.debugPublic("delayedEvents: \(self.delayedEvents)")
             }
         }
 

package/ios/VoipPushHandler.h

@@ -0,0 +1,29 @@
+#import <Foundation/Foundation.h>
+#import <PushKit/PushKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface VoipPushHandler : NSObject <PKPushRegistryDelegate>
+
++ (instancetype)sharedInstance;
+
+/** Handles a legacy `pushRegistry:didReceiveIncomingPushWithPayload:forType:withCompletionHandler:` callback. */
++ (void)handleIncomingPush:(PKPushPayload *)payload
+                   forType:(NSString *)type
+         completionHandler:(void (^_Nullable)(void))completion;
+
+/**
+ * Handles an iOS 26.4+ `pushRegistry:didReceiveIncomingVoIPPushWithPayload:metadata:withCompletionHandler:`
+ * callback. Gated behind `__IPHONE_26_4` because `PKVoIPPushMetadata` only
+ * exists in the iOS 26.4 SDK; on older Xcode this declaration is omitted and
+ * PushKit dispatches to the legacy `handleIncomingPush:forType:` path instead.
+ */
+#ifdef __IPHONE_26_4
++ (void)handleIncomingVoIPPush:(PKPushPayload *)payload
+                      metadata:(PKVoIPPushMetadata * _Nullable)metadata
+             completionHandler:(void (^_Nullable)(void))completion API_AVAILABLE(ios(26.4));
+#endif
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/VoipPushHandler.m

@@ -0,0 +1,195 @@
+#import "VoipPushHandler.h"
+#import "CallingxPublic.h"
+#import <UIKit/UIKit.h>
+
+// Import Swift generated header for VoipNotificationsManager
+#if __has_include("Callingx-Swift.h")
+#import "Callingx-Swift.h"
+#else
+#import <Callingx/Callingx-Swift.h>
+#endif
+
+static NSString *const DEFAULT_DISPLAY_NAME = @"Unknown Caller";
+
+@interface Callingx (VoipPushHandlerInternal)
++ (BOOL)shouldSkipIncomingPushInForeground;
+@end
+
+#pragma mark - Helpers
+
+// applicationState must be read on the main thread (PushKit delivers on
+// main, so the common path skips dispatch). Treat Inactive as foreground:
+// covers brief transitions and system overlays.
+static BOOL isAppInForeground(void) {
+    __block UIApplicationState state = UIApplicationStateActive;
+    void (^readState)(void) = ^{
+        state = [UIApplication sharedApplication].applicationState;
+    };
+    if ([NSThread isMainThread]) {
+        readState();
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), readState);
+    }
+    return state != UIApplicationStateBackground;
+}
+
+// Extracts CallKit-display fields from the Stream payload and reports the
+// incoming call via Callingx.
+static void reportIncomingCallFromStreamPayload(NSDictionary *streamPayload,
+                                                void (^_Nullable completion)(void)) {
+    NSString *callCid = streamPayload[@"call_cid"];
+    NSString *callDisplayName = streamPayload[@"call_display_name"];
+    NSString *createdByDisplayName = streamPayload[@"created_by_display_name"];
+    NSString *createdCallerName = callDisplayName.length > 0 ? callDisplayName : createdByDisplayName;
+    NSString *localizedCallerName = createdCallerName.length > 0 ? createdCallerName : DEFAULT_DISPLAY_NAME;
+    NSString *createdById = streamPayload[@"created_by_id"];
+    NSString *handle = createdById.length > 0 ? createdById : localizedCallerName;
+    NSString *videoIncluded = streamPayload[@"video"];
+    BOOL hasVideo = [videoIncluded isEqualToString:@"false"] ? NO : YES;
+
+    [Callingx reportNewIncomingCall:callCid
+                             handle:handle
+                         handleType:@"generic"
+                           hasVideo:hasVideo
+                localizedCallerName:localizedCallerName
+                    supportsHolding:NO
+                       supportsDTMF:NO
+                   supportsGrouping:NO
+                 supportsUngrouping:NO
+                            payload:streamPayload
+              withCompletionHandler:completion];
+}
+
+#pragma mark - Implementation
+
+@implementation VoipPushHandler
+
++ (instancetype)sharedInstance {
+    static VoipPushHandler *instance;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[self alloc] init];
+    });
+    return instance;
+}
+
+#pragma mark - Static orchestration
+
++ (void)handleIncomingPush:(PKPushPayload *)payload
+                   forType:(NSString *)type
+         completionHandler:(void (^_Nullable)(void))completion {
+    NSDictionary *streamPayload = payload.dictionaryPayload[@"stream"];
+    if (!streamPayload) {
+        [CallingxLogBridge pushError:@"[handleIncomingPush] Stream payload not found"];
+        if (completion) {
+            completion();
+        }
+        return;
+    }
+
+    NSString *callCid = streamPayload[@"call_cid"];
+    if (!callCid) {
+        [CallingxLogBridge pushError:@"[handleIncomingPush] Missing required field: call_cid"];
+        if (completion) {
+            completion();
+        }
+        return;
+    }
+
+    if (![Callingx canRegisterCall]) {
+        if (completion) {
+            completion();
+        }
+        return;
+    }
+
+    reportIncomingCallFromStreamPayload(streamPayload, completion);
+    [VoipNotificationsManager didReceiveIncomingPushWithPayload:payload forType:type];
+}
+
+#pragma mark - PKPushRegistryDelegate (managed mode)
+
+- (void)pushRegistry:(PKPushRegistry *)registry
+   didUpdatePushCredentials:(PKPushCredentials *)credentials
+                    forType:(PKPushType)type {
+    [VoipNotificationsManager didUpdatePushCredentials:credentials forType:(NSString *)type];
+}
+
+- (void)pushRegistry:(PKPushRegistry *)registry
+   didReceiveIncomingPushWithPayload:(PKPushPayload *)payload
+                             forType:(PKPushType)type
+               withCompletionHandler:(void (^)(void))completion {
+    [VoipPushHandler handleIncomingPush:payload
+                                forType:(NSString *)type
+                      completionHandler:completion];
+    [CallingxLogBridge pushDebug:@"[pushRegistry:didReceiveIncomingPushWithPayload:forType:withCompletionHandler:] completion"];
+}
+
+#ifdef __IPHONE_26_4
++ (void)handleIncomingVoIPPush:(PKPushPayload *)payload
+                      metadata:(PKVoIPPushMetadata * _Nullable)metadata
+             completionHandler:(void (^_Nullable)(void))completion {
+    NSDictionary *streamPayload = payload.dictionaryPayload[@"stream"];
+    if (!streamPayload) {
+        [CallingxLogBridge pushError:@"[handleIncomingVoIPPush] Stream payload not found"];
+        if (completion) {
+            completion();
+        }
+        return;
+    }
+
+    NSString *callCid = streamPayload[@"call_cid"];
+    if (!callCid) {
+        [CallingxLogBridge pushError:@"[handleIncomingVoIPPush] Missing required field: call_cid"];
+        if (completion) {
+            completion();
+        }
+        return;
+    }
+
+    NSString *type = @"PKPushTypeVoIP";
+    BOOL mustReport = metadata ? metadata.mustReport : YES;
+
+    // Both skip paths require mustReport == NO; skipping while YES risks
+    // PushKit terminating the app.
+    if (!mustReport && ![Callingx canRegisterCall]) {
+        // Busy reject: drop without forwarding to JS.
+        if (completion) {
+            completion();
+        }
+        return;
+    }
+
+    if (!mustReport &&
+        [Callingx shouldSkipIncomingPushInForeground] &&
+        isAppInForeground()) {
+        // Foreground skip: hide CallKit, let JS render the ringing UI.
+        [VoipNotificationsManager didReceiveIncomingPushWithPayload:payload forType:type];
+        if (completion) {
+            completion();
+        }
+        return;
+    }
+
+    reportIncomingCallFromStreamPayload(streamPayload, completion);
+    [VoipNotificationsManager didReceiveIncomingPushWithPayload:payload forType:type];
+}
+
+// iOS 26.4 added a new VoIP push selector that carries a `PKVoIPPushMetadata`
+// argument (notably `mustReport`). The type only exists in the iOS 26.4 SDK,
+// so the `#ifdef __IPHONE_26_4` gate ensures this file still compiles on
+// older Xcode versions — older Xcode simply doesn't emit this method, and
+// PushKit on those builds dispatches to the legacy selector above.
+- (void)pushRegistry:(PKPushRegistry *)registry
+   didReceiveIncomingVoIPPushWithPayload:(PKPushPayload *)payload
+                                metadata:(PKVoIPPushMetadata *)metadata
+                   withCompletionHandler:(void (^)(void))completion
+                                                                API_AVAILABLE(ios(26.4)) {
+    [VoipPushHandler handleIncomingVoIPPush:payload
+                                   metadata:metadata
+                          completionHandler:completion];
+    [CallingxLogBridge pushDebug:@"[pushRegistry:didReceiveIncomingVoIPPushWithPayload:metadata:withCompletionHandler:] completion"];
+}
+#endif
+
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/react-native-callingx",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "CallKit and Telecom API capabilities for React Native",
   "main": "./dist/module/index.js",
   "module": "./dist/module/index.js",
@@ -59,20 +59,20 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@react-native-community/cli": "20.0.1",
-    "@react-native/babel-preset": "0.81.5",
-    "@stream-io/react-native-webrtc": "137.2.0",
-    "@types/react": "^19.1.0",
+    "@react-native-community/cli": "20.1.3",
+    "@react-native/babel-preset": "0.85.3",
+    "@stream-io/react-native-webrtc": "145.0.0",
+    "@types/react": "^19.2.15",
     "del-cli": "^6.0.0",
-    "react": "19.1.0",
-    "react-native": "0.81.5",
-    "react-native-builder-bob": "^0.40.15",
-    "typescript": "^5.9.2"
+    "react": "19.2.3",
+    "react-native": "0.85.3",
+    "react-native-builder-bob": "^0.41.0",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
     "@react-native-firebase/app": ">=23.0.0",
     "@react-native-firebase/messaging": ">=23.0.0",
-    "@stream-io/react-native-webrtc": ">=137.1.2",
+    "@stream-io/react-native-webrtc": "^145.0.0",
     "react": "*",
     "react-native": "*"
   },

package/src/spec/NativeCallingx.ts

@@ -48,11 +48,14 @@ export interface Spec extends TurboModule {
   getInitialEvents(): Array<{
     eventName: string;
     params: {
-      callId: string;
+      callId?: string;
       cause?: string;
       muted?: boolean;
       hold?: boolean;
       source?: string;
+      phase?: string;
+      reason?: string;
+      shouldResume?: boolean;
     };
   }>;
 
@@ -147,10 +150,14 @@ export interface Spec extends TurboModule {
   readonly onNewEvent: EventEmitter<{
     eventName: string;
     params: {
-      callId: string;
+      callId?: string;
       cause?: string;
       muted?: boolean;
       hold?: boolean;
+      source?: string;
+      phase?: string;
+      reason?: string;
+      shouldResume?: boolean;
     };
   }>;
 

package/src/types.ts

@@ -292,14 +292,12 @@ export type InfoDisplayOptions = {
 };
 
 export type EventData = {
-  eventName: EventName;
-  params: EventParams[EventName];
-};
+  [K in EventName]: { eventName: K; params: EventParams[K] };
+}[EventName];
 
 export type VoipEventData = {
-  eventName: VoipEventName;
-  params: VoipEventParams[VoipEventName];
-};
+  [K in VoipEventName]: { eventName: K; params: VoipEventParams[K] };
+}[VoipEventName];
 
 export type EventName =
   | 'answerCall'
@@ -307,11 +305,19 @@ export type EventName =
   | 'didDisplayIncomingCall'
   | 'didToggleHoldCallAction'
   | 'didChangeAudioRoute'
+  | 'didAudioInterruption'
   | 'didReceiveStartCallAction'
   | 'didPerformSetMutedCallAction'
   | 'didActivateAudioSession'
   | 'didDeactivateAudioSession';
 
+export type IOSAudioInterruptionEvent = {
+  source: 'callingx';
+  phase: 'began' | 'ended';
+  reason?: 'default' | 'builtInMicMuted' | 'routeDisconnected' | (string & {});
+  shouldResume?: boolean;
+};
+
 export type EventParams = {
   answerCall: {
     callId: string;
@@ -337,6 +343,7 @@ export type EventParams = {
     callId: string;
     output: string;
   };
+  didAudioInterruption: IOSAudioInterruptionEvent;
   didReceiveStartCallAction: {
     callId: string;
   };