@stream-io/react-native-callingx 0.1.0-beta.0

package/ios/CallingxPublic.h

@@ -0,0 +1,79 @@
+#import <Foundation/Foundation.h>
+#import <CallKit/CallKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Callingx - React Native Turbo Module for CallKit integration
+ *
+ * This header exposes the public API for use in AppDelegate or other native code.
+ *
+ * Usage in AppDelegate.m:
+ * ```
+ * #import <Callingx/CallingxPublic.h>
+ *
+ * [Callingx reportNewIncomingCall:callId
+ *                          handle:handle
+ *                      handleType:@"number"
+ *                        hasVideo:YES
+ *             localizedCallerName:callerName
+ *                 supportsHolding:NO
+ *                    supportsDTMF:NO
+ *                supportsGrouping:NO
+ *              supportsUngrouping:NO
+ *                     fromPushKit:YES
+ *                         payload:payload
+ *           withCompletionHandler:^{ }];
+ * ```
+ */
+@interface Callingx : NSObject
+
+/**
+ * Report a new incoming call to CallKit.
+ * Call this from your PushKit delegate when receiving a VoIP push notification.
+ *
+ * @param callId Unique identifier for the call (e.g., call ID from your backend)
+ * @param handle The phone number or identifier to display
+ * @param handleType Type of handle: "number", "email", or "generic"
+ * @param hasVideo Whether this is a video call
+ * @param localizedCallerName The caller's display name
+ * @param supportsHolding Whether the call supports being put on hold
+ * @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
+ */
++ (void)reportNewIncomingCall:(NSString *)callId
+                       handle:(NSString *)handle
+                   handleType:(NSString *)handleType
+                     hasVideo:(BOOL)hasVideo
+          localizedCallerName:(NSString * _Nullable)localizedCallerName
+              supportsHolding:(BOOL)supportsHolding
+                 supportsDTMF:(BOOL)supportsDTMF
+             supportsGrouping:(BOOL)supportsGrouping
+           supportsUngrouping:(BOOL)supportsUngrouping
+                  fromPushKit:(BOOL)fromPushKit
+                      payload:(NSDictionary * _Nullable)payload
+        withCompletionHandler:(void (^_Nullable)(void))completion;
+
+/**
+ * End a call with a specific reason.
+ *
+ * @param callId The call ID to end
+ * @param reason The reason for ending: 1=failed, 2=remoteEnded, 3=unanswered, 4=answeredElsewhere, 5=declinedElsewhere
+ */
++ (void)endCall:(NSString *)callId
+         reason:(int)reason;
+
+/**
+ * Check if a new call can be registered (based on shouldRejectCallWhenBusy setting)
+ *
+ * @return YES if a new call can be registered, NO if should be rejected
+ */
++ (BOOL)canRegisterCall;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Settings.swift

