@qusaieilouti99/call-manager 0.1.129 → 0.1.131

package/ios/AudioManager.swift

@@ -18,10 +18,21 @@ class AudioManager {
   private let session = AVAudioSession.sharedInstance()
   private var observers: [NSObjectProtocol] = []
 
+  // WebRTC compatibility flags
+  private var isWebRTCActive = false
+  private var isCallKitActive = false
+  private var pendingActivation = false
+
+  // Audio state management
+  private var currentCategory: AVAudioSession.Category = .playback
+  private var currentMode: AVAudioSession.Mode = .default
+  private var currentOptions: AVAudioSession.CategoryOptions = []
+
   init(delegate: AudioManagerDelegate) {
     self.delegate = delegate
     logger.info("AudioManager init")
     setupNotifications()
+    setupInitialAudioSession()
   }
 
   deinit {
@@ -44,83 +55,245 @@ class AudioManager {
         queue: nil
       ) { [weak self] n in self?.handleInterruption(n) }
     )
+    observers.append(
+      nc.addObserver(
+        forName: AVAudioSession.mediaServicesWereResetNotification,
+        object: nil,
+        queue: nil
+      ) { [weak self] _ in self?.handleMediaServicesReset() }
+    )
     logger.info("AudioManager notifications set")
   }
 
+  private func setupInitialAudioSession() {
+    logger.info("Setting up initial audio session")
+    do {
+      // Start with playback category for non-call state
+      try session.setCategory(.playback,
+                              mode: .default,
+                              options: [.mixWithOthers])
+      currentCategory = .playback
+      currentMode = .default
+      currentOptions = [.mixWithOthers]
+      logger.info("Initial audio session configured")
+    } catch {
+      logger.error("Failed to setup initial audio session: \(error.localizedDescription)")
+    }
+  }
+
+  // MARK: - WebRTC Compatible Audio Session Management
+
   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) }
+                             isIncoming: Bool,
+                             isWebRTCCall: Bool = true) {
+    logger.info("configureAudioSession: video=\(isVideo), incoming=\(isIncoming), webrtc=\(isWebRTCCall)")
+
+    isWebRTCActive = isWebRTCCall
+
+    // Define optimal configuration for VoIP calls
+    let category: AVAudioSession.Category = .playAndRecord
+    let mode: AVAudioSession.Mode = .voiceChat
+    var options: AVAudioSession.CategoryOptions = [
+      .allowBluetooth,
+      .allowBluetoothA2DP,
+      .mixWithOthers,
+      .duckOthers
+    ]
+
+    // Video calls should default to speaker
+    if isVideo {
+      options.insert(.defaultToSpeaker)
+    }
+
+    // Store configuration for later use
+    currentCategory = category
+    currentMode = mode
+    currentOptions = options
+
+    // Don't activate immediately if we're waiting for CallKit
+    if !isCallKitActive {
+      pendingActivation = true
+      logger.info("Audio session configured but not activated - waiting for CallKit")
+      return
+    }
+
+    applyAudioConfiguration()
+  }
+
+  private func applyAudioConfiguration() {
+    logger.info("Applying audio configuration: \(currentCategory), \(currentMode)")
+
     do {
-      try session.setCategory(.playAndRecord,
-                              mode: .voiceChat,
-                              options: opts)
-      logger.info("audioSession category set")
+      // First, ensure we're not active to avoid conflicts
+      if session.isOtherAudioPlaying {
+        logger.info("Other audio is playing, will configure without activation")
+      }
+
+      try session.setCategory(currentCategory,
+                              mode: currentMode,
+                              options: currentOptions)
+      logger.info("Audio session category applied successfully")
+
     } catch {
-      logger.error("setCategory failed: \(error.localizedDescription)")
+      logger.error("Failed to apply audio configuration: \(error.localizedDescription)")
     }
   }
 
