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

package/dist/typescript/src/utils/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,WAAW,MAAM,4EAK5C,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,WAAW,MAAM,4EAK5C,CAAC;AAGF,eAAO,MAAM,oBAAoB,SAAgC,CAAC"}

package/ios/Callingx.mm

@@ -1,8 +1,14 @@
+#ifdef RCT_NEW_ARCH_ENABLED
 #import <CallingxSpec/CallingxSpec.h>
+#endif
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 #import <React/RCTBridge+Private.h>
 
 #import <AVFoundation/AVAudioSession.h>
 #import <CallKit/CallKit.h>
+#import "WebRTCModule.h"
 
 // Import Swift generated header
 #if __has_include("Callingx-Swift.h")
@@ -11,9 +17,13 @@
 #import <Callingx/Callingx-Swift.h>
 #endif
 
-// MARK: - Callingx Turbo Module Interface
+// MARK: - Callingx Interface
 
+#ifdef RCT_NEW_ARCH_ENABLED
 @interface Callingx : NativeCallingxSpecBase<NativeCallingxSpec, CallingxEventEmitter, VoipNotificationsEventEmitter>
+#else
+@interface Callingx : RCTEventEmitter <RCTBridgeModule, CallingxEventEmitter, VoipNotificationsEventEmitter>
+#endif
 
 @property (nonatomic, strong) CXCallController *callKeepCallController;
 @property (nonatomic, strong) CXProvider *callKeepProvider;
@@ -35,15 +45,21 @@
   return sharedInstance;
 }
 
-#pragma mark - Class Methods (Public API)
+#pragma mark - Module Registration
 
 + (BOOL)requiresMainQueueSetup {
   return YES;
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
 + (NSString *)moduleName {
   return @"Callingx";
 }
+#else
+RCT_EXPORT_MODULE(Callingx)
+#endif
+
+#pragma mark - Class Methods (Public API)
 
 + (void)reportNewIncomingCall:(NSString *)callId
                        handle:(NSString *)handle
@@ -54,10 +70,9 @@
                  supportsDTMF:(BOOL)supportsDTMF
              supportsGrouping:(BOOL)supportsGrouping
            supportsUngrouping:(BOOL)supportsUngrouping
-                  fromPushKit:(BOOL)fromPushKit
                       payload:(NSDictionary *_Nullable)payload
         withCompletionHandler:(void (^_Nullable)(void))completion {
-  
+
   [CallingxImpl reportNewIncomingCallWithCallId:callId
                                          handle:handle
                                      handleType:handleType
@@ -67,9 +82,11 @@
                                    supportsDTMF:supportsDTMF
                                supportsGrouping:supportsGrouping
                              supportsUngrouping:supportsUngrouping
-                                    fromPushKit:fromPushKit
                                         payload:payload
-                                     completion:completion];
+                                     completion:completion
+                                        resolve:nil
+                                         reject:nil
+  ];
 }
 
 + (BOOL)canRegisterCall {
@@ -96,23 +113,59 @@
   _moduleImpl = nil;
 }
 
+#pragma mark - Old Arch Event Support
+
+#ifndef RCT_NEW_ARCH_ENABLED
+- (NSArray<NSString *> *)supportedEvents {
+  return @[@"onNewEvent", @"onNewVoipEvent"];
+}
+#endif
+
+#pragma mark - Turbo Module (New Arch Only)
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params {
   return std::make_shared<facebook::react::NativeCallingxSpecJSI>(params);
 }
+#endif
 
-#pragma mark - CallingxEventEmitter Protocol
+#pragma mark - Event Emission
 
 - (void)emitEvent:(NSDictionary *)dictionary {
+#ifdef RCT_NEW_ARCH_ENABLED
   [self emitOnNewEvent:dictionary];
+#else
+  [self sendEventWithName:@"onNewEvent" body:dictionary];
+#endif
 }
 
 - (void)emitVoipEvent:(NSDictionary *)dictionary {
+#ifdef RCT_NEW_ARCH_ENABLED
   [self emitOnNewVoipEvent:dictionary];
+#else
+  [self sendEventWithName:@"onNewVoipEvent" body:dictionary];
+#endif
 }
 
