@qusaieilouti99/call-manager 0.1.65 → 0.1.67

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

@@ -31,6 +31,7 @@ import android.telecom.PhoneAccountHandle
 import android.telecom.TelecomManager
 import android.telecom.VideoProfile
 import android.util.Log
+import androidx.annotation.RequiresApi
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -44,8 +45,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 +52,16 @@ object CallEngine {
     private val isInitialized = AtomicBoolean(false)
     private val initializationLock = Any()
 
-    // Audio & Media
+    // Enhanced Audio & Media Management
     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
+    private val audioFocusRetryHandler = Handler(Looper.getMainLooper())
+    private var audioFocusRetryCount = 0
+    private val MAX_AUDIO_FOCUS_RETRIES = 3
 
     // Call State Management
     private val activeCalls = ConcurrentHashMap<String, CallInfo>()
@@ -70,8 +73,6 @@ object CallEngine {
 
     // Audio State Tracking
     private var lastAudioRoutesInfo: AudioRoutesInfo? = null
-    private var hasAudioFocus: Boolean = false
-    private var isSystemCallActive: Boolean = false
 
     // Lock Screen Bypass
     private var lockScreenBypassActive = false
@@ -85,25 +86,49 @@ object CallEngine {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    // --- INITIALIZATION - Fixed for better context management ---
+    // Enhanced Audio Focus Change Listener for Self-Managed Calls
+    private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
+        Log.d(TAG, "Audio focus changed: $focusChange")
+        when (focusChange) {
+            AudioManager.AUDIOFOCUS_GAIN -> {
+                Log.d(TAG, "Audio focus gained")
+                hasAudioFocus = true
+                audioFocusRetryCount = 0
+
+                // Resume any system-held calls after a short delay
+                Handler(Looper.getMainLooper()).postDelayed({
+                    resumeSystemHeldCalls()
+                }, 500)
+            }
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                Log.d(TAG, "Permanent audio focus loss - holding active calls")
+                hasAudioFocus = false
+                holdAllActiveCalls(heldBySystem = true)
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                Log.d(TAG, "Transient audio focus loss - holding calls temporarily")
+                hasAudioFocus = false
+                holdAllActiveCalls(heldBySystem = true)
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                Log.d(TAG, "Transient audio focus loss (can duck) - keeping calls active")
+                hasAudioFocus = false
+                // Don't hold calls for ducking scenarios in self-managed calls
+            }
+        }
+    }
+
+    // --- 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 +137,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,142 +154,111 @@ 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 ---
-    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
-                hasAudioFocus = false
-            }
-            AudioManager.AUDIOFOCUS_GAIN -> {
-                Log.d(TAG, "Audio focus gained")
-                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
-            }
-        }
-        updateForegroundNotification()
-    }
+    // --- Enhanced Audio Focus Management for Self-Managed Calls ---
+    private fun requestAudioFocus(): Boolean {
+        val context = requireContext()
+        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
 
-    private fun holdSystemCalls() {
-        val callsToHold = activeCalls.values.filter {
-            it.state == CallState.ACTIVE && !it.wasHeldBySystem
+        if (hasAudioFocus) {
+            Log.d(TAG, "Audio focus already granted")
+            return true
         }
 
-        if (callsToHold.isEmpty()) {
-            Log.d(TAG, "No active calls to hold due to audio focus loss")
-            return
-        }
+        Log.d(TAG, "Requesting audio focus for self-managed call (attempt ${audioFocusRetryCount + 1})")
 
-        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}")
-            }
+        val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            requestAudioFocusApi26Plus()
+        } else {
+            requestAudioFocusLegacy()
         }
-        stopRingback()
-    }
 