+  // MARK: - CallKit Integration Points
+
   func activateAudioSession() {
-    logger.info("activateAudioSession")
+    logger.info("activateAudioSession - CallKit activation")
+    isCallKitActive = true
+
+    // Apply pending configuration if we have one
+    if pendingActivation {
+      applyAudioConfiguration()
+      pendingActivation = false
+    }
+
     do {
       try session.setActive(true)
+      logger.info("Audio session activated successfully")
       delegate?.audioManagerDidActivateAudioSession(self)
     } catch {
-      logger.error("activate failed: \(error.localizedDescription)")
+      logger.error("Failed to activate audio session: \(error.localizedDescription)")
     }
   }
 
   func deactivateAudioSession() {
-    logger.info("deactivateAudioSession")
+    logger.info("deactivateAudioSession - CallKit deactivation")
+    isCallKitActive = false
+    isWebRTCActive = false
+    pendingActivation = false
+
     do {
       try session.setActive(false, options: .notifyOthersOnDeactivation)
+      logger.info("Audio session deactivated successfully")
+
+      // Reset to default configuration for non-call state
+      try session.setCategory(.playback,
+                              mode: .default,
+                              options: [.mixWithOthers])
+      currentCategory = .playback
+      currentMode = .default
+      currentOptions = [.mixWithOthers]
+      logger.info("Audio session reset to default configuration")
+
       delegate?.audioManagerDidDeactivateAudioSession(self)
     } catch {
-      logger.error("deactivate failed: \(error.localizedDescription)")
+      logger.error("Failed to deactivate audio session: \(error.localizedDescription)")
     }
   }
 
