@qusaieilouti99/call-manager 0.1.64 → 0.1.66

package/android/src/main/java/com/margelo/nitro/qusaieilouti99/callmanager/CallEngine.kt

@@ -44,8 +44,6 @@ object CallEngine {
     private const val PHONE_ACCOUNT_ID = "com.qusaieilouti99.callmanager.SELF_MANAGED"
     private const val NOTIF_CHANNEL_ID = "incoming_call_channel"
     private const val NOTIF_ID = 2001
-    private const val FOREGROUND_CHANNEL_ID = "call_foreground_channel"
-    private const val FOREGROUND_NOTIF_ID = 1001
 
     // Core context - initialized once and maintained
     @Volatile
@@ -53,12 +51,13 @@ object CallEngine {
     private val isInitialized = AtomicBoolean(false)
     private val initializationLock = Any()
 
-    // Audio & Media
+    // Audio & Media - SIMPLIFIED
     private var ringtone: android.media.Ringtone? = null
     private var ringbackPlayer: MediaPlayer? = null
     private var audioManager: AudioManager? = null
     private var wakeLock: PowerManager.WakeLock? = null
     private var audioFocusRequest: AudioFocusRequest? = null
+    private var hasAudioFocus: Boolean = false
 
     // Call State Management
     private val activeCalls = ConcurrentHashMap<String, CallInfo>()
@@ -68,10 +67,8 @@ object CallEngine {
     private var currentCallId: String? = null
     private var canMakeMultipleCalls: Boolean = false
 
-    // Audio State Tracking
+    // Audio State Tracking - SIMPLIFIED
     private var lastAudioRoutesInfo: AudioRoutesInfo? = null
-    private var hasAudioFocus: Boolean = false
-    private var isSystemCallActive: Boolean = false
 
     // Lock Screen Bypass
     private var lockScreenBypassActive = false
@@ -85,25 +82,17 @@ object CallEngine {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    // --- INITIALIZATION - Fixed for better context management ---
+    // --- INITIALIZATION ---
     fun initialize(context: Context) {
         synchronized(initializationLock) {
             if (isInitialized.compareAndSet(false, true)) {
                 appContext = context.applicationContext
                 audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
-                Log.d(TAG, "CallEngine initialized successfully with context: ${context.javaClass.simpleName}")
-
-                // Verify critical services are available
-                if (audioManager == null) {
-                    Log.w(TAG, "AudioManager is null after initialization")
-                }
+                Log.d(TAG, "CallEngine initialized successfully")
 
-                // Initialize foreground service if needed
                 if (isCallActive()) {
                     startForegroundService()
                 }
-            } else {
-                Log.d(TAG, "CallEngine already initialized, skipping")
             }
         }
     }
@@ -112,7 +101,7 @@ object CallEngine {
 
     private fun requireContext(): Context {
         return appContext ?: throw IllegalStateException(
-            "CallEngine not initialized. Ensure CallEngine.initialize(context) is called in Application.onCreate() before any module usage."
+            "CallEngine not initialized. Call initialize() in Application.onCreate()"
         )
     }
 
@@ -129,93 +118,41 @@ object CallEngine {
         }
     }
 
-    // Made public for MyConnection
     fun emitEvent(type: CallEventType, data: JSONObject) {
-        Log.d(TAG, "Emitting event: $type, data: $data")
+        Log.d(TAG, "Emitting event: $type")
         val dataString = data.toString()
         if (eventHandler != null) {
             eventHandler?.invoke(type, dataString)
         } else {
-            Log.d(TAG, "No event handler registered, caching event: $type")
+            Log.d(TAG, "No event handler, caching event: $type")
             cachedEvents.add(Pair(type, dataString))
         }
     }
 
-    // --- FIXED Audio Focus Management ---
+    // --- SIMPLIFIED Audio Focus Management ---
     private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
         Log.d(TAG, "Audio focus changed: $focusChange")
         when (focusChange) {
             AudioManager.AUDIOFOCUS_LOSS -> {
-                Log.d(TAG, "Permanent audio focus loss - another app took focus")
-                hasAudioFocus = false
-                isSystemCallActive = true
-                holdSystemCalls()
-            }
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-                Log.d(TAG, "Transient audio focus loss - temporary interruption")
-                hasAudioFocus = false
-                isSystemCallActive = true
-                holdSystemCalls()
-            }
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
-                Log.d(TAG, "Audio focus loss with ducking - lowering volume but keeping active")
-                // Don't hold the call for ducking, just lower volume
+                // Only hold calls on PERMANENT audio focus loss (like system calls)
+                Log.d(TAG, "Permanent audio focus loss - holding calls")
                 hasAudioFocus = false
+                holdAllActiveCalls(heldBySystem = true)
             }
             AudioManager.AUDIOFOCUS_GAIN -> {
-                Log.d(TAG, "Audio focus gained")
+                Log.d(TAG, "Audio focus gained - resuming held calls")
                 hasAudioFocus = true
-                isSystemCallActive = false
-                // Delay resuming to avoid rapid hold/unhold cycles
                 Handler(Looper.getMainLooper()).postDelayed({
                     resumeSystemHeldCalls()
-                }, 500)  // Reduced from 1000ms
-            }
-            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT -> {
-                Log.d(TAG, "Transient audio focus gained")
-                hasAudioFocus = true
+                }, 1000)
             }
-        }
-        updateForegroundNotification()
-    }
-
-    private fun holdSystemCalls() {
-        val callsToHold = activeCalls.values.filter {
-            it.state == CallState.ACTIVE && !it.wasHeldBySystem
-        }
-
-        if (callsToHold.isEmpty()) {
-            Log.d(TAG, "No active calls to hold due to audio focus loss")
-            return
-        }
-
-        Log.d(TAG, "Holding ${callsToHold.size} calls due to audio focus loss")
-        callsToHold.forEach { call ->
-            // Add a small delay to prevent holding immediately after answering
-            val timeSinceAnswer = System.currentTimeMillis() - call.timestamp
-            if (timeSinceAnswer > 2000) {  // Only hold if call has been active for 2+ seconds
-                holdCallInternal(call.callId, heldBySystem = true)
-            } else {
-                Log.d(TAG, "Skipping hold for recently answered call: ${call.callId}")
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT,
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                // Don't hold calls for transient losses - just note we lost focus
+                Log.d(TAG, "Transient audio focus loss - keeping calls active")
+                hasAudioFocus = false
             }
         }
-        stopRingback()
-    }
-
-    private fun resumeSystemHeldCalls() {
-        val callsToResume = activeCalls.values.filter {
-            it.state == CallState.HELD && it.wasHeldBySystem
-        }
-
-        if (callsToResume.isEmpty()) {
-            Log.d(TAG, "No system-held calls to resume")
-            return
-        }
-
-        Log.d(TAG, "Resuming ${callsToResume.size} system-held calls")
-        callsToResume.forEach { call ->
-            unholdCallInternal(call.callId, resumedBySystem = true)
-        }
     }
 
     private fun requestAudioFocus(): Boolean {
@@ -231,8 +168,8 @@ object CallEngine {
                             .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                             .build()
                     )
-                    .setOnAudioFocusChangeListener(audioFocusChangeListener, Handler(Looper.getMainLooper()))
-                    .setAcceptsDelayedFocusGain(true)  // Added this
+                    .setOnAudioFocusChangeListener(audioFocusChangeListener)
+                    .setAcceptsDelayedFocusGain(true)
                     .build()
             }
             val result = audioManager?.requestAudioFocus(audioFocusRequest!!)