-    private fun resumeSystemHeldCalls() {
-        val callsToResume = activeCalls.values.filter {
-            it.state == CallState.HELD && it.wasHeldBySystem
-        }
+        val success = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+        hasAudioFocus = success
 
-        if (callsToResume.isEmpty()) {
-            Log.d(TAG, "No system-held calls to resume")
-            return
-        }
+        Log.d(TAG, "Audio focus request result: $result (granted: $success)")
 
-        Log.d(TAG, "Resuming ${callsToResume.size} system-held calls")
-        callsToResume.forEach { call ->
-            unholdCallInternal(call.callId, resumedBySystem = true)
+        if (!success && audioFocusRetryCount < MAX_AUDIO_FOCUS_RETRIES) {
+            // Retry after a short delay
+            audioFocusRetryCount++
+            audioFocusRetryHandler.postDelayed({
+                Log.d(TAG, "Retrying audio focus request...")
+                requestAudioFocus()
+            }, 200)
         }
-    }
 
-    private fun requestAudioFocus(): Boolean {
-        val context = requireContext()
-        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+        return success
+    }
 
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            if (audioFocusRequest == null) {
-                audioFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
-                    .setAudioAttributes(
-                        AudioAttributes.Builder()
-                            .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
-                            .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
-                            .build()
-                    )
-                    .setOnAudioFocusChangeListener(audioFocusChangeListener, Handler(Looper.getMainLooper()))
-                    .setAcceptsDelayedFocusGain(true)  // Added this
-                    .build()
-            }
-            val result = audioManager?.requestAudioFocus(audioFocusRequest!!)
-            hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
-            Log.d(TAG, "Audio focus request result: $result (granted: $hasAudioFocus)")
-            hasAudioFocus
-        } else {
-            @Suppress("DEPRECATION")
-            val result = audioManager?.requestAudioFocus(
-                audioFocusChangeListener,
-                AudioManager.STREAM_VOICE_CALL,
-                AudioManager.AUDIOFOCUS_GAIN
-            )
-            hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
-            Log.d(TAG, "Audio focus request result (legacy): $result (granted: $hasAudioFocus)")
-            hasAudioFocus
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun requestAudioFocusApi26Plus(): Int {
+        if (audioFocusRequest == null) {
+            audioFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
+                .setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION_SIGNALLING)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                        .setFlags(AudioAttributes.FLAG_AUDIBILITY_ENFORCED)
+                        .build()
+                )
+                .setOnAudioFocusChangeListener(audioFocusChangeListener)
+                .setAcceptsDelayedFocusGain(true)
+                .setWillPauseWhenDucked(false)
+                .build()
         }
+
+        return audioManager?.requestAudioFocus(audioFocusRequest!!) ?: AudioManager.AUDIOFOCUS_REQUEST_FAILED
+    }
+
+    @Suppress("DEPRECATION")
+    private fun requestAudioFocusLegacy(): Int {
+        return audioManager?.requestAudioFocus(
+            audioFocusChangeListener,
+            AudioManager.STREAM_VOICE_CALL,
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE
+        ) ?: AudioManager.AUDIOFOCUS_REQUEST_FAILED
     }
 
     private fun abandonAudioFocus() {
+        if (!hasAudioFocus) return
+
         audioManager?.let { am ->
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                 audioFocusRequest?.let { request ->
                     am.abandonAudioFocusRequest(request)
-                }
+                } ?: AudioManager.AUDIOFOCUS_REQUEST_FAILED
             } else {
                 @Suppress("DEPRECATION")
                 am.abandonAudioFocus(audioFocusChangeListener)
             }
+            Log.d(TAG, "Audio focus abandoned, result: $result")
         }
+
         hasAudioFocus = false
-        Log.d(TAG, "Audio focus abandoned")
+        audioFocusRetryCount = 0
+        audioFocusRetryHandler.removeCallbacksAndMessages(null)
+    }
+
+    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 ---
@@ -296,12 +290,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 +313,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 +360,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 +379,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)
@@ -398,7 +387,7 @@ object CallEngine {
         updateLockScreenBypass()
     }
 
