@stream-io/react-native-callingx 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [0.6.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/react-native-callingx-0.6.0...@stream-io/react-native-callingx-0.6.1) (2026-07-02)
+
+### Dependency Updates
+
+- `@stream-io/typescript-config` updated to version `0.1.0`
+
+### Bug Fixes
+
+- made CXCallObserver static warm instance ([#2306](https://github.com/GetStream/stream-video-js/issues/2306)) ([ac79c64](https://github.com/GetStream/stream-video-js/commit/ac79c64f7231b12295e726f258e92c28b239d28b))
+
 ## [0.6.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/react-native-callingx-0.5.1...@stream-io/react-native-callingx-0.6.0) (2026-06-26)
 
 ### Dependency Updates

package/ios/CallingxImpl.swift

@@ -208,26 +208,15 @@ import stream_react_native_webrtc
     }
     
     @objc public static func canRegisterCall() -> Bool {
-        let hasCall = hasRegisteredCall()
         let shouldReject = Settings.getShouldRejectCallWhenBusy()
-        return !shouldReject || (shouldReject && !hasCall)
+        guard shouldReject else { return true }
+        return !hasRegisteredCall()
     }
-    
+
     @objc public static func hasRegisteredCall() -> Bool {
-        guard let storage = uuidStorage else { return false }
-      
-        let appUUIDs = storage.allUUIDs()
-        if appUUIDs.isEmpty { return false }
-        
-        let observer = CXCallObserver()
-        for call in observer.calls {
-            for uuid in appUUIDs {
-                if call.uuid == uuid {
-                    return true
-                }
-            }
-        }
-        return false
+        // Backed by the warm CXCallObserver maintained in UUIDStorage — no per-call observer
+        // construction and no cold-snapshot misses. Intersects our calls with CallKit's live set.
+        return uuidStorage?.hasRegisteredCall() ?? false
     }
     
     @objc public static func getAudioOutput() -> String? {
@@ -427,8 +416,12 @@ import stream_react_native_webrtc
 
         // This is mostly needed for very first setup, as we need to override the default
         // provider configuration which is set in the constructor.
-        // IMPORTANT: We override CXProvider instance only if there is no registered call, otherwise we may lose corrsponding call state/events from CallKit
-        if !CallingxImpl.hasRegisteredCall() {
+        // IMPORTANT: We override the CXProvider instance only when there are no calls in
+        // flight, otherwise we'd destroy CallKit state/events for a live call. We check our
+        // own storage rather than CXCallObserver here: the observer trails registration and
+        // can briefly report empty (e.g. a VoIP-push call reported just before setup runs),
+        // which would wrongly tear down the provider mid-call.
+        if (CallingxImpl.uuidStorage?.count() ?? 0) == 0 {
             let oldProvider = CallingxImpl.sharedProvider
             let newProvider = CXProvider(configuration: Settings.getProviderConfiguration())
             newProvider.setDelegate(self, queue: nil)
@@ -581,18 +574,9 @@ import stream_react_native_webrtc
     }
     
     @objc public func isCallTracked(_ callId: String) -> Bool {
-        guard let uuid = CallingxImpl.uuidStorage?.getUUID(forCid: callId) else {
-            CallingxLog.core.debugPublic("[isCallTracked] callId not found")
-            return false
-        }
-        
-        let observer = CXCallObserver()
-        for call in observer.calls {
-            if call.uuid == uuid {
-                return true
-            }
-        }
-        return false
+        // Backed by the warm CXCallObserver in UUIDStorage — no per-call observer construction
+        // and no cold-snapshot misses. True when the call is tracked AND confirmed live by CallKit.
+        return CallingxImpl.uuidStorage?.isCallTracked(forCid: callId) ?? false
     }
     
     @objc public func setCurrentCallActive(_ callId: String) -> Bool {

package/ios/UUIDStorage.swift

@@ -1,14 +1,58 @@
 import Foundation
+import CallKit
 
-@objcMembers public class UUIDStorage: NSObject {
+@objcMembers public class UUIDStorage: NSObject, CXCallObserverDelegate {
     /// 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: [])
 
+    /// Warm, long-lived observer of CallKit's call state — a cold observer can report empty even for a
+    /// call that's been live for a while.
+    private let callObserver = CXCallObserver()
+    /// CallKit's live view, maintained from observer callbacks. NOTE: contains UUIDs of ALL
+    /// system calls. Only ever intersect it with our own UUIDs — never treat it as "our calls".
+    private var liveCallKitUUIDs: Set<UUID> = []
+
     public override init() {
         super.init()
+        callObserver.setDelegate(self, queue: queue)
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            self.liveCallKitUUIDs = Set(
+                self.callObserver.calls.filter { !$0.hasEnded }.map { $0.uuid }
+            )
+        }
+    }
+
+    // MARK: - CXCallObserverDelegate
+
+    /// IMPORTANT: delivered on `queue`, NEVER call the `queue.sync` helpers below —
+    /// re-entering the serial queue would deadlock.
+    public func callObserver(_ callObserver: CXCallObserver, callChanged call: CXCall) {
+        if call.hasEnded {
+            liveCallKitUUIDs.remove(call.uuid)
+        } else {
+            liveCallKitUUIDs.insert(call.uuid)
+        }
+    }
+
+    // MARK: - CallKit liveness queries
+
+    public func hasRegisteredCall() -> Bool {
+        return queue.sync {
+            guard !callsByCid.isEmpty else { return false }
+            let ours = Set(callsByCid.values.map { $0.uuid })
+            return !ours.isDisjoint(with: liveCallKitUUIDs)
+        }
+    }
+
+    public func isCallTracked(forCid cid: String) -> Bool {
+        return queue.sync {
+            guard let call = callsByCid[cid] else { return false }
+            return liveCallKitUUIDs.contains(call.uuid)
+        }
     }
 
     // MARK: - CallingxCall-based API (new)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/react-native-callingx",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "CallKit and Telecom API capabilities for React Native",
   "main": "./dist/module/index.js",
   "module": "./dist/module/index.js",