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

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)]"
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/react-native-callingx",
-  "version": "0.1.0-beta.3",
+  "version": "0.1.0-beta.5",
   "description": "CallKit and Telecom API capabilities for React Native",
   "main": "./dist/module/index.js",
   "module": "./dist/module/index.js",
@@ -61,7 +61,7 @@
   "devDependencies": {
     "@react-native-community/cli": "20.0.1",
     "@react-native/babel-preset": "^0.81.5",
-    "@stream-io/react-native-webrtc": "137.1.2-alpha.1",
+    "@stream-io/react-native-webrtc": "137.1.2",
     "@types/react": "^19.1.0",
     "del-cli": "^6.0.0",
     "react": "19.1.0",
@@ -70,7 +70,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@stream-io/react-native-webrtc": ">=137.1.1",
+    "@stream-io/react-native-webrtc": ">=137.1.2",
     "react": "*",
     "react-native": "*"
   },

package/src/CallingxModule.ts

@@ -196,8 +196,8 @@ class CallingxModule implements ICallingxModule {
     return NativeCallingModule.endCallWithReason(callId, reasons[reason]);
   }
 
-  isCallRegistered(callId: string): boolean {
-    return NativeCallingModule.isCallRegistered(callId);
+  isCallTracked(callId: string): boolean {
+    return NativeCallingModule.isCallTracked(callId);
   }
 
   hasRegisteredCall(): boolean {

package/src/spec/NativeCallingx.ts

@@ -109,7 +109,7 @@ export interface Spec extends TurboModule {
     },
   ): Promise<void>;
 
-  isCallRegistered(callId: string): boolean;
+  isCallTracked(callId: string): boolean;
 
   hasRegisteredCall(): boolean;
 

package/src/types.ts

@@ -76,11 +76,11 @@ export interface ICallingxModule {
   ): Promise<void>;
 
   /**
-   * Check if the call is registered in CallKit/Telecom.
+   * Check if the call is tracked in the native calling module.
    * @param callId - The call id.
    * @returns The boolean value.
    */
-  isCallRegistered(callId: string): boolean;
+  isCallTracked(callId: string): boolean;
 
   /**
    * Check if there is a registered call.