+  // MARK: - Hold/Unhold Handling (Critical for WebRTC)
+
+  func handleCallUnhold(forCallType isVideo: Bool) {
+    logger.info("handleCallUnhold: video=\(isVideo)")
+
+    // For WebRTC calls, we need to be very careful about audio session management
+    if isWebRTCActive {
+      logger.info("Handling WebRTC call unhold")
+
+      // Briefly deactivate and reactivate to ensure clean state
+      do {
+        try session.setActive(false, options: [])
+        logger.info("Audio session briefly deactivated for unhold")
+
+        // Small delay to allow system to process
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
+          self?.reconfigureForUnhold(isVideo: isVideo)
+        }
+      } catch {
+        logger.error("Failed to deactivate for unhold: \(error.localizedDescription)")
+        // Fallback to direct reconfiguration
+        reconfigureForUnhold(isVideo: isVideo)
+      }
+    } else {
+      // Non-WebRTC calls can be handled normally
+      reconfigureForUnhold(isVideo: isVideo)
+    }
+  }
+
+  private func reconfigureForUnhold(isVideo: Bool) {
+    logger.info("Reconfiguring audio for unhold: video=\(isVideo)")
+
+    // Reconfigure with fresh settings
+    let category: AVAudioSession.Category = .playAndRecord
+    let mode: AVAudioSession.Mode = .voiceChat
+    var options: AVAudioSession.CategoryOptions = [
+      .allowBluetooth,
+      .allowBluetoothA2DP,
+      .mixWithOthers,
+      .duckOthers
+    ]
+
+    if isVideo {
+      options.insert(.defaultToSpeaker)
+    }
+
+    do {
+      try session.setCategory(category, mode: mode, options: options)
+      try session.setActive(true)
+
+      currentCategory = category
+      currentMode = mode
+      currentOptions = options
+
+      logger.info("Audio session reconfigured and activated for unhold")
+    } catch {
+      logger.error("Failed to reconfigure audio for unhold: \(error.localizedDescription)")
+    }
+  }
+
+  // MARK: - Audio Device Management
+
   func getAudioDevices() -> AudioRoutesInfo {
     let current = session.currentRoute
     var devices = ["Earpiece", "Speaker"]
+
     if let inputs = session.availableInputs {
-      for i in inputs {
-        switch i.portType {
+      for input in inputs {
+        switch input.portType {
         case .bluetoothHFP, .bluetoothA2DP, .bluetoothLE:
-          if !devices.contains("Bluetooth") { devices.append("Bluetooth") }
+          if !devices.contains("Bluetooth") {
+            devices.append("Bluetooth")
+          }
         case .headphones, .headsetMic:
-          if !devices.contains("Headset") { devices.append("Headset") }
-        default: break
+          if !devices.contains("Headset") {
+            devices.append("Headset")
+          }
+        default:
+          break
         }
       }
     }
-    let route = determineCurrentRoute()
 
-    // Convert strings to StringHolder objects
+    let route = determineCurrentRoute()
     let deviceHolders = devices.map { StringHolder(value: $0) }
-    let info = AudioRoutesInfo(devices: deviceHolders, currentRoute: route)
-    return info
+    return AudioRoutesInfo(devices: deviceHolders, currentRoute: route)
   }
 
   func setAudioRoute(_ route: String) {
     logger.info("setAudioRoute: \(route)")
+
     do {
       switch route {
       case "Speaker":
         try session.overrideOutputAudioPort(.speaker)
+      case "Earpiece", "Headset", "Bluetooth":
+        try session.overrideOutputAudioPort(.none)
       default:
         try session.overrideOutputAudioPort(.none)
       }
+      logger.info("Audio route set to: \(route)")
     } catch {
-      logger.error("overrideOutputAudioPort failed: \(error.localizedDescription)")
+      logger.error("Failed to set audio route to \(route): \(error.localizedDescription)")
     }
   }
 
   private func determineCurrentRoute() -> String {
-    for o in session.currentRoute.outputs {
-      switch o.portType {
+    for output in session.currentRoute.outputs {
+      switch output.portType {
       case .bluetoothHFP, .bluetoothA2DP, .bluetoothLE:
         return "Bluetooth"
       case .builtInSpeaker:
@@ -129,18 +302,25 @@ class AudioManager {
         return "Earpiece"
       case .headphones, .headsetMic:
         return "Headset"
-      default: continue
+      default:
+        continue
       }
     }
     return "Earpiece"
   }
 
-  private func handleRouteChange(_ n: Notification) {
-    logger.info("routeChange notification")
-    guard let rv = n.userInfo?[AVAudioSessionRouteChangeReasonKey] as? UInt,
-          let reason = AVAudioSession.RouteChangeReason(rawValue: rv)
-    else { return }
+  // MARK: - Notification Handlers
+
+  private func handleRouteChange(_ notification: Notification) {
+    logger.info("Audio route change notification")
+    guard let reasonValue = notification.userInfo?[AVAudioSessionRouteChangeReasonKey] as? UInt,
+          let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue)
+    else {
+      return
+    }
+
     let info = getAudioDevices()
+
     switch reason {
     case .newDeviceAvailable, .oldDeviceUnavailable:
       delegate?.audioManager(self, didChangeDevices: info)
@@ -149,23 +329,37 @@ class AudioManager {
     }
   }
 
-  private func handleInterruption(_ n: Notification) {
-    logger.info("interruption notification")
-    guard let tv = n.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt,
-          let type = AVAudioSession.InterruptionType(rawValue: tv)
-    else { return }
+  private func handleInterruption(_ notification: Notification) {
+    logger.info("Audio interruption notification")
+    guard let typeValue = notification.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt,
+          let type = AVAudioSession.InterruptionType(rawValue: typeValue)
+    else {
+      return
+    }
+
     switch type {
     case .began:
-      logger.info("interruption began")
+      logger.info("Audio interruption began")
     case .ended:
-      logger.info("interruption ended")
-      if let ov = n.userInfo?[AVAudioSessionInterruptionOptionKey] as? UInt {
-        let opts = AVAudioSession.InterruptionOptions(rawValue: ov)
-        if opts.contains(.shouldResume) {
+      logger.info("Audio interruption ended")
+      if let optionsValue = notification.userInfo?[AVAudioSessionInterruptionOptionKey] as? UInt {
+        let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
+        if options.contains(.shouldResume) && isCallKitActive {
+          logger.info("Resuming audio session after interruption")
           activateAudioSession()
         }
       }
-    @unknown default: break
+    @unknown default:
+      break
+    }
+  }
+
+  private func handleMediaServicesReset() {
+    logger.warning("Media services were reset - reconfiguring audio")
+    if isCallKitActive {
+      // Reconfigure the audio session
+      applyAudioConfiguration()
+      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,24 @@ 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: Use the new WebRTC-compatible unhold handling
+          audioManager.handleCallUnhold(forCallType: info.callType == "Video")
 
-      emitEvent(.callUnheld, data: ["callId": callId])
-    }
-    activeCalls[callId] = info
+          emitEvent(.callUnheld, data: ["callId": callId])
+      }
+      activeCalls[callId] = info
   }
 
   func callKitManager(_ manager: CallKitManager,
@@ -462,17 +465,16 @@ extension CallEngine: CallKitManagerDelegate {
   func callKitManager(_ manager: CallKitManager,
                       didActivateAudioSession session: AVAudioSession)
   {
-    logger.info("CallKit didActivate audioSession")
-    audioManager.activateAudioSession()
+      logger.info("CallKit didActivate audioSession")
+      audioManager.activateAudioSession()
   }
 
   func callKitManager(_ manager: CallKitManager,
                       didDeactivateAudioSession session: AVAudioSession)
   {
-    logger.info("CallKit didDeactivate audioSession")
-    audioManager.deactivateAudioSession()
+      logger.info("CallKit didDeactivate audioSession")
+      audioManager.deactivateAudioSession()
   }
-}
 
 // MARK: AudioManagerDelegate
 

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.131",
   "description": "Call manager",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",