-    // --- Outgoing Call Management ---
+    // --- Enhanced Outgoing Call Management ---
     fun startOutgoingCall(
         callId: String,
         callType: String,
@@ -430,12 +419,16 @@ object CallEngine {
         currentCallId = callId
         Log.d(TAG, "Call $callId added to activeCalls. State: DIALING")
 
+        // Set audio mode and request focus early for outgoing calls
+        setAudioMode()
+        val audioFocusGranted = requestAudioFocus()
+        Log.d(TAG, "Audio focus for outgoing call: $audioFocusGranted")
+
         registerPhoneAccount()
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
         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 +437,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 +447,15 @@ object CallEngine {
             telecomManager.placeCall(addressUri, extras)
             startForegroundService()
 
-            // FIXED: Request audio focus BEFORE starting ringback
-            val audioFocusGranted = requestAudioFocus()
+            // Start ringback only if audio focus is available
             if (audioFocusGranted) {
                 startRingback()
-            } else {
-                Log.w(TAG, "Audio focus not granted for outgoing call, skipping ringback")
             }
 
             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 +464,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,9 +490,10 @@ 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()
+        setAudioMode()
         requestAudioFocus()
         bringAppToForeground()
         startForegroundService()
@@ -516,11 +501,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 ---
+    // --- Enhanced Call Answer Management ---
     fun callAnsweredFromJS(callId: String) {
         Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
         coreCallAnswered(callId, isLocalAnswer = false)
@@ -531,9 +516,8 @@ object CallEngine {
         coreCallAnswered(callId, isLocalAnswer = true)
     }
 
-    // FIXED: Core Call Answered Method with proper audio focus handling
+    // Enhanced call answer flow with proper audio focus timing
     private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
-        val context = requireContext()
         Log.d(TAG, "coreCallAnswered: $callId, isLocalAnswer: $isLocalAnswer")
 
         val callInfo = activeCalls[callId]
@@ -542,28 +526,26 @@ object CallEngine {
             return
         }
 
-        // FIXED: Request audio focus FIRST, before stopping media
+        // Set audio mode BEFORE requesting audio focus
+        setAudioMode()
+
+        // Request audio focus BEFORE setting call to active
         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
+            Log.w(TAG, "Audio focus not granted for call $callId, but proceeding anyway")
         }
 
-        // Stop media AFTER getting audio focus
+        // Now set call to ACTIVE
+        activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
+        currentCallId = callId
+        Log.d(TAG, "Call $callId set to ACTIVE state (audio focus: $audioFocusGranted)")
+
+        // 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
-        }
-
+        // Handle multiple calls
         if (!canMakeMultipleCalls) {
             activeCalls.filter { it.key != callId }.values.forEach { otherCall ->
                 if (otherCall.state == CallState.ACTIVE) {
@@ -575,20 +557,16 @@ object CallEngine {
         bringAppToForeground()
         startForegroundService()
         keepScreenAwake(true)
-        resetAudioMode()
         updateLockScreenBypass()
-        updateForegroundNotification()
 
-        // FIXED: Emit different events based on call direction
+        // 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 +583,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 +603,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 +616,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 +633,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 +642,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,14 +656,13 @@ 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
+        // Request audio focus when resuming a call
+        if (resumedBySystem) {
+            requestAudioFocus()
         }
 
         activeCalls[callId] = callInfo.copy(
@@ -702,14 +670,10 @@ object CallEngine {
             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 +685,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 +715,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 +727,7 @@ object CallEngine {
         callMetadata.clear()
         currentCallId = null
 
-        finalCleanup()
+        cleanup()
         updateLockScreenBypass()
     }
 
@@ -779,12 +739,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 +750,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 +757,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 +774,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 +784,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 +819,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 +835,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 +880,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 +913,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 +947,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 +978,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 +1014,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,10 +1085,8 @@ 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()
@@ -1165,21 +1095,17 @@ object CallEngine {
     // --- Service Management ---
     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 +1117,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 +1133,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 +1158,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 +1177,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 ---
+    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 +1250,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/package.json

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