@@ -0,0 +1,108 @@
+import Foundation
+import CallKit
+import UIKit
+
+@objcMembers public class Settings: NSObject {
+    private static let settingsKey = "CallingxSettings"
+
+    public static func getSettings() -> [String: Any] {
+        return UserDefaults.standard.dictionary(forKey: settingsKey) ?? [:]
+    }
+
+    public static func setSettings(_ options: [String: Any]?) {
+        #if DEBUG
+        print("[Settings][setSettings] options = \(String(describing: options))")
+        #endif
+
+        var settings: [String: Any] = getSettings()
+
+        if let options = options {
+            for (key, value) in options {
+                settings[key] = value
+            }
+        }
+
+        UserDefaults.standard.set(settings, forKey: settingsKey)
+        UserDefaults.standard.synchronize()
+    }
+
+    public static func getShouldRejectCallWhenBusy() -> Bool {
+        guard let shouldReject = getSettings()["shouldRejectCallWhenBusy"] as? Bool else {
+            return false
+        }
+        return shouldReject
+    }
+
+    public static func setShouldRejectCallWhenBusy(_ shouldReject: Bool) {
+        setSettings(["shouldRejectCallWhenBusy": shouldReject])
+    }
+
+    public static func getProviderConfiguration() -> CXProviderConfiguration {
+        #if DEBUG
+        print("[Settings][getProviderConfiguration]")
+        #endif
+      
+        let settings = getSettings()
+        let providerConfiguration = CXProviderConfiguration()
+        providerConfiguration.supportsVideo = true
+        providerConfiguration.maximumCallGroups = 1
+        providerConfiguration.maximumCallsPerCallGroup = 1
+        providerConfiguration.supportedHandleTypes = getSupportedHandleTypes(settings["handleType"])
+
+        if let supportsVideo = settings["supportsVideo"] as? Bool {
+            providerConfiguration.supportsVideo = supportsVideo
+        }
+        if let maximumCallGroups = settings["maximumCallGroups"] as? Int {
+            providerConfiguration.maximumCallGroups = maximumCallGroups
+        }
+        if let maximumCallsPerCallGroup = settings["maximumCallsPerCallGroup"] as? Int {
+            providerConfiguration.maximumCallsPerCallGroup = maximumCallsPerCallGroup
+        }
+
+        if let imageName = settings["imageName"] as? String, !imageName.isEmpty {
+            if let image = UIImage(named: imageName) {
+                providerConfiguration.iconTemplateImageData = image.pngData()
+            }
+        }
+
+        if let ringtoneSound = settings["ringtoneSound"] as? String, !ringtoneSound.isEmpty {
+            providerConfiguration.ringtoneSound = ringtoneSound
+        }
+
+        if let includesCallsInRecents = settings["includesCallsInRecents"] as? Bool {
+            providerConfiguration.includesCallsInRecents = includesCallsInRecents
+        }
+
+        return providerConfiguration
+    }
+
+  public static func getSupportedHandleTypes(_ handleType: Any?) -> Set<CXHandle.HandleType> {
+        if let handleTypeArray = handleType as? [String] {
+            var types = Set<CXHandle.HandleType>()
+            for type in handleTypeArray {
+                types.insert(getHandleType(type))
+            }
+            return types
+        } else if let handleTypeString = handleType as? String {
+            let type = getHandleType(handleTypeString)
+            return Set([type])
+        } else {
+            return Set([CXHandle.HandleType.phoneNumber])
+        }
+    }
+
+    public static func getHandleType(_ handleType: String?) -> CXHandle.HandleType {
+        guard let handleType = handleType else { return .generic }
+
+        switch handleType {
+        case "generic":
+            return .generic
+        case "number", "phone":
+            return .phoneNumber
+        case "email":
+            return .emailAddress
+        default:
+            return .generic
+        }
+    }
+}

package/ios/UUIDStorage.swift

@@ -0,0 +1,124 @@
+import Foundation
+
+@objcMembers public class UUIDStorage: NSObject {
+    private var uuidDict: [String: String] = [:]
+    private var cidDict: [String: String] = [:]
+    private let queue = DispatchQueue(label: "com.stream.uuidstorage", attributes: [])
+
+    public override init() {
+        super.init()
+    }
+
+    public func allUUIDs() -> [UUID] {
+        return queue.sync {
+            return uuidDict.values.compactMap { UUID(uuidString: $0.lowercased()) }
+        }
+    }
+
+    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 DEBUG
+                print("[UUIDStorage] getUUIDForCid: found existing UUID \(existingUUID) for cid \(cid)")
+                #endif
+                return UUID(uuidString: existingUUID) ?? UUID()
+            }
+
+            let uuid = UUID()
+            let uuidString = uuid.uuidString.lowercased()
+            uuidDict[cid] = uuidString
+            cidDict[uuidString] = cid
+            #if DEBUG
+            print("[UUIDStorage] getUUIDForCid: created new UUID \(uuidString) for cid \(cid)")
+            #endif
+            return uuid
+        }
+    }
+
+    public func getUUID(forCid cid: String) -> UUID? {
+        return queue.sync {
+            guard let uuidString = uuidDict[cid] else { return nil }
+            return UUID(uuidString: uuidString)
+        }
+    }
+
+    public func getCid(forUUID uuid: UUID) -> String? {
+        return queue.sync {
+            let uuidString = uuid.uuidString.lowercased()
+            let cid = cidDict[uuidString]
+            #if DEBUG
+            print("[UUIDStorage] getCidForUUID: UUID \(uuidString) -> cid \(cid ?? "(not found)")")
+            #endif
+            return cid
+        }
+    }
+
+    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 DEBUG
+                print("[UUIDStorage] removeCidForUUID: removed cid \(cid) for UUID \(uuidString)")
+                #endif
+            } else {
+                #if DEBUG
+                print("[UUIDStorage] removeCidForUUID: no cid found for UUID \(uuidString)")
+                #endif
+            }
+        }
+    }
+
+    public func removeCid(_ cid: String) {
+        queue.sync {
+            if let uuidString = uuidDict[cid] {
+                cidDict.removeValue(forKey: uuidString)
+                uuidDict.removeValue(forKey: cid)
+                #if DEBUG
+                print("[UUIDStorage] removeCid: removed cid \(cid) with UUID \(uuidString)")
+                #endif
+            } else {
+                #if DEBUG
+                print("[UUIDStorage] removeCid: no UUID found for cid \(cid)")
+                #endif
+            }
+        }
+    }
+
+    public func removeAllObjects() {
+        queue.sync {
+            let count = uuidDict.count
+            uuidDict.removeAll()
+            cidDict.removeAll()
+            #if DEBUG
+            print("[UUIDStorage] removeAllObjects: cleared \(count) entries")
+            #endif
+        }
+    }
+
+    public func count() -> Int {
+        return queue.sync {
+            return uuidDict.count
+        }
+    }
+
+    public func containsCid(_ cid: String) -> Bool {
+        return queue.sync {
+            return uuidDict[cid] != nil
+        }
+    }
+
+    public func containsUUID(_ uuid: UUID) -> Bool {
+        return queue.sync {
+            return cidDict[uuid.uuidString.lowercased()] != nil
+        }
+    }
+
+    public override var description: String {
+        return queue.sync {
+            return "UUIDStorage: \(uuidDict)"
+        }
+    }
+}

