@qusaieilouti99/call-manager 0.1.129 → 0.1.130

package/ios/AudioManager.swift

@@ -48,18 +48,48 @@ class AudioManager {
   }
 
   func configureAudioSession(forCallType isVideo: Bool,
-                             isIncoming: Bool) {
-    logger.info("configureAudioSession: video=\(isVideo), incoming=\(isIncoming)")
-    var opts: AVAudioSession.CategoryOptions = [.allowBluetooth, .allowBluetoothA2DP]
-    if isVideo || isIncoming { opts.insert(.defaultToSpeaker) }
-    do {
-      try session.setCategory(.playAndRecord,
-                              mode: .voiceChat,
-                              options: opts)
-      logger.info("audioSession category set")
-    } catch {
-      logger.error("setCategory failed: \(error.localizedDescription)")
-    }
+                             isIncoming: Bool,
+                             forceReconfigure: Bool = false) {
+      logger.info("configureAudioSession: video=\(isVideo), incoming=\(isIncoming), force=\(forceReconfigure)")
+
+      // For hold/unhold scenarios, we need to fully reconfigure
+      if forceReconfigure {
+          do {
+              try session.setActive(false, options: .notifyOthersOnDeactivation)
+              logger.info("deactivated audio session for reconfigure")
+          } catch {
+              logger.error("deactivate for reconfigure failed: \(error.localizedDescription)")
+          }
+      }
+
+      var opts: AVAudioSession.CategoryOptions = [.allowBluetooth, .allowBluetoothA2DP, .mixWithOthers]
+
+      // Always use defaultToSpeaker for video calls
+      // For audio calls, maintain consistent routing
+      if isVideo {
+          opts.insert(.defaultToSpeaker)
+      }
+
+      do {
+          try session.setCategory(.playAndRecord,
+                                mode: .voiceChat,
+                                options: opts)
+          logger.info("audioSession category set")
+
+          // Immediately reactivate after configuration
+          if forceReconfigure || !session.isOtherAudioPlaying {
+              try session.setActive(true)
+              logger.info("audioSession reactivated after configuration")
+          }
+      } catch {
+          logger.error("setCategory/activate failed: \(error.localizedDescription)")
+      }
+  }
+
+  // Add a method specifically for hold/unhold scenarios
+  func reconfigureAudioSessionForUnhold(forCallType isVideo: Bool) {
+      logger.info("reconfigureAudioSessionForUnhold: video=\(isVideo)")
+      configureAudioSession(forCallType: isVideo, isIncoming: false, forceReconfigure: true)
   }
 
   func activateAudioSession() {

package/ios/CallEngine.swift

@@ -169,63 +169,67 @@ class CallEngine {
 
     // MARK: Direct Active (Join Ongoing Call)
 
-    func startCall(callId: String,
-                   callType: String,
-                   targetName: String,
-                   metadata: String? = nil)
-    {
-      logger.info("startCall (join ongoing): \(callId)")
-      if let m = metadata {
-        callMetadata[callId] = m
-        logger.info("metadata cached for \(callId)")
-      }
-
-      guard activeCalls[callId] == nil else {
-        logger.warning("call \(callId) already exists")
-        return
-      }
-
-      guard validateOutgoingCallRequest() else {
-        logger.warning("rejecting join call \(callId) - conflicts")
-        emitEvent(.callRejected, data: ["callId": callId,
-                                        "reason": "Conflict with existing call"])
-        return
-      }
-
-      if canMakeMultipleCalls {
-        activeCalls.values
-          .filter { $0.state == .active }
-          .forEach { call in
-            logger.info("holding existing \(call.callId)")
-            callKitManager.setCallOnHold(callId: call.callId, onHold: true)
-          }
-      }
-
-      // Create call directly in active state
-      var info = CallInfo(callId: callId,
-                          callType: callType,
-                          displayName: targetName,
-                          pictureUrl: nil,
-                          state: .active)
-      activeCalls[callId] = info
-      currentCallId = callId
-
-      audioManager.configureAudioSession(forCallType: callType == "Video",
-                                         isIncoming: false)
-
-      // Report to CallKit as already connected outgoing call (no ringing)
-      callKitManager.reportConnectedOutgoingCall(callInfo: info) { [weak self] error in
-        if let e = error {
-          self?.logger.error("startCall reportConnected failed: \(e.localizedDescription)")
-          self?.endCallInternal(callId: callId)
-          return
-        }
-
-        self?.logger.info("startCall reported as connected - activating audio")
-        self?.audioManager.activateAudioSession()
-        self?.emitOutgoingCallAnsweredWithMetadata(callId: callId)
-      }
-    }
+   func startCall(callId: String,
+                  callType: String,
+                  targetName: String,
+                  metadata: String? = nil)
+   {
+       logger.info("startCall (modified for proper CallKit integration): \(callId)")
+       if let m = metadata {
+           callMetadata[callId] = m
+           logger.info("metadata cached for \(callId)")
+       }
+
+       guard activeCalls[callId] == nil else {
+           logger.warning("call \(callId) already exists")
+           return
+       }
+
+       guard validateOutgoingCallRequest() else {
+           logger.warning("rejecting join call \(callId) - conflicts")
+           emitEvent(.callRejected, data: ["callId": callId,
+                                           "reason": "Conflict with existing call"])
+           return
+       }
+
+       if canMakeMultipleCalls {
+           activeCalls.values
+               .filter { $0.state == .active }
+               .forEach { call in
+                   logger.info("holding existing \(call.callId)")
+                   callKitManager.setCallOnHold(callId: call.callId, onHold: true)
+               }
+       }
+
+       // Use standard outgoing call flow instead of trying to bypass it
+       var info = CallInfo(callId: callId,
+                           callType: callType,
+                           displayName: targetName,
+                           pictureUrl: nil,
+                           state: .dialing)
+       activeCalls[callId] = info
+       currentCallId = callId
+
+       audioManager.configureAudioSession(forCallType: callType == "Video",
+                                          isIncoming: false)
+
+       // Use standard outgoing call method
+       callKitManager.startOutgoingCall(callInfo: info) { [weak self] error in
+           if let e = error {
+               self?.logger.error("startCall failed: \(e.localizedDescription)")
+               self?.endCallInternal(callId: callId)
+               return
+           }
+
+           // Immediately report as connected since this is for joining ongoing calls
+           DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+               if let uuid = UUID(uuidString: callId) {
+                   self?.callKitManager.provider.reportOutgoingCall(with: uuid, connectedAt: Date())
+                   self?.logger.info("startCall: reported as connected")
+               }
+           }
+       }
+   }
   // MARK: JS Actions
 
   func answerCall(callId: String) {
@@ -415,25 +419,29 @@ extension CallEngine: CallKitManagerDelegate {
                       didSetHeld callId: String,
                       onHold: Bool)
   {
-    logger.info("didSetHeld: \(callId), onHold=\(onHold)")
-    guard var info = activeCalls[callId] else { return }
+      logger.info("didSetHeld: \(callId), onHold=\(onHold)")
+      guard var info = activeCalls[callId] else { return }
 
-    if onHold {
-      info.updateState(.held)
-      info.wasHeldBySystem = true
-      emitEvent(.callHeld, data: ["callId": callId])
-    } else {
-      info.updateState(.active)
-      info.wasHeldBySystem = false
-      currentCallId = callId
+      if onHold {
+          info.updateState(.held)
+          info.wasHeldBySystem = true
+          emitEvent(.callHeld, data: ["callId": callId])
+      } else {
+          info.updateState(.active)
+          info.wasHeldBySystem = false
+          currentCallId = callId
 
-      // Re-configure audio when unheld
-      audioManager.configureAudioSession(forCallType: info.callType == "Video",
-                                         isIncoming: false)
+          // CRITICAL FIX: Force reconfigure audio session when unholding
+          audioManager.reconfigureAudioSessionForUnhold(forCallType: info.callType == "Video")
 
-      emitEvent(.callUnheld, data: ["callId": callId])
-    }
-    activeCalls[callId] = info
+          // Give the audio session a moment to stabilize
+          DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+              self.audioManager.activateAudioSession()
+          }
+
+          emitEvent(.callUnheld, data: ["callId": callId])
+      }
+      activeCalls[callId] = info
   }
 
   func callKitManager(_ manager: CallKitManager,

package/ios/CallKitManager.swift

@@ -74,46 +74,6 @@ class CallKitManager: NSObject {
     }
   }
 
-    func reportConnectedOutgoingCall(callInfo: CallInfo,
-                                     completion: @escaping (Error?) -> Void)
-    {
-      logger.info("reportConnectedOutgoingCall: \(callInfo.callId)")
-      guard let uuid = UUID(uuidString: callInfo.callId) else {
-        let err = NSError(domain: "CallKitManager",
-                          code: -1,
-                          userInfo: [NSLocalizedDescriptionKey: "Invalid UUID"])
-        completion(err)
-        return
-      }
-
-      let handle = CXHandle(type: .generic, value: callInfo.displayName)
-      let action = CXStartCallAction(call: uuid, handle: handle)
-      action.isVideo = callInfo.callType == "Video"
-
-      let tx = CXTransaction(action: action)
-      activeCallIds.insert(callInfo.callId)
-
-      callController.request(tx) { [weak self] error in
-        if let e = error {
-          self?.logger.error("reportConnectedOutgoingCall error: \(e.localizedDescription)")
-          self?.activeCallIds.remove(callInfo.callId)
-          completion(e)
-          return
-        }
-
-        // Immediately report the call as connected (no ringing phase)
-        let update = CXCallUpdate()
-        update.remoteHandle = handle
-        update.localizedCallerName = callInfo.displayName
-        update.hasVideo = callInfo.callType == "Video"
-
-        // Report as connected at current time - this skips ringing
-        self?.provider.reportOutgoingCall(with: uuid, connectedAt: Date())
-        self?.logger.info("Call reported as immediately connected")
-        completion(nil)
-      }
-    }
-
   func startOutgoingCall(callInfo: CallInfo,
                          completion: @escaping (Error?) -> Void)
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qusaieilouti99/call-manager",
-  "version": "0.1.129",
+  "version": "0.1.130",
   "description": "Call manager",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",