@@ -247,7 +184,6 @@ object CallEngine {
                 AudioManager.AUDIOFOCUS_GAIN
             )
             hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
-            Log.d(TAG, "Audio focus request result (legacy): $result (granted: $hasAudioFocus)")
             hasAudioFocus
         }
     }
@@ -267,6 +203,18 @@ object CallEngine {
         Log.d(TAG, "Audio focus abandoned")
     }
 
+    private fun holdAllActiveCalls(heldBySystem: Boolean) {
+        activeCalls.values.filter { it.state == CallState.ACTIVE }.forEach { call ->
+            holdCallInternal(call.callId, heldBySystem = heldBySystem)
+        }
+    }
+
+    private fun resumeSystemHeldCalls() {
+        activeCalls.values.filter { it.state == CallState.HELD && it.wasHeldBySystem }.forEach { call ->
+            unholdCallInternal(call.callId, resumedBySystem = true)
+        }
+    }
+
     // --- Lock Screen Bypass Management ---
     fun registerLockScreenBypassCallback(callback: LockScreenBypassCallback) {
         lockScreenBypassCallbacks.add(callback)
@@ -296,12 +244,12 @@ object CallEngine {
     // --- Telecom Connection Management ---
     fun addTelecomConnection(callId: String, connection: Connection) {
         telecomConnections[callId] = connection
-        Log.d(TAG, "Added Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
+        Log.d(TAG, "Added Telecom Connection for callId: $callId")
     }
 
     fun removeTelecomConnection(callId: String) {
         telecomConnections.remove(callId)?.let {
-            Log.d(TAG, "Removed Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
+            Log.d(TAG, "Removed Telecom Connection for callId: $callId")
         }
     }
 
@@ -319,9 +267,7 @@ object CallEngine {
         calls.forEach {
             jsonArray.put(it.toJsonObject())
         }
-        val result = jsonArray.toString()
-        Log.d(TAG, "Current call state: $result")
-        return result
+        return jsonArray.toString()
     }
 
     // --- Incoming Call Management ---
@@ -368,7 +314,7 @@ object CallEngine {
 
         activeCalls[callId] = CallInfo(callId, callType, displayName, pictureUrl, CallState.INCOMING)
         currentCallId = callId
-        Log.d(TAG, "Call $callId added to activeCalls. State: INCOMING, callType: $callType")
+        Log.d(TAG, "Call $callId added to activeCalls. State: INCOMING")
 
         showIncomingCallUI(callId, displayName, callType)
         registerPhoneAccount()
@@ -387,9 +333,6 @@ object CallEngine {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
             startForegroundService()
             Log.d(TAG, "Successfully reported incoming call to TelecomManager for $callId")
-        } catch (e: SecurityException) {
-            Log.e(TAG, "SecurityException: Failed to report incoming call. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
-            endCallInternal(callId)
         } catch (e: Exception) {
             Log.e(TAG, "Failed to report incoming call: ${e.message}", e)
             endCallInternal(callId)
@@ -435,7 +378,6 @@ object CallEngine {
         val phoneAccountHandle = getPhoneAccountHandle()
         val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, targetName, null)
 
-        // Build a bundle of ONLY your own keys
         val outgoingExtras = Bundle().apply {
             putString(MyConnectionService.EXTRA_CALL_ID, callId)
             putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
@@ -444,7 +386,6 @@ object CallEngine {
             metadata?.let { putString("metadata", it) }
         }
 
-        // Wrap under the single Telecom-honored key
         val extras = Bundle().apply {
             putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
             putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
@@ -455,21 +396,14 @@ object CallEngine {
             telecomManager.placeCall(addressUri, extras)
             startForegroundService()
 
-            // FIXED: Request audio focus BEFORE starting ringback
-            val audioFocusGranted = requestAudioFocus()
-            if (audioFocusGranted) {
-                startRingback()
-            } else {
-                Log.w(TAG, "Audio focus not granted for outgoing call, skipping ringback")
-            }
+            // SIMPLIFIED: Request audio focus and start ringback
+            requestAudioFocus()
+            startRingback()
 
             bringAppToForeground()
             keepScreenAwake(true)
             setInitialAudioRoute(callType)
             Log.d(TAG, "Successfully reported outgoing call to TelecomManager")
-        } catch (e: SecurityException) {
-            Log.e(TAG, "SecurityException placing outgoing call: ${e.message}", e)
-            endCallInternal(callId)
         } catch (e: Exception) {
             Log.e(TAG, "Failed to start outgoing call: ${e.message}", e)
             endCallInternal(callId)
@@ -478,14 +412,12 @@ object CallEngine {
         updateLockScreenBypass()
     }
 
-    // Fixed: Start call as active (not dialing) with foreground service
     fun startCall(
         callId: String,
         callType: String,
         targetName: String,
         metadata: String? = null
     ) {
-        val context = requireContext()
         Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -506,7 +438,7 @@ object CallEngine {
         // Start directly as active call
         activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
         currentCallId = callId
-        Log.d(TAG, "Call $callId started as ACTIVE, callType: $callType")
+        Log.d(TAG, "Call $callId started as ACTIVE")
 
         registerPhoneAccount()
         requestAudioFocus()
@@ -516,11 +448,11 @@ object CallEngine {
         setInitialAudioRoute(callType)
         updateLockScreenBypass()
 
-        // Emit outgoing call answered event with metadata for JS-initiated calls
+        // Emit outgoing call answered event
         emitOutgoingCallAnsweredWithMetadata(callId)
     }
 
-    // --- Call Answer Management ---
+    // --- Call Answer Management - SIMPLIFIED ---
     fun callAnsweredFromJS(callId: String) {
         Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
         coreCallAnswered(callId, isLocalAnswer = false)
@@ -531,9 +463,8 @@ object CallEngine {
         coreCallAnswered(callId, isLocalAnswer = true)
     }
 
-    // FIXED: Core Call Answered Method with proper audio focus handling
+    // SIMPLIFIED: Always succeed call answer, handle audio focus gracefully
     private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
-        val context = requireContext()
         Log.d(TAG, "coreCallAnswered: $callId, isLocalAnswer: $isLocalAnswer")
 
         val callInfo = activeCalls[callId]
@@ -542,27 +473,18 @@ object CallEngine {
             return
         }
 
-        // FIXED: Request audio focus FIRST, before stopping media
-        val audioFocusGranted = requestAudioFocus()
-        if (!audioFocusGranted) {
-            Log.w(TAG, "Failed to get audio focus for call $callId, but continuing...")
-            // Don't fail the call, but warn about audio issues
-        }
+        // ALWAYS set call to ACTIVE - don't fail due to audio focus
+        activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
+        currentCallId = callId
+        Log.d(TAG, "Call $callId set to ACTIVE state")
 
-        // Stop media AFTER getting audio focus
+        // Clean up media and UI
         stopRingtone()
         stopRingback()
         cancelIncomingCallUI()
 
-        // FIXED: Only set call to ACTIVE if we have audio focus OR if it's a remote answer
-        if (audioFocusGranted || !isLocalAnswer) {
-            activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
-            currentCallId = callId
-            Log.d(TAG, "Call $callId set to ACTIVE state")
-        } else {
-            Log.w(TAG, "Call $callId not set to ACTIVE due to audio focus failure")
-            return
-        }
+        // Request audio focus (but don't fail if not granted)
+        requestAudioFocus()
 
         if (!canMakeMultipleCalls) {
             activeCalls.filter { it.key != callId }.values.forEach { otherCall ->
@@ -575,20 +497,17 @@ object CallEngine {
         bringAppToForeground()
         startForegroundService()
         keepScreenAwake(true)
-        resetAudioMode()
+        setAudioMode()
         updateLockScreenBypass()
-        updateForegroundNotification()
 
-        // FIXED: Emit different events based on call direction
+        // Always emit events based on call direction
         if (isLocalAnswer) {
-            // This is for incoming calls - user answered locally
             emitCallAnsweredWithMetadata(callId)
         } else {
-            // This is for outgoing calls - remote party answered
             emitOutgoingCallAnsweredWithMetadata(callId)
         }
 
-        Log.d(TAG, "Call $callId successfully answered and UI cleaned up")
+        Log.d(TAG, "Call $callId successfully answered")
     }
 
     // For incoming calls (local answer)
@@ -605,8 +524,7 @@ object CallEngine {
                 try {
                     put("metadata", JSONObject(it))
                 } catch (e: Exception) {
-                    Log.w(TAG, "Invalid metadata JSON for callId: $callId", e)
-                    put("metadata", it) // fallback to string
+                    put("metadata", it)
                 }
             }
         })
@@ -626,8 +544,7 @@ object CallEngine {
                 try {
                     put("metadata", JSONObject(it))
                 } catch (e: Exception) {
-                    Log.w(TAG, "Invalid metadata JSON for callId: $callId", e)
-                    put("metadata", it) // fallback to string
+                    put("metadata", it)
                 }
             }
         })
@@ -640,21 +557,16 @@ object CallEngine {
 
     fun setOnHold(callId: String, onHold: Boolean) {
         Log.d(TAG, "setOnHold: $callId, onHold: $onHold")
-
         val callInfo = activeCalls[callId]
         if (callInfo == null) {
-            Log.w(TAG, "Cannot set hold state for call $callId - not found in active calls")
+            Log.w(TAG, "Cannot set hold state for call $callId - not found")
             return
         }
 
-        if (onHold) {
-            if (callInfo.state == CallState.ACTIVE) {
-                holdCallInternal(callId, heldBySystem = false)
-            }
-        } else {
-            if (callInfo.state == CallState.HELD) {
-                unholdCallInternal(callId, resumedBySystem = false)
-            }
+        if (onHold && callInfo.state == CallState.ACTIVE) {
+            holdCallInternal(callId, heldBySystem = false)
+        } else if (!onHold && callInfo.state == CallState.HELD) {
+            unholdCallInternal(callId, resumedBySystem = false)
         }
     }
 
@@ -662,7 +574,7 @@ object CallEngine {
         Log.d(TAG, "holdCallInternal: $callId, heldBySystem: $heldBySystem")
         val callInfo = activeCalls[callId]
         if (callInfo?.state != CallState.ACTIVE) {
-            Log.w(TAG, "Cannot hold call $callId - not in active state (current: ${callInfo?.state})")
+            Log.w(TAG, "Cannot hold call $callId - not in active state")
             return
         }
 
@@ -671,9 +583,7 @@ object CallEngine {
             wasHeldBySystem = heldBySystem
         )
 
-        val connection = telecomConnections[callId]
-        connection?.setOnHold()
-
+        telecomConnections[callId]?.setOnHold()
         updateForegroundNotification()
         emitEvent(CallEventType.CALL_HELD, JSONObject().put("callId", callId))
         updateLockScreenBypass()
@@ -687,29 +597,19 @@ object CallEngine {
         Log.d(TAG, "unholdCallInternal: $callId, resumedBySystem: $resumedBySystem")
         val callInfo = activeCalls[callId]
         if (callInfo?.state != CallState.HELD) {
-            Log.w(TAG, "Cannot unhold call $callId - not in held state (current: ${callInfo?.state})")
+            Log.w(TAG, "Cannot unhold call $callId - not in held state")
             return
         }
 
-        // FIXED: Simplified audio focus check to prevent UNHELD FAILED
-        if (!hasAudioFocus && !resumedBySystem && !requestAudioFocus()) {
-            Log.w(TAG, "Failed to get audio focus for unhold - but continuing anyway")
-            // Don't emit UNHELD FAILED - just continue
-        }
-
         activeCalls[callId] = callInfo.copy(
             state = CallState.ACTIVE,
             wasHeldBySystem = false
         )
 
-        val connection = telecomConnections[callId]
-        connection?.setActive()
-
+        telecomConnections[callId]?.setActive()
         updateForegroundNotification()
         emitEvent(CallEventType.CALL_UNHELD, JSONObject().put("callId", callId))
         updateLockScreenBypass()
-
-        Log.d(TAG, "Call $callId successfully unheld")
     }
 
     fun muteCall(callId: String) {
@@ -721,18 +621,17 @@ object CallEngine {
     }
 
     fun setMuted(callId: String, muted: Boolean) {
-        Log.d(TAG, "setMuted: $callId, muted: $muted")
         setMutedInternal(callId, muted)
     }
 
     private fun setMutedInternal(callId: String, muted: Boolean) {
-        val context = requireContext()
         val callInfo = activeCalls[callId]
         if (callInfo == null) {
-            Log.w(TAG, "Cannot set mute state for call $callId - not found in active calls")
+            Log.w(TAG, "Cannot set mute state for call $callId - not found")
             return
         }
 
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
         val wasMuted = audioManager?.isMicrophoneMute ?: false
@@ -752,11 +651,8 @@ object CallEngine {
     }
 
     fun endAllCalls() {
-        Log.d(TAG, "endAllCalls: Ending all active calls.")
-        if (activeCalls.isEmpty()) {
-            Log.d(TAG, "No active calls, nothing to do.")
-            return
-        }
+        Log.d(TAG, "endAllCalls: Ending all active calls")
+        if (activeCalls.isEmpty()) return
 
         activeCalls.keys.toList().forEach { callId ->
             endCallInternal(callId)
@@ -767,7 +663,7 @@ object CallEngine {
         callMetadata.clear()
         currentCallId = null
 
-        finalCleanup()
+        cleanup()
         updateLockScreenBypass()
     }
 
@@ -779,12 +675,10 @@ object CallEngine {
             return
         }
 
-        // Get metadata before removing
         val metadata = callMetadata.remove(callId)
 
         activeCalls[callId] = callInfo.copy(state = CallState.ENDED)
         activeCalls.remove(callId)
-        Log.d(TAG, "Call $callId removed from activeCalls. Remaining: ${activeCalls.size}")
 
         stopRingback()
         stopRingtone()
@@ -792,7 +686,6 @@ object CallEngine {
 
         if (currentCallId == callId) {
             currentCallId = activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
-            Log.d(TAG, "Current call was $callId. New currentCallId: $currentCallId")
         }
 
         val connection = telecomConnections[callId]
@@ -800,11 +693,10 @@ object CallEngine {
             connection.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
             connection.destroy()
             removeTelecomConnection(callId)
-            Log.d(TAG, "Telecom Connection for $callId disconnected and destroyed.")
         }
 
         if (activeCalls.isEmpty()) {
-            finalCleanup()
+            cleanup()
         } else {
             updateForegroundNotification()
         }
@@ -818,8 +710,7 @@ object CallEngine {
                 try {
                     put("metadata", JSONObject(it))
                 } catch (e: Exception) {
-                    Log.w(TAG, "Invalid metadata JSON for callId: $callId", e)
-                    put("metadata", it) // fallback to string
+                    put("metadata", it)
                 }
             }
         })
@@ -829,7 +720,6 @@ object CallEngine {
     fun getAudioDevices(): AudioRoutesInfo {
         val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
-            Log.e(TAG, "getAudioDevices: AudioManager is null. Returning default.")
             return AudioRoutesInfo(emptyArray(), "Unknown")
         }
 
@@ -865,15 +755,13 @@ object CallEngine {
             else -> "Earpiece"
         }
 
-        val result = AudioRoutesInfo(devices.toTypedArray(), currentRoute)
-        Log.d(TAG, "Audio devices info: $result")
-        return result
+        return AudioRoutesInfo(devices.toTypedArray(), currentRoute)
     }
 
     fun setAudioRoute(route: String) {
         val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-        Log.d(TAG, "Attempting to set audio route to: $route. Current mode: ${audioManager?.mode}")
+        Log.d(TAG, "Setting audio route to: $route")
 
         val previousRoute = getCurrentAudioRoute()
 
@@ -883,26 +771,22 @@ object CallEngine {
 
         when (route) {
             "Speaker" -> {
-                Log.d(TAG, "Setting audio route to Speaker.")
                 audioManager?.isSpeakerphoneOn = true
                 audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
             }
             "Earpiece" -> {
-                Log.d(TAG, "Setting audio route to Earpiece.")
                 audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
             }
             "Bluetooth" -> {
-                Log.d(TAG, "Setting audio route to Bluetooth.")
                 audioManager?.startBluetoothSco()
                 audioManager?.isBluetoothScoOn = true
                 audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
             }
             "Headset" -> {
-                Log.d(TAG, "Setting audio route to Headset (wired).")
                 audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
             }
             else -> {
-                Log.w(TAG, "Unknown audio route: $route. No action taken.")
+                Log.w(TAG, "Unknown audio route: $route")
                 return
             }
         }
@@ -932,34 +816,31 @@ object CallEngine {
             else -> "Earpiece"
         }
 
-        Log.d(TAG, "Setting initial audio route for $callType call: $defaultRoute")
+        Log.d(TAG, "Setting initial audio route: $defaultRoute")
         setAudioRoute(defaultRoute)
     }
 
+    private fun setAudioMode() {
+        audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
+    }
+
     private fun resetAudioMode() {
-        val context = requireContext()
-        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         if (activeCalls.isEmpty()) {
-            Log.d(TAG, "Resetting audio mode to NORMAL as no active calls remain.")
             audioManager?.mode = AudioManager.MODE_NORMAL
             audioManager?.stopBluetoothSco()
             audioManager?.isBluetoothScoOn = false
             audioManager?.isSpeakerphoneOn = false
             abandonAudioFocus()
-        } else {
-            Log.d(TAG, "Audio mode not reset; ${activeCalls.size} calls still active.")
         }
     }
 
     // --- Audio Device Callback ---
     private val audioDeviceCallback = object : AudioDeviceCallback() {
         override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
-            Log.d(TAG, "Audio devices added. Checking for changes.")
             emitAudioDevicesChangedIfNeeded()
         }
 
         override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
-            Log.d(TAG, "Audio devices removed. Checking for changes.")
             emitAudioDevicesChangedIfNeeded()
         }
     }
@@ -968,14 +849,12 @@ object CallEngine {
         val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         audioManager?.registerAudioDeviceCallback(audioDeviceCallback, null)
-        Log.d(TAG, "Audio device callback registered.")
     }
 
     fun unregisterAudioDeviceCallback() {
         val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
-        Log.d(TAG, "Audio device callback unregistered.")
     }
 
     private fun emitAudioDevicesChangedIfNeeded() {
@@ -1004,14 +883,14 @@ object CallEngine {
                     PowerManager.SCREEN_DIM_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP,
                     "CallEngine:WakeLock"
                 )
-                wakeLock?.acquire(10 * 60 * 1000L /* 10 minutes */)
-                Log.d(TAG, "Acquired SCREEN_DIM_WAKE_LOCK.")
+                wakeLock?.acquire(10 * 60 * 1000L)
+                Log.d(TAG, "Acquired SCREEN_DIM_WAKE_LOCK")
             }
         } else {
             wakeLock?.let {
                 if (it.isHeld) {
                     it.release()
-                    Log.d(TAG, "Released SCREEN_DIM_WAKE_LOCK.")
+                    Log.d(TAG, "Released SCREEN_DIM_WAKE_LOCK")
                 }
             }
             wakeLock = null
@@ -1035,17 +914,7 @@ object CallEngine {
     }
 
     private fun rejectIncomingCallCollision(callId: String, reason: String) {
-        // Remove metadata for rejected call
         callMetadata.remove(callId)
-
-        CoroutineScope(Dispatchers.IO).launch {
-            try {
-                Log.d(TAG, "Server rejection request would be made here for callId: $callId, reason: $reason")
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to send rejection to server", e)
-            }
-        }
-
         emitEvent(CallEventType.CALL_REJECTED, JSONObject().apply {
             put("callId", callId)
             put("reason", reason)
@@ -1081,13 +950,12 @@ object CallEngine {
 
             val manager = context.getSystemService(NotificationManager::class.java)
             manager.createNotificationChannel(channel)
-            Log.d(TAG, "Notification channel '$NOTIF_CHANNEL_ID' created/updated.")
         }
     }
 
     private fun showIncomingCallUI(callId: String, callerName: String, callType: String) {
         val context = requireContext()
-        Log.d(TAG, "Showing incoming call UI for $callId, caller: $callerName, callType: $callType")
+        Log.d(TAG, "Showing incoming call UI for $callId")
         createNotificationChannel()
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
@@ -1153,33 +1021,27 @@ object CallEngine {
         setInitialAudioRoute(callType)
     }
 
-    // Made public for CallActivity
     fun cancelIncomingCallUI() {
         val context = requireContext()
-        Log.d(TAG, "Cancelling incoming call UI.")
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(NOTIF_ID)
         stopRingtone()
     }
 
-    // --- Service Management ---
+    // --- Service Management - SIMPLIFIED ---
     private fun startForegroundService() {
         val context = requireContext()
-        Log.d(TAG, "Starting CallForegroundService.")
-
         val currentCall = activeCalls.values.find {
             it.state == CallState.ACTIVE || it.state == CallState.INCOMING ||
             it.state == CallState.DIALING || it.state == CallState.HELD
         }
 
         val intent = Intent(context, CallForegroundService::class.java)
-
         if (currentCall != null) {
             intent.putExtra("callId", currentCall.callId)
             intent.putExtra("callType", currentCall.callType)
             intent.putExtra("displayName", currentCall.displayName)
             intent.putExtra("state", currentCall.state.name)
-            Log.d(TAG, "Starting foreground service with call info: ${currentCall.callId}")
         }
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -1191,11 +1053,14 @@ object CallEngine {
 
     private fun stopForegroundService() {
         val context = requireContext()
-        Log.d(TAG, "Stopping CallForegroundService.")
         val intent = Intent(context, CallForegroundService::class.java)
         context.stopService(intent)
     }
 
+    private fun updateForegroundNotification() {
+        startForegroundService() // Just restart the service with updated info
+    }
+
     private fun bringAppToForeground() {
         val context = requireContext()
         val packageName = context.packageName
@@ -1204,11 +1069,6 @@ object CallEngine {
 
         if (isCallActive()) {
             launchIntent?.putExtra("BYPASS_LOCK_SCREEN", true)
-            launchIntent?.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
-            Log.d(TAG, "App brought to foreground with lock screen bypass request for active call")
-        } else {
-            launchIntent?.removeExtra("BYPASS_LOCK_SCREEN")
-            Log.d(TAG, "App brought to foreground without lock screen bypass")
         }
 
         try {
@@ -1234,14 +1094,10 @@ object CallEngine {
 
             try {
                 telecomManager.registerPhoneAccount(phoneAccount)
-                Log.d(TAG, "PhoneAccount registered successfully.")
-            } catch (e: SecurityException) {
-                Log.e(TAG, "SecurityException: Cannot register PhoneAccount. Missing MANAGE_OWN_CALLS permission?", e)
+                Log.d(TAG, "PhoneAccount registered successfully")
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to register PhoneAccount: ${e.message}", e)
             }
-        } else {
-            Log.d(TAG, "PhoneAccount already registered.")
         }
     }
 
@@ -1257,115 +1113,65 @@ object CallEngine {
     private fun playRingtone() {
         val context = requireContext()
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            Log.d(TAG, "playRingtone: Android S+ detected, system will handle ringtone via Telecom.")
-            return
+            return // System handles it
         }
 
         try {
-            Log.d(TAG, "Playing ringtone (for Android < S).")
             val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
             ringtone = RingtoneManager.getRingtone(context, uri)
-            ringtone?.audioAttributes = AudioAttributes.Builder()
-                .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
-                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                .build()
             ringtone?.play()
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to play ringtone: ${e.message}", e)
+            Log.e(TAG, "Failed to play ringtone: ${e.message}")
         }
     }
 
-    // Made public for CallActivity and CallManager
     fun stopRingtone() {
         try {
-            if (ringtone?.isPlaying == true) {
-                ringtone?.stop()
-                Log.d(TAG, "Ringtone stopped.")
-            }
+            ringtone?.stop()
         } catch (e: Exception) {
-            Log.e(TAG, "Error stopping ringtone: ${e.message}", e)
+            Log.e(TAG, "Error stopping ringtone: ${e.message}")
         }
         ringtone = null
     }
 
     private fun startRingback() {
         val context = requireContext()
-        if (ringbackPlayer?.isPlaying == true) {
-            Log.d(TAG, "Ringback tone already playing.")
-            return
-        }
+        if (ringbackPlayer?.isPlaying == true) return
 
         try {
             val ringbackUri = Uri.parse("android.resource://${context.packageName}/raw/ringback_tone")
             ringbackPlayer = MediaPlayer.create(context, ringbackUri)
-            if (ringbackPlayer == null) {
-                Log.e(TAG, "Failed to create MediaPlayer for ringback. Check raw/ringback_tone.mp3 exists.")
-                return
-            }
-
             ringbackPlayer?.apply {
                 isLooping = true
-                setAudioAttributes(
-                    AudioAttributes.Builder()
-                        .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION_SIGNALLING)
-                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-                        .build()
-                )
                 start()
-                Log.d(TAG, "Ringback tone started.")
             }
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to play ringback tone: ${e.message}", e)
+            Log.e(TAG, "Failed to play ringback tone: ${e.message}")
         }
     }
 
     private fun stopRingback() {
         try {
-            if (ringbackPlayer?.isPlaying == true) {
-                ringbackPlayer?.stop()
-                ringbackPlayer?.release()
-                Log.d(TAG, "Ringback tone stopped and released.")
-            }
+            ringbackPlayer?.stop()
+            ringbackPlayer?.release()
         } catch (e: Exception) {
-            Log.e(TAG, "Error stopping ringback tone: ${e.message}", e)
+            Log.e(TAG, "Error stopping ringback: ${e.message}")
         } finally {
             ringbackPlayer = null
         }
     }
 
-    private fun updateForegroundNotification() {
-        val context = requireContext()
-        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
-        val heldCall = activeCalls.values.find { it.state == CallState.HELD }
-
-        val callToShow = activeCall ?: heldCall
-        callToShow?.let {
-            val intent = Intent(context, CallForegroundService::class.java)
-            intent.putExtra("UPDATE_NOTIFICATION", true)
-            intent.putExtra("callId", it.callId)
-            intent.putExtra("callType", it.callType)
-            intent.putExtra("displayName", it.displayName)
-            intent.putExtra("state", it.state.name)
-
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(intent)
-            } else {
-                context.startService(intent)
-            }
-        }
-    }
-
-    private fun finalCleanup() {
-        Log.d(TAG, "Performing final cleanup - no active calls remaining")
+    // --- Cleanup - SIMPLIFIED ---
+    private fun cleanup() {
+        Log.d(TAG, "Performing cleanup")
         stopForegroundService()
         keepScreenAwake(false)
         resetAudioMode()
-        isSystemCallActive = false
     }
 
     // --- Lifecycle Management ---
     fun onApplicationTerminate() {
-        Log.d(TAG, "Application terminating - cleaning up all calls")
+        Log.d(TAG, "Application terminating")
 
         // End all calls properly
         activeCalls.keys.toList().forEach { callId ->
@@ -1380,8 +1186,7 @@ object CallEngine {
         callMetadata.clear()
         currentCallId = null
 
-        // Release resources
-        finalCleanup()
+        cleanup()
 
         // Clear callbacks
         lockScreenBypassCallbacks.clear()

package/android/src/main/java/com/margelo/nitro/qusaieilouti99/callmanager/CallForegroundService.kt

@@ -35,10 +35,8 @@ class CallForegroundService : Service() {
         val state = intent?.getStringExtra("state")
 
         val notification = if (callId != null && callType != null && displayName != null && state != null) {
-            Log.d(TAG, "Building enhanced notification with call info: $callId")
             buildEnhancedNotification(callId, callType, displayName, state)
         } else {
-            Log.d(TAG, "Building basic notification - no call info available")
             buildBasicNotification()
         }
 
@@ -46,14 +44,9 @@ class CallForegroundService : Service() {
         return START_STICKY
     }
 
-    override fun onBind(intent: Intent?): IBinder? {
-        Log.d(TAG, "Service onBind")
-        return null
-    }
+    override fun onBind(intent: Intent?): IBinder? = null
 
     private fun buildBasicNotification(): Notification {
-        Log.d(TAG, "Building basic foreground notification.")
-
         return NotificationCompat.Builder(this, CHANNEL_ID)
             .setContentTitle("Call Service")
             .setContentText("Call service is running...")
@@ -61,12 +54,11 @@ class CallForegroundService : Service() {
             .setOngoing(true)
             .setCategory(NotificationCompat.CATEGORY_CALL)
             .setPriority(NotificationCompat.PRIORITY_DEFAULT)
-            .setWhen(System.currentTimeMillis())
             .build()
     }
 
     private fun buildEnhancedNotification(callId: String, callType: String, displayName: String, state: String): Notification {
-        Log.d(TAG, "Building enhanced foreground notification for callId: $callId, state: $state")
+        Log.d(TAG, "Building notification for callId: $callId, state: $state")
 
         val endCallIntent = Intent(this, CallNotificationActionReceiver::class.java).apply {
             action = "com.qusaieilouti99.callmanager.END_CALL"
@@ -90,16 +82,6 @@ class CallForegroundService : Service() {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
         )
 
-        val mainIntent = packageManager.getLaunchIntentForPackage(packageName)?.apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-        }
-        val mainPendingIntent = mainIntent?.let {
-            PendingIntent.getActivity(
-                this, 102, it,
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-            )
-        }
-
         val statusText = when (state) {
             "ACTIVE" -> displayName
             "HELD" -> "$displayName (on hold)"
@@ -123,8 +105,8 @@ class CallForegroundService : Service() {
             .setOngoing(true)
             .setCategory(NotificationCompat.CATEGORY_CALL)
             .setPriority(NotificationCompat.PRIORITY_HIGH)
-            .setWhen(System.currentTimeMillis())
 
+        // Add action buttons for ACTIVE and HELD calls
         if (state == "ACTIVE" || state == "HELD") {
             notificationBuilder
                 .addAction(
@@ -145,10 +127,6 @@ class CallForegroundService : Service() {
             )
         }
 
-        mainPendingIntent?.let {
-            notificationBuilder.setContentIntent(it)
-        }
-
         return notificationBuilder.build()
     }
 
@@ -166,37 +144,28 @@ class CallForegroundService : Service() {
 
             val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
             manager.createNotificationChannel(channel)
-            Log.d(TAG, "Foreground notification channel '$CHANNEL_ID' created/updated.")
         }
     }
 
     override fun onTaskRemoved(rootIntent: Intent?) {
-        // Figure out which Activity’s task was just removed:
         val removed = rootIntent?.component?.className
-        Log.d(TAG, "onTaskRemoved: removedActivity=$removed")
+        Log.d(TAG, "onTaskRemoved: $removed")
 
-        // If it was our lock-screen CallActivity, ignore —
-        // we only want to clean up when the MAIN app task is swiped away.
-        if (removed == CallActivity::class.java.name) {
-          Log.d(TAG, "CallActivity was removed; keeping call alive.")
-          return
+        // Only terminate if main app was removed, not CallActivity
+        if (removed != CallActivity::class.java.name) {
+            Log.d(TAG, "Main app task removed - terminating")
+            CallEngine.onApplicationTerminate()
         }
 
-        // Otherwise (e.g. MainActivity removed), tear everything down:
-        Log.d(TAG, "Main task removed; ending all calls.")
-        CallEngine.onApplicationTerminate()
-        stopSelf()
         super.onTaskRemoved(rootIntent)
-      }
+    }
 
     override fun onDestroy() {
         super.onDestroy()
-        Log.d(TAG, "Service onDestroy. Stopping foreground.")
+        Log.d(TAG, "Service onDestroy")
         stopForeground(true)
 
-        // Additional cleanup when service is destroyed
-        if (!CallEngine.isCallActive()) {
-            CallEngine.onApplicationTerminate()
-        }
+        // SIMPLIFIED: Don't call onApplicationTerminate here
+        // Only onTaskRemoved should trigger app termination
     }
 }

package/lib/typescript/src/CallEventType.d.ts

@@ -1,2 +1,2 @@
-export type CallEventType = 'AUDIO_DEVICES_CHANGED' | 'AUDIO_ROUTE_CHANGED' | 'CALL_HELD' | 'CALL_UNHELD' | 'CALL_UNHOLD_FAILED' | 'CALL_MUTED' | 'CALL_UNMUTED' | 'CALL_ANSWERED' | 'CALL_REJECTED' | 'CALL_ENDED' | 'DTMF_TONE';
+export type CallEventType = 'AUDIO_DEVICES_CHANGED' | 'AUDIO_ROUTE_CHANGED' | 'CALL_HELD' | 'CALL_UNHELD' | 'CALL_UNHOLD_FAILED' | 'CALL_MUTED' | 'CALL_UNMUTED' | 'CALL_ANSWERED' | 'OUTGOING_CALL_ANSWERED' | 'CALL_REJECTED' | 'CALL_ENDED' | 'DTMF_TONE';
 //# sourceMappingURL=CallEventType.d.ts.map

package/lib/typescript/src/CallEventType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CallEventType.d.ts","sourceRoot":"","sources":["../../../src/CallEventType.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,aAAa,GACvB,uBAAuB,GACrB,qBAAqB,GACrB,WAAW,GACX,aAAa,GACb,oBAAoB,GACpB,YAAY,GACZ,cAAc,GACd,eAAe,GACf,eAAe,GACf,YAAY,GACZ,WAAW,CAAC"}
+{"version":3,"file":"CallEventType.d.ts","sourceRoot":"","sources":["../../../src/CallEventType.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,aAAa,GACvB,uBAAuB,GACrB,qBAAqB,GACrB,WAAW,GACX,aAAa,GACb,oBAAoB,GACpB,YAAY,GACZ,cAAc,GACd,eAAe,GACf,wBAAwB,GACxB,eAAe,GACf,YAAY,GACZ,WAAW,CAAC"}

package/nitrogen/generated/android/c++/JCallEventType.hpp

@@ -49,6 +49,7 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
       static const auto fieldCALL_MUTED = clazz->getStaticField<JCallEventType>("CALL_MUTED");
       static const auto fieldCALL_UNMUTED = clazz->getStaticField<JCallEventType>("CALL_UNMUTED");
       static const auto fieldCALL_ANSWERED = clazz->getStaticField<JCallEventType>("CALL_ANSWERED");
+      static const auto fieldOUTGOING_CALL_ANSWERED = clazz->getStaticField<JCallEventType>("OUTGOING_CALL_ANSWERED");
       static const auto fieldCALL_REJECTED = clazz->getStaticField<JCallEventType>("CALL_REJECTED");
       static const auto fieldCALL_ENDED = clazz->getStaticField<JCallEventType>("CALL_ENDED");
       static const auto fieldDTMF_TONE = clazz->getStaticField<JCallEventType>("DTMF_TONE");
@@ -70,6 +71,8 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
           return clazz->getStaticFieldValue(fieldCALL_UNMUTED);
         case CallEventType::CALL_ANSWERED:
           return clazz->getStaticFieldValue(fieldCALL_ANSWERED);
+        case CallEventType::OUTGOING_CALL_ANSWERED:
+          return clazz->getStaticFieldValue(fieldOUTGOING_CALL_ANSWERED);
         case CallEventType::CALL_REJECTED:
           return clazz->getStaticFieldValue(fieldCALL_REJECTED);
         case CallEventType::CALL_ENDED:

package/nitrogen/generated/android/kotlin/com/margelo/nitro/qusaieilouti99/callmanager/CallEventType.kt

@@ -24,6 +24,7 @@ enum class CallEventType {
   CALL_MUTED,
   CALL_UNMUTED,
   CALL_ANSWERED,
+  OUTGOING_CALL_ANSWERED,
   CALL_REJECTED,
   CALL_ENDED,
   DTMF_TONE;

package/nitrogen/generated/ios/swift/CallEventType.swift

@@ -33,6 +33,8 @@ public extension CallEventType {
         self = .callUnmuted
       case "CALL_ANSWERED":
         self = .callAnswered
+      case "OUTGOING_CALL_ANSWERED":
+        self = .outgoingCallAnswered
       case "CALL_REJECTED":
         self = .callRejected
       case "CALL_ENDED":
@@ -65,6 +67,8 @@ public extension CallEventType {
         return "CALL_UNMUTED"
       case .callAnswered:
         return "CALL_ANSWERED"
+      case .outgoingCallAnswered:
+        return "OUTGOING_CALL_ANSWERED"
       case .callRejected:
         return "CALL_REJECTED"
       case .callEnded:

package/nitrogen/generated/shared/c++/CallEventType.hpp

@@ -37,9 +37,10 @@ namespace margelo::nitro::qusaieilouti99_callmanager {
     CALL_MUTED      SWIFT_NAME(callMuted) = 5,
     CALL_UNMUTED      SWIFT_NAME(callUnmuted) = 6,
     CALL_ANSWERED      SWIFT_NAME(callAnswered) = 7,
-    CALL_REJECTED      SWIFT_NAME(callRejected) = 8,
-    CALL_ENDED      SWIFT_NAME(callEnded) = 9,
-    DTMF_TONE      SWIFT_NAME(dtmfTone) = 10,
+    OUTGOING_CALL_ANSWERED      SWIFT_NAME(outgoingCallAnswered) = 8,
+    CALL_REJECTED      SWIFT_NAME(callRejected) = 9,
+    CALL_ENDED      SWIFT_NAME(callEnded) = 10,
+    DTMF_TONE      SWIFT_NAME(dtmfTone) = 11,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::qusaieilouti99_callmanager
@@ -62,6 +63,7 @@ namespace margelo::nitro {
         case hashString("CALL_MUTED"): return CallEventType::CALL_MUTED;
         case hashString("CALL_UNMUTED"): return CallEventType::CALL_UNMUTED;
         case hashString("CALL_ANSWERED"): return CallEventType::CALL_ANSWERED;
+        case hashString("OUTGOING_CALL_ANSWERED"): return CallEventType::OUTGOING_CALL_ANSWERED;
         case hashString("CALL_REJECTED"): return CallEventType::CALL_REJECTED;
         case hashString("CALL_ENDED"): return CallEventType::CALL_ENDED;
         case hashString("DTMF_TONE"): return CallEventType::DTMF_TONE;
@@ -79,6 +81,7 @@ namespace margelo::nitro {
         case CallEventType::CALL_MUTED: return JSIConverter<std::string>::toJSI(runtime, "CALL_MUTED");
         case CallEventType::CALL_UNMUTED: return JSIConverter<std::string>::toJSI(runtime, "CALL_UNMUTED");
         case CallEventType::CALL_ANSWERED: return JSIConverter<std::string>::toJSI(runtime, "CALL_ANSWERED");
+        case CallEventType::OUTGOING_CALL_ANSWERED: return JSIConverter<std::string>::toJSI(runtime, "OUTGOING_CALL_ANSWERED");
         case CallEventType::CALL_REJECTED: return JSIConverter<std::string>::toJSI(runtime, "CALL_REJECTED");
         case CallEventType::CALL_ENDED: return JSIConverter<std::string>::toJSI(runtime, "CALL_ENDED");
         case CallEventType::DTMF_TONE: return JSIConverter<std::string>::toJSI(runtime, "DTMF_TONE");
@@ -101,6 +104,7 @@ namespace margelo::nitro {
         case hashString("CALL_MUTED"):
         case hashString("CALL_UNMUTED"):
         case hashString("CALL_ANSWERED"):
+        case hashString("OUTGOING_CALL_ANSWERED"):
         case hashString("CALL_REJECTED"):
         case hashString("CALL_ENDED"):
         case hashString("DTMF_TONE"):

package/package.json

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

package/src/CallEventType.ts

@@ -8,6 +8,7 @@ export type CallEventType =
   | 'CALL_MUTED'
   | 'CALL_UNMUTED'
   | 'CALL_ANSWERED'
+  | 'OUTGOING_CALL_ANSWERED'
   | 'CALL_REJECTED'
   | 'CALL_ENDED'
   | 'DTMF_TONE'; // ADD THIS LINE IF YOU NEED DTMF EVENTS