package/ios/VoipNotificationsManager.swift

@@ -0,0 +1,180 @@
+import Foundation
+import PushKit
+import React
+
+@objcMembers public class VoipNotificationsEvents: NSObject {
+    public static let registered = "voipNotificationsRegistered"
+    public static let newNotification = "voipNotificationReceived"
+}
+
+typealias RNVoipPushNotificationCompletion = () -> Void
+
+@objc public protocol VoipNotificationsEventEmitter {
+    func emitVoipEvent(_ dictionary: [String: Any])
+}
+
+@objc public class VoipNotificationsManager: NSObject {
+    
+    @objc public weak var eventEmitter: VoipNotificationsEventEmitter?
+    
+    private static var isVoipRegistered = false
+    private static var lastVoipToken = ""
+    private static var voipRegistry: PKPushRegistry?
+    
+    private var canSendEvents: Bool = false
+    private var delayedEvents: [[String:Any]] = []
+    
+    private static var sharedInstance: VoipNotificationsManager?
+    
+    @objc public static func shared() -> VoipNotificationsManager {
+        if sharedInstance == nil {
+            sharedInstance = VoipNotificationsManager()
+        }
+        return sharedInstance!
+    }
+    
+    @objc public override init() {
+        super.init()
+
+        canSendEvents = false
+        delayedEvents = []
+
+        if VoipNotificationsManager.sharedInstance == nil {
+            VoipNotificationsManager.sharedInstance = self
+        }
+    }
+
+     deinit {
+        NotificationCenter.default.removeObserver(self)
+        
+        canSendEvents = false
+        delayedEvents = []
+    }
+    
+    // MARK: - Class Methods
+    
+    @objc public static func voipRegistration() {
+        if isVoipRegistered {
+            #if DEBUG
+            print("[VoipNotificationsManager] voipRegistration is already registered. return _lastVoipToken = \(lastVoipToken)")
+            #endif
+            let voipPushManager = VoipNotificationsManager.shared()
+            voipPushManager.sendEventWithNameWrapper(name: VoipNotificationsEvents.registered, body: ["token": lastVoipToken])
+        } else {
+            #if DEBUG
+            print("[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
+                    print("[VoipNotificationsManager] voipRegistration appDelegate not found. return")
+                    #endif
+                }
+            }
+        }
+    }
+    
+    @objc public static func didUpdatePushCredentials(_ credentials: PKPushCredentials, forType type: String) {
+        #if DEBUG
+        print("[VoipNotificationsManager] didUpdatePushCredentials credentials.token = \(credentials.token), type = \(type)")
+        #endif
+        
+        let voipTokenLength = credentials.token.count
+        if voipTokenLength == 0 {
+            return
+        }
+        
+        lastVoipToken = credentials.token.map { String(format: "%02x", $0) }.joined()
+        
+        let voipPushManager = VoipNotificationsManager.shared()
+        voipPushManager.sendEventWithNameWrapper(name: VoipNotificationsEvents.registered, body: ["token": lastVoipToken])
+    }
+    
+    @objc public static func didReceiveIncomingPushWithPayload(_ payload: PKPushPayload, forType type: String) {
+        #if DEBUG
+        print("[VoipNotificationsManager] didReceiveIncomingPushWithPayload payload.dictionaryPayload = \(payload.dictionaryPayload), type = \(type)")
+        #endif
+        
+        let dictionaryPayload: [String: Any] = Dictionary(uniqueKeysWithValues: payload.dictionaryPayload.map { (key, value) in
+            (String(describing: key), value)
+        })
+        
+        let voipPushManager = VoipNotificationsManager.shared()
+        voipPushManager.sendEventWithNameWrapper(name: VoipNotificationsEvents.newNotification, body: dictionaryPayload)
+    }
+    
+    // MARK: - React Native Methods
+    @objc public func getInitialEvents() -> [[String: Any]] {
+        var events: [[String: Any]] = []
+        let action = {
+            #if DEBUG
+            print("[VoipNotificationsManager][getInitialEvents] delayedEvents = \(self.delayedEvents)")
+            #endif
+            
+            events = self.delayedEvents
+            self.delayedEvents = []
+            self.canSendEvents = true
+        }
+
+        if (Thread.isMainThread) {
+            action()
+        } else {
+            DispatchQueue.main.sync {
+                action()
+            }
+        }
+        return events
+    }
+
+    @objc public func registerVoipToken() {
+        if RCTRunningInAppExtension() {
+            return
+        }
+        DispatchQueue.main.async {
+            VoipNotificationsManager.voipRegistration()
+        }
+    }
+
+    private func sendEventWithNameWrapper(name: String, body: [String: Any]?) {
+        #if DEBUG
+        print("[VoipNotificationsManager] sendEventWithNameWrapper: \(name)")
+        #endif
+        
+        let sendEventAction = {
+            var dictionary: [String: Any] = ["eventName": name]
+            if let body = body {
+                dictionary["params"] = body
+            }
+
+            if self.canSendEvents {
+                self.eventEmitter?.emitVoipEvent(dictionary)
+            } else {
+                self.delayedEvents.append(dictionary)
+                #if DEBUG
+                print("[VoipNotificationsManager] delayedEvents: \(self.delayedEvents)")
+                #endif
+            }
+        }
+
+        if (Thread.isMainThread) {
+            sendEventAction()
+        } else {
+            DispatchQueue.main.async {
+                sendEventAction()
+            }
+        }
+
+    }
+}
+

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@stream-io/react-native-callingx",
+  "version": "0.1.0-beta.0",
+  "description": "CallKit and Telecom API capabilities for React Native",
+  "main": "./dist/module/index.js",
+  "module": "./dist/module/index.js",
+  "types": "./dist/typescript/src/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/typescript/src/index.d.ts",
+      "default": "./dist/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "dist",
+    "android",
+    "ios",
+    "cpp",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "clean": "del-cli android/build dist",
+    "prepare": "bob build",
+    "build": "bob build",
+    "typecheck": "tsc"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GetStream/stream-video-js.git"
+  },
+  "author": "https://getstream.io <support@getstream.io> (https://github.com/GetStream)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/GetStream/stream-video-js/issues"
+  },
+  "homepage": "https://github.com/GetStream/stream-video-js#readme",
+  "publishConfig": {
+    "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.1.0",
+    "@types/react": "^19.1.0",
+    "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"
+  },
+  "peerDependencies": {
+    "@stream-io/react-native-webrtc": ">=137.1.0",
+    "react": "*",
+    "react-native": "*"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "dist",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "codegenConfig": {
+    "name": "CallingxSpec",
+    "type": "modules",
+    "jsSrcsDir": "src/spec",
+    "android": {
+      "javaPackageName": "io.getstream.rn.callingx"
+    },
+    "ios": {
+      "moduleName": "Callingx"
+    }
+  },
+  "create-react-native-library": {
+    "languages": "kotlin-objc",
+    "type": "turbo-module",
+    "tools": [],
+    "version": "0.55.0"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {},
+      ios: {},
+    },
+  },
+};