-#pragma mark - Turbo Module Methods
+#pragma mark - Internal Helpers
+
+- (void)_setupiOSWithOptions:(NSDictionary *)optionsDict {
+  [_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;
+}
+
+#pragma mark - setupiOS
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)setupiOS:(JS::NativeCallingx::SpecSetupiOSOptions &)options {
   NSDictionary *optionsDict = @{
     @"supportsVideo" : @(options.supportsVideo()),
@@ -125,35 +178,106 @@
     @"displayCallTimeout" : @(options.displayCallTimeout())
   };
   
-  [_moduleImpl setupWithOptions:optionsDict];
-  
-  self.callKeepCallController = _moduleImpl.callKeepCallController;
-  self.callKeepProvider = _moduleImpl.callKeepProvider;
+  [self _setupiOSWithOptions:optionsDict];
+}
+#else
+RCT_EXPORT_METHOD(setupiOS:(NSDictionary *)options) {
+  NSDictionary *optionsDict = @{
+    @"supportsVideo" : options[@"supportsVideo"] ?: @(NO),
+    @"maximumCallsPerCallGroup" : options[@"maximumCallsPerCallGroup"] ?: @(1),
+    @"maximumCallGroups" : options[@"maximumCallGroups"] ?: @(1),
+    @"handleType" : options[@"handleType"] ?: @"generic",
+    @"ringtoneSound" : options[@"sound"] ?: @"",
+    @"imageName" : options[@"imageName"] ?: @"",
+    @"includesCallsInRecents" : options[@"callsHistory"] ?: @(NO),
+    @"displayCallTimeout" : options[@"displayCallTimeout"] ?: @(0)
+  };
+
+  [self _setupiOSWithOptions:optionsDict];
+}
+#endif
+
+#pragma mark - setupAndroid
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (void)setupAndroid:(JS::NativeCallingx::SpecSetupAndroidOptions &)options {
+  // iOS only - leave empty
+}
+#else
+RCT_EXPORT_METHOD(setupAndroid:(NSDictionary *)options) {
+  // iOS only - leave empty
 }
+#endif
 
+#pragma mark - setShouldRejectCallWhenBusy
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)setShouldRejectCallWhenBusy:(BOOL)shouldReject {
   [Settings setShouldRejectCallWhenBusy:shouldReject];
 }
+#else
+RCT_EXPORT_METHOD(setShouldRejectCallWhenBusy:(BOOL)shouldReject) {
+  [Settings setShouldRejectCallWhenBusy:shouldReject];
+}
+#endif
+
+#pragma mark - getInitialEvents
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (NSArray<NSDictionary *> *)getInitialEvents {
   return [_moduleImpl getInitialEvents];
 }
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getInitialEvents) {
+  return [_moduleImpl getInitialEvents];
+}
+#endif
+
+#pragma mark - getInitialVoipEvents
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (NSArray<NSDictionary *> *)getInitialVoipEvents {
   return [[VoipNotificationsManager shared] getInitialEvents];
 }
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getInitialVoipEvents) {
+  return [[VoipNotificationsManager shared] getInitialEvents];
+}
+#endif
 
+#pragma mark - registerVoipToken
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)registerVoipToken {
   [[VoipNotificationsManager shared] registerVoipToken];
 }
+#else
+RCT_EXPORT_METHOD(registerVoipToken) {
+  [[VoipNotificationsManager shared] registerVoipToken];
+}
+#endif
 
+#pragma mark - answerIncomingCall
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)answerIncomingCall:(nonnull NSString *)callId
                    resolve:(nonnull RCTPromiseResolveBlock)resolve
                     reject:(nonnull RCTPromiseRejectBlock)reject {
   BOOL result = [_moduleImpl answerIncomingCall:callId];
   resolve(@(result));
 }
+#else
+RCT_EXPORT_METHOD(answerIncomingCall:(NSString *)callId
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject) {
+  BOOL result = [_moduleImpl answerIncomingCall:callId];
+  resolve(@(result));
+}
+#endif
+
+#pragma mark - displayIncomingCall
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)displayIncomingCall:(nonnull NSString *)callId
                 phoneNumber:(nonnull NSString *)phoneNumber
                  callerName:(nonnull NSString *)callerName
@@ -161,13 +285,35 @@
              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
+  ];
+}
+#else
+RCT_EXPORT_METHOD(displayIncomingCall:(NSString *)callId
+                phoneNumber:(NSString *)phoneNumber
+                 callerName:(NSString *)callerName
+                   hasVideo:(BOOL)hasVideo
+             displayOptions:(NSDictionary *)displayOptions
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject) {
+  [_moduleImpl displayIncomingCallWithCallId:callId
+                                 phoneNumber:phoneNumber
+                                  callerName:callerName
+                                    hasVideo:hasVideo
+                                     resolve:resolve
+                                      reject:reject
+  ];
 }
+#endif
 
+#pragma mark - endCallWithReason
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)endCallWithReason:(nonnull NSString *)callId
                    reason:(double)reason
                   resolve:(nonnull RCTPromiseResolveBlock)resolve
@@ -175,29 +321,79 @@
   [CallingxImpl endCall:callId reason:(int)reason];
   resolve(@YES);
 }
+#else
+RCT_EXPORT_METHOD(endCallWithReason:(NSString *)callId
+                   reason:(double)reason
+                  resolve:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject) {
+  [CallingxImpl endCall:callId reason:(int)reason];
+  resolve(@YES);
+}
+#endif
+
+#pragma mark - endCall
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)endCall:(nonnull NSString *)callId
         resolve:(nonnull RCTPromiseResolveBlock)resolve
          reject:(nonnull RCTPromiseRejectBlock)reject {
   BOOL result = [_moduleImpl endCall:callId];
   resolve(@(result));
 }
+#else
+RCT_EXPORT_METHOD(endCall:(NSString *)callId
+        resolve:(RCTPromiseResolveBlock)resolve
+         reject:(RCTPromiseRejectBlock)reject) {
+  BOOL result = [_moduleImpl endCall:callId];
+  resolve(@(result));
+}
+#endif
+
+#pragma mark - isCallRegistered
 
-- (NSNumber *)isCallRegistered:(nonnull NSString *)callId {
-  return @([_moduleImpl isCallRegistered:callId]);
+#ifdef RCT_NEW_ARCH_ENABLED
+- (NSNumber *)isCallTracked:(nonnull NSString *)callId {
+  return @([_moduleImpl isCallTracked:callId]);
 }
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isCallTracked:(NSString *)callId) {
+  return @([_moduleImpl isCallTracked:callId]);
+}
+#endif
 
+#pragma mark - hasRegisteredCall
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (NSNumber *)hasRegisteredCall {
   return @([CallingxImpl hasRegisteredCall]);
 }
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(hasRegisteredCall) {
+  return @([CallingxImpl hasRegisteredCall]);
+}
+#endif
+
+#pragma mark - setCurrentCallActive
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)setCurrentCallActive:(nonnull NSString *)callId
                      resolve:(nonnull RCTPromiseResolveBlock)resolve
                       reject:(nonnull RCTPromiseRejectBlock)reject {
   BOOL result = [_moduleImpl setCurrentCallActive:callId];
   resolve(@(result));
 }
+#else
+RCT_EXPORT_METHOD(setCurrentCallActive:(NSString *)callId
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject) {
+  BOOL result = [_moduleImpl setCurrentCallActive:callId];
+  resolve(@(result));
+}
+#endif
+
+#pragma mark - setMutedCall
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)setMutedCall:(nonnull NSString *)callId
              isMuted:(BOOL)isMuted
              resolve:(nonnull RCTPromiseResolveBlock)resolve
@@ -205,7 +401,19 @@
   BOOL result = [_moduleImpl setMutedCall:callId isMuted:isMuted];
   resolve(@(result));
 }
+#else
+RCT_EXPORT_METHOD(setMutedCall:(NSString *)callId
+             isMuted:(BOOL)isMuted
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject) {
+  BOOL result = [_moduleImpl setMutedCall:callId isMuted:isMuted];
+  resolve(@(result));
+}
+#endif
+
+#pragma mark - setOnHoldCall
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)setOnHoldCall:(nonnull NSString *)callId
              isOnHold:(BOOL)isOnHold
               resolve:(nonnull RCTPromiseResolveBlock)resolve
@@ -213,7 +421,19 @@
   BOOL result = [_moduleImpl setOnHoldCall:callId isOnHold:isOnHold];
   resolve(@(result));
 }
+#else
+RCT_EXPORT_METHOD(setOnHoldCall:(NSString *)callId
+             isOnHold:(BOOL)isOnHold
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject) {
+  BOOL result = [_moduleImpl setOnHoldCall:callId isOnHold:isOnHold];
+  resolve(@(result));
+}
+#endif
 
+#pragma mark - startCall
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)startCall:(nonnull NSString *)callId
       phoneNumber:(nonnull NSString *)phoneNumber
        callerName:(nonnull NSString *)callerName
@@ -227,7 +447,25 @@
                     hasVideo:hasVideo];
   resolve(@YES);
 }
+#else
+RCT_EXPORT_METHOD(startCall:(NSString *)callId
+      phoneNumber:(NSString *)phoneNumber
+       callerName:(NSString *)callerName
+         hasVideo:(BOOL)hasVideo
+   displayOptions:(NSDictionary *)displayOptions
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject) {
+  [_moduleImpl startCallWithCallId:callId
+                 phoneNumber:phoneNumber
+                  callerName:callerName
+                    hasVideo:hasVideo];
+  resolve(@YES);
+}
+#endif
+
+#pragma mark - updateDisplay
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)updateDisplay:(nonnull NSString *)callId
           phoneNumber:(nonnull NSString *)phoneNumber
            callerName:(nonnull NSString *)callerName
@@ -239,15 +477,35 @@
                                     callerName:callerName];
   resolve(@(result));
 }
+#else
+RCT_EXPORT_METHOD(updateDisplay:(NSString *)callId
+          phoneNumber:(NSString *)phoneNumber
+           callerName:(NSString *)callerName
+       displayOptions:(NSDictionary *)displayOptions
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject) {
+  BOOL result = [_moduleImpl updateDisplayWithCallId:callId
+                                   phoneNumber:phoneNumber
+                                    callerName:callerName];
+  resolve(@(result));
+}
+#endif
+
+#pragma mark - log
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)log:(NSString *)message level:(NSString *)level {
   NSLog(@"[Callingx][log] %@, %@", message, level);
 }
-
-- (void)setupAndroid:(JS::NativeCallingx::SpecSetupAndroidOptions &)options {
-  // iOS only - leave empty
+#else
+RCT_EXPORT_METHOD(log:(NSString *)message level:(NSString *)level) {
+  NSLog(@"[Callingx][log] %@, %@", message, level);
 }
+#endif
+
+#pragma mark - startBackgroundTask
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)startBackgroundTask:(NSString *)taskName
                     timeout:(double)timeout
                     resolve:(RCTPromiseResolveBlock)resolve
@@ -255,26 +513,72 @@
   // Not implemented on iOS
   resolve(@YES);
 }
+#else
+RCT_EXPORT_METHOD(startBackgroundTask:(NSString *)taskName
+                    timeout:(double)timeout
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject) {
+  // Not implemented on iOS
+  resolve(@YES);
+}
+#endif
+
+#pragma mark - stopBackgroundTask
 
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)stopBackgroundTask:(NSString *)taskName
                    resolve:(RCTPromiseResolveBlock)resolve
                     reject:(RCTPromiseRejectBlock)reject {
   // Not implemented on iOS
   resolve(@YES);
 }
+#else
+RCT_EXPORT_METHOD(stopBackgroundTask:(NSString *)taskName
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject) {
+  // Not implemented on iOS
+  resolve(@YES);
+}
+#endif
 
+#pragma mark - registerBackgroundTaskAvailable
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)registerBackgroundTaskAvailable {
   // Not implemented on iOS - background tasks work differently on iOS
 }
+#else
+RCT_EXPORT_METHOD(registerBackgroundTaskAvailable) {
+  // Not implemented on iOS - background tasks work differently on iOS
+}
+#endif
 
+#pragma mark - isServiceStarted
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (void)isServiceStarted:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject {
   // iOS doesn't use a service like Android, always return true
   resolve(@YES);
 }
+#else
+RCT_EXPORT_METHOD(isServiceStarted:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  // iOS doesn't use a service like Android, always return true
+  resolve(@YES);
+}
+#endif
 
+#pragma mark - canPostNotifications
+
+#ifdef RCT_NEW_ARCH_ENABLED
 - (nonnull NSNumber *)canPostNotifications {
   return @YES;
 }
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(canPostNotifications) {
+  return @YES;
+}
+#endif
 
 @end

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