@qusaieilouti99/call-manager 0.1.47 → 0.1.49

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

@@ -1,18 +1,26 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
-import android.app.*
+import android.app.Activity
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
 import android.content.ComponentName
 import android.content.Context
 import android.content.Intent
+import android.graphics.Color
 import android.media.AudioAttributes
 import android.media.AudioDeviceCallback
-import android.media.AudioManager
 import android.media.AudioDeviceInfo
+import android.media.AudioManager
 import android.media.MediaPlayer
 import android.media.RingtoneManager
 import android.net.Uri
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.os.PowerManager
 import android.telecom.CallAudioState
 import android.telecom.Connection
@@ -22,12 +30,14 @@ import android.telecom.PhoneAccountHandle
 import android.telecom.TelecomManager
 import android.telecom.VideoProfile
 import android.util.Log
-import android.graphics.Color
-import android.app.Person
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import org.json.JSONArray
 import org.json.JSONObject
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
 
 object CallEngine {
     private const val TAG = "CallEngine"
@@ -37,33 +47,55 @@ object CallEngine {
     private const val FOREGROUND_CHANNEL_ID = "call_foreground_channel"
     private const val FOREGROUND_NOTIF_ID = 1001
 
+    // Audio & Media
     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 appContext: Context? = null
 
-    // --- Multi-call state ---
+    // Call State Management
     private val activeCalls = ConcurrentHashMap<String, CallInfo>()
     private val telecomConnections = ConcurrentHashMap<String, Connection>()
     private var currentCallId: String? = null
-    private var canMakeMultipleCalls: Boolean = true
+    private var canMakeMultipleCalls: Boolean = false
+
+    // Audio State Tracking
+    private var lastAudioRoutesInfo: AudioRoutesInfo? = null
+    private var lastMuteState: Boolean = false
+
+    // Lock Screen Bypass
+    private var lockScreenBypassActive = false
+    private val lockScreenBypassCallbacks = mutableSetOf<LockScreenBypassCallback>()
+
+    // Event System
+    private var eventHandler: ((CallEventType, String) -> Unit)? = null
+    private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
+
+    // Operation State
+    private val operationInProgress = AtomicBoolean(false)
 
     data class CallInfo(
         val callId: String,
         val callData: String,
         var state: CallState,
-        val callType: String = "Audio"
+        val callType: String = "Audio",
+        val timestamp: Long = System.currentTimeMillis()
     )
 
     enum class CallState {
         INCOMING, DIALING, ACTIVE, HELD, ENDED
     }
 
-    // --- Event handler for JS ---
-    private var eventHandler: ((CallEventType, String) -> Unit)? = null
-    private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
+    interface LockScreenBypassCallback {
+        fun onLockScreenBypassChanged(shouldBypass: Boolean)
+    }
 
+    interface ServerCallRejectCallback {
+        fun onRejectCall(callId: String, reason: String)
+    }
+
+    // --- Event System ---
     fun setEventHandler(handler: ((CallEventType, String) -> Unit)?) {
         Log.d(TAG, "setEventHandler called. Handler present: ${handler != null}")
         eventHandler = handler
@@ -76,7 +108,7 @@ object CallEngine {
         }
     }
 
-    fun emitEvent(type: CallEventType, data: JSONObject) {
+    private fun emitEvent(type: CallEventType, data: JSONObject) {
         Log.d(TAG, "Emitting event: $type, data: $data")
         val dataString = data.toString()
         if (eventHandler != null) {
@@ -87,7 +119,31 @@ object CallEngine {
         }
     }
 
-    fun getAppContext(): Context? = appContext
+    // --- Lock Screen Bypass Management ---
+    fun registerLockScreenBypassCallback(callback: LockScreenBypassCallback) {
+        lockScreenBypassCallbacks.add(callback)
+    }
+
+    fun unregisterLockScreenBypassCallback(callback: LockScreenBypassCallback) {
+        lockScreenBypassCallbacks.remove(callback)
+    }
+
+    private fun updateLockScreenBypass() {
+        val shouldBypass = isCallActive()
+        if (lockScreenBypassActive != shouldBypass) {
+            lockScreenBypassActive = shouldBypass
+            Log.d(TAG, "Lock screen bypass state changed: $lockScreenBypassActive")
+            lockScreenBypassCallbacks.forEach { callback ->
+                try {
+                    callback.onLockScreenBypassChanged(shouldBypass)
+                } catch (e: Exception) {
+                    Log.w(TAG, "Error notifying lock screen bypass callback", e)
+                }
+            }
+        }
+    }
+
+    fun isLockScreenBypassActive(): Boolean = lockScreenBypassActive
 
     // --- Telecom Connection Management ---
     fun addTelecomConnection(callId: String, connection: Connection) {
@@ -96,13 +152,14 @@ object CallEngine {
     }
 
     fun removeTelecomConnection(callId: String) {
-        telecomConnections.remove(callId)
-        Log.d(TAG, "Removed Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
+        telecomConnections.remove(callId)?.let {
+            Log.d(TAG, "Removed Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
+        }
     }
 
-    fun getTelecomConnection(callId: String): Connection? {
-        return telecomConnections[callId]
-    }
+    fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
+
+    fun getAppContext(): Context? = appContext
 
     // --- Public API ---
     fun setCanMakeMultipleCalls(allow: Boolean) {
@@ -126,20 +183,31 @@ object CallEngine {
         return result
     }
 
+    // --- Incoming Call Management ---
     fun reportIncomingCall(context: Context, callId: String, callData: String) {
         appContext = context.applicationContext
         Log.d(TAG, "reportIncomingCall: $callId, $callData")
 
-        val callerName = try {
-            val json = JSONObject(callData)
-            json.optString("name", "Unknown")
-        } catch (e: Exception) { "Unknown" }
+        // Check for call collision - reject second incoming call automatically
+        val incomingCall = activeCalls.values.find { it.state == CallState.INCOMING }
+        if (incomingCall != null && incomingCall.callId != callId) {
+            Log.d(TAG, "Incoming call collision detected. Auto-rejecting new call: $callId")
 
-        val parsedCallType = try {
-            val json = JSONObject(callData)
-            json.optString("callType", "Audio")
-        } catch (e: Exception) { "Audio" }
+            // Auto-reject the new call
+            rejectIncomingCallCollision(callId, "Another call is already incoming")
+            return
+        }
 
+        // Check if there's an active call when receiving incoming
+        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
+        if (activeCall != null) {
+            Log.d(TAG, "Active call exists when receiving incoming call. Auto-rejecting: $callId")
+            rejectIncomingCallCollision(callId, "Another call is already active")
+            return
+        }
+
+        val callerName = extractCallerName(callData)
+        val parsedCallType = extractCallType(callData)
         val isVideoCallBoolean = parsedCallType == "Video"
 
         if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
@@ -153,17 +221,18 @@ object CallEngine {
 
         showIncomingCallUI(context, callId, callerName, parsedCallType)
         registerPhoneAccount(context)
+
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
         val phoneAccountHandle = getPhoneAccountHandle(context)
         val extras = Bundle().apply {
             putString(MyConnectionService.EXTRA_CALL_DATA, callData)
             putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, isVideoCallBoolean)
         }
+
         try {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
             startForegroundService(context)
             Log.d(TAG, "Successfully reported incoming call to TelecomManager for $callId")
-            // REMOVED: Don't bring app to foreground for incoming calls - only when answered
         } catch (e: SecurityException) {
             Log.e(TAG, "SecurityException: Failed to report incoming call. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
             endCall(context, callId)
@@ -171,23 +240,28 @@ object CallEngine {
             Log.e(TAG, "Failed to report incoming call: ${e.message}", e)
             endCall(context, callId)
         }
-        notifyCallStateChanged(context)
+
+        updateLockScreenBypass()
+        notifySpecificCallStateChanged(context, callId, CallState.INCOMING)
     }
 
+    // --- Outgoing Call Management ---
     fun startOutgoingCall(context: Context, callId: String, callData: String) {
         appContext = context.applicationContext
         Log.d(TAG, "startOutgoingCall: $callId, $callData")
 
-        val targetName = try {
-            val json = JSONObject(callData)
-            json.optString("name", "Unknown")
-        } catch (e: Exception) { "Unknown" }
-
-        val parsedCallType = try {
-            val json = JSONObject(callData)
-            json.optString("callType", "Audio")
-        } catch (e: Exception) { "Audio" }
+        // Validate outgoing call request
+        if (!validateOutgoingCallRequest()) {
+            Log.w(TAG, "Rejecting outgoing call - incoming/active call exists")
+            emitEvent(CallEventType.CALL_REJECTED, JSONObject().apply {
+                put("callId", callId)
+                put("reason", "Cannot start outgoing call while incoming or active call exists")
+            })
+            return
+        }
 
+        val targetName = extractCallerName(callData)
+        val parsedCallType = extractCallType(callData)
         val isVideoCallBoolean = parsedCallType == "Video"
 
         if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
@@ -202,7 +276,6 @@ object CallEngine {
         registerPhoneAccount(context)
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
         val phoneAccountHandle = getPhoneAccountHandle(context)
-
         val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, callId, null)
 
         val extras = Bundle().apply {
@@ -216,15 +289,11 @@ object CallEngine {
             telecomManager.placeCall(addressUri, extras)
             startForegroundService(context)
             Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
+
             startRingback()
-            // CHANGED: Bring app to foreground for outgoing calls
             bringAppToForeground(context)
             keepScreenAwake(context, true)
-            if (parsedCallType == "Video") {
-                setAudioRoute(context, "Speaker")
-            } else {
-                setAudioRoute(context, "Earpiece")
-            }
+            setInitialAudioRoute(context, parsedCallType)
         } catch (e: SecurityException) {
             Log.e(TAG, "SecurityException: Failed to start outgoing call via placeCall. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
             endCall(context, callId)
@@ -232,25 +301,31 @@ object CallEngine {
             Log.e(TAG, "Failed to start outgoing call via placeCall: ${e.message}", e)
             endCall(context, callId)
         }
-        notifyCallStateChanged(context)
+
+        updateLockScreenBypass()
+        notifySpecificCallStateChanged(context, callId, CallState.DIALING)
     }
 
-    // SINGLE SOURCE OF TRUTH: Core function for handling when remote party answers
+    // --- Call Answer Management ---
     fun callAnsweredFromJS(context: Context, callId: String) {
         Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
         coreCallAnswered(context, callId, isLocalAnswer = false)
     }
 
-    // SINGLE SOURCE OF TRUTH: Core function for handling local answer (user answering)
     fun answerCall(context: Context, callId: String) {
         Log.d(TAG, "answerCall: $callId - local party answering")
         coreCallAnswered(context, callId, isLocalAnswer = true)
     }
 
-    // SINGLE SOURCE OF TRUTH: Core function that handles ALL call answering logic
     private fun coreCallAnswered(context: Context, callId: String, isLocalAnswer: Boolean) {
         Log.d(TAG, "coreCallAnswered: $callId, isLocalAnswer: $isLocalAnswer")
 
+        val callInfo = activeCalls[callId]
+        if (callInfo == null) {
+            Log.w(TAG, "Cannot answer call $callId - not found in active calls")
+            return
+        }
+
         // Stop all ringtones and notifications immediately
         stopRingtone()
         stopRingback()
@@ -264,79 +339,94 @@ object CallEngine {
             activeCalls.filter { it.key != callId }.values.forEach { it.state = CallState.HELD }
         }
 
-        // Bring app to foreground only when call is answered
+        // Bring app to foreground when call is answered
         bringAppToForeground(context)
         startForegroundService(context)
         keepScreenAwake(context, true)
         resetAudioMode(context)
 
-        // ADDED: Ensure MainActivity shows above lock screen during call
-        updateMainActivityLockScreenBypass()
+        updateLockScreenBypass()
 
-        // Emit event
-        emitEvent(CallEventType.CALL_ANSWERED, JSONObject().put("callId", callId))
-        notifyCallStateChanged(context)
+        // Emit event with full call data instead of just callId
+        emitEvent(CallEventType.CALL_ANSWERED, JSONObject().apply {
+            put("callId", callId)
+            put("callData", callInfo.callData)
+            put("callType", callInfo.callType)
+        })
 
+        notifySpecificCallStateChanged(context, callId, CallState.ACTIVE)
         Log.d(TAG, "Call $callId successfully answered and UI cleaned up")
     }
 
-    // NEW: Method to update MainActivity lock screen bypass state
-    private fun updateMainActivityLockScreenBypass() {
-        try {
-            // Try to get MainActivity instance through reflection or static reference
-            val mainActivityClass = Class.forName("com.pingme2022.MainActivity")
-            val getCurrentInstanceMethod = mainActivityClass.getMethod("getCurrentInstance")
-            val mainActivityInstance = getCurrentInstanceMethod.invoke(null)
-
-            if (mainActivityInstance != null) {
-                val updateMethod = mainActivityClass.getMethod("updateLockScreenBypass")
-                updateMethod.invoke(mainActivityInstance)
-                Log.d(TAG, "Updated MainActivity lock screen bypass state")
-            } else {
-                Log.d(TAG, "MainActivity instance not available for lock screen bypass update")
-            }
-        } catch (e: Exception) {
-            Log.w(TAG, "Could not update MainActivity lock screen bypass: ${e.message}")
-        }
-    }
-
+    // --- Call Control Methods ---
     fun holdCall(context: Context, callId: String) {
         Log.d(TAG, "holdCall: $callId")
+        val callInfo = activeCalls[callId]
+        if (callInfo?.state != CallState.ACTIVE) {
+            Log.w(TAG, "Cannot hold call $callId - not in active state")
+            return
+        }
+
+        activeCalls[callId]?.state = CallState.HELD
         val connection = telecomConnections[callId]
         connection?.setOnHold()
+
+        updateForegroundNotification(context)
         emitEvent(CallEventType.CALL_HELD, JSONObject().put("callId", callId))
-        notifyCallStateChanged(context)
+        updateLockScreenBypass()
+        notifySpecificCallStateChanged(context, callId, CallState.HELD)
     }
 
     fun unholdCall(context: Context, callId: String) {
         Log.d(TAG, "unholdCall: $callId")
+        val callInfo = activeCalls[callId]
+        if (callInfo?.state != CallState.HELD) {
+            Log.w(TAG, "Cannot unhold call $callId - not in held state")
+            return
+        }
+
         activeCalls[callId]?.state = CallState.ACTIVE
         val connection = telecomConnections[callId]
         connection?.setActive()
+
+        updateForegroundNotification(context)
         emitEvent(CallEventType.CALL_UNHELD, JSONObject().put("callId", callId))
-        notifyCallStateChanged(context)
+        updateLockScreenBypass()
+        notifySpecificCallStateChanged(context, callId, CallState.ACTIVE)
     }
 
     fun muteCall(context: Context, callId: String) {
         Log.d(TAG, "muteCall: $callId")
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+        // Only emit event if mute state actually changes
+        val wasMuted = audioManager?.isMicrophoneMute ?: false
         audioManager?.isMicrophoneMute = true
-        emitEvent(CallEventType.CALL_MUTED, JSONObject().put("callId", callId))
+
+        if (!wasMuted) {
+            lastMuteState = true
+            emitEvent(CallEventType.CALL_MUTED, JSONObject().put("callId", callId))
+        }
     }
 
     fun unmuteCall(context: Context, callId: String) {
         Log.d(TAG, "unmuteCall: $callId")
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+        // Only emit event if mute state actually changes
+        val wasMuted = audioManager?.isMicrophoneMute ?: false
         audioManager?.isMicrophoneMute = false
-        emitEvent(CallEventType.CALL_UNMUTED, JSONObject().put("callId", callId))
+
+        if (wasMuted) {
+            lastMuteState = false
+            emitEvent(CallEventType.CALL_UNMUTED, JSONObject().put("callId", callId))
+        }
     }
 
-    // SINGLE SOURCE OF TRUTH: Core function that handles ALL call ending logic
+    // --- Call End Management ---
     fun endCall(context: Context, callId: String) {
         appContext = context.applicationContext
         Log.d(TAG, "endCall: $callId")
-
-        // Core cleanup logic
         coreEndCall(context, callId)
     }
 
@@ -346,22 +436,27 @@ object CallEngine {
             Log.d(TAG, "No active calls, nothing to do.")
             return
         }
+
         activeCalls.keys.toList().forEach { callId ->
             coreEndCall(context, callId)
         }
+
         activeCalls.clear()
         telecomConnections.clear()
         currentCallId = null
 
-        // Final cleanup
         finalCleanup(context)
-        notifyCallStateChanged(context)
+        updateLockScreenBypass()
     }
 
-    // SINGLE SOURCE OF TRUTH: Core function that handles ending a single call
     private fun coreEndCall(context: Context, callId: String) {
         Log.d(TAG, "coreEndCall: $callId")
 
+        val callInfo = activeCalls[callId] ?: run {
+            Log.w(TAG, "Call $callId not found in active calls")
+            return
+        }
+
         // Update call state
         activeCalls[callId]?.state = CallState.ENDED
         activeCalls.remove(callId)
@@ -390,181 +485,24 @@ object CallEngine {
         // If no more calls, do final cleanup
         if (activeCalls.isEmpty()) {
             finalCleanup(context)
-        }
-
-        emitEvent(CallEventType.CALL_ENDED, JSONObject().put("callId", callId))
-        notifyCallStateChanged(context)
-    }
-
-    // SINGLE SOURCE OF TRUTH: Final cleanup when all calls are ended
-    private fun finalCleanup(context: Context) {
-        Log.d(TAG, "Performing final cleanup - no active calls remaining")
-
-        stopForegroundService(context)
-        keepScreenAwake(context, false)
-        resetAudioMode(context)
-
-        // ENHANCED: Clear lock screen bypass when calls end
-        updateMainActivityLockScreenBypass()
-    }
-    // NEW: Function to clear lock screen bypass
-    private fun clearLockScreenBypass(context: Context) {
-        try {
-            if (context is Activity) {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
-                    context.setShowWhenLocked(false)
-                    context.setTurnScreenOn(false)
-                } else {
-                    context.window.clearFlags(
-                        android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-                        android.view.WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
-                        android.view.WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
-                    )
-                }
-                Log.d(TAG, "Lock screen bypass flags cleared for Activity")
-            }
-        } catch (e: Exception) {
-            Log.w(TAG, "Could not clear lock screen bypass flags: ${e.message}")
-        }
-    }
-
-    fun getActiveCalls(): List<CallInfo> = activeCalls.values.toList()
-    fun getCurrentCallId(): String? = currentCallId
-    fun isCallActive(): Boolean = activeCalls.any {
-        it.value.state == CallState.ACTIVE ||
-        it.value.state == CallState.INCOMING ||
-        it.value.state == CallState.DIALING
-    }
-
-    // Enhanced incoming call UI with better cleanup
-    fun showIncomingCallUI(context: Context, callId: String, callerName: String, callType: String) {
-        Log.d(TAG, "Showing incoming call UI for $callId, caller: $callerName, callType: $callType")
-        createNotificationChannel(context)
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-        val answerIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
-            action = "com.qusaieilouti99.callmanager.ANSWER_CALL"
-            putExtra("callId", callId)
-        }
-        val answerPendingIntent = PendingIntent.getBroadcast(context, 0, answerIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-
-        val declineIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
-            action = "com.qusaieilouti99.callmanager.DECLINE_CALL"
-            putExtra("callId", callId)
-        }
-        val declinePendingIntent = PendingIntent.getBroadcast(context, 1, declineIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-
-        val fullScreenIntent = Intent(context, CallActivity::class.java).apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-            putExtra("callId", callId)
-            putExtra("callerName", callerName)
-            putExtra("callType", callType)
-        }
-        val fullScreenPendingIntent = PendingIntent.getActivity(context, 2, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-
-        val notification: Notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            val person = Person.Builder().setName(callerName).setImportant(true).build()
-            Notification.Builder(context, NOTIF_CHANNEL_ID)
-                .setSmallIcon(android.R.drawable.sym_call_incoming)
-                .setStyle(Notification.CallStyle.forIncomingCall(person, declinePendingIntent, answerPendingIntent))
-                .setFullScreenIntent(fullScreenPendingIntent, true)
-                .setOngoing(true)
-                .setAutoCancel(false)
-                .build()
-        } else {
-            Notification.Builder(context, NOTIF_CHANNEL_ID)
-                .setSmallIcon(android.R.drawable.sym_call_incoming)
-                .setContentTitle("Incoming Call")
-                .setContentText(callerName)
-                .setPriority(Notification.PRIORITY_HIGH)
-                .setCategory(Notification.CATEGORY_CALL)
-                .setFullScreenIntent(fullScreenPendingIntent, true)
-                .addAction(android.R.drawable.sym_action_call, "Answer", answerPendingIntent)
-                .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Decline", declinePendingIntent)
-                .setOngoing(true)
-                .setAutoCancel(false)
-                .build()
-        }
-
-        notificationManager.notify(NOTIF_ID, notification)
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) playRingtone(context)
-        if (callType == "Video") {
-            setAudioRoute(context, "Speaker")
-        }
-    }
-
-    fun cancelIncomingCallUI(context: Context) {
-        Log.d(TAG, "Cancelling incoming call UI.")
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(NOTIF_ID)
-        stopRingtone()
-    }
-
-    fun startForegroundService(context: Context) {
-        Log.d(TAG, "Starting CallForegroundService.")
-        val intent = Intent(context, CallForegroundService::class.java)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) context.startForegroundService(intent)
-        else context.startService(intent)
-    }
-
-    fun stopForegroundService(context: Context) {
-        Log.d(TAG, "Stopping CallForegroundService.")
-        val intent = Intent(context, CallForegroundService::class.java)
-        context.stopService(intent)
-    }
-
-    // Enhanced bringAppToForeground with better lock screen handling
-    fun bringAppToForeground(context: Context) {
-        val packageName = context.packageName
-        val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
-        launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-
-        // Handle lock screen bypass for active calls
-        if (isCallActive()) {
-            // ENHANCED: Add multiple flags for better lock screen bypass
-            launchIntent?.putExtra("BYPASS_LOCK_SCREEN", true)
-
-            // Add lock screen bypass flags directly to the intent
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
-                launchIntent?.addFlags(Intent.FLAG_ACTIVITY_SHOW_WHEN_LOCKED or Intent.FLAG_ACTIVITY_TURN_SCREEN_ON)
-            } else {
-                launchIntent?.addFlags(
-                    Intent.FLAG_ACTIVITY_SHOW_WHEN_LOCKED or
-                    Intent.FLAG_ACTIVITY_TURN_SCREEN_ON or
-                    Intent.FLAG_ACTIVITY_CLEAR_TASK
-                )
-            }
-
-            Log.d(TAG, "App brought to foreground with lock screen bypass for active call")
         } else {
-            launchIntent?.removeExtra("BYPASS_LOCK_SCREEN")
-            Log.d(TAG, "App brought to foreground without lock screen bypass")
+            updateForegroundNotification(context)
         }
 
-        try {
-            context.startActivity(launchIntent)
-
-            // ADDED: Small delay to ensure activity is created before updating bypass
-            android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
-                updateMainActivityLockScreenBypass()
-            }, 100)
-
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to bring app to foreground: ${e.message}")
-        }
+        updateLockScreenBypass()
+        emitEvent(CallEventType.CALL_ENDED, JSONObject().put("callId", callId))
+        notifySpecificCallStateChanged(context, callId, CallState.ENDED)
     }
 
-    // Rest of the methods remain the same...
-    // (getAudioDevices, setAudioRoute, keepScreenAwake, etc. - keeping them unchanged for brevity)
-
-    // --- Audio Device Management ---
+    // --- Audio Management ---
     fun getAudioDevices(): AudioRoutesInfo {
         audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
             Log.e(TAG, "getAudioDevices: AudioManager is null or appContext is not set. Returning default.")
             return AudioRoutesInfo(emptyArray(), "Unknown")
         }
-        val devices = mutableListOf<String>()
-        var currentRoute: String = "Unknown"
+
+        val devices = mutableSetOf<String>()
+        var currentRoute = "Earpiece" // Default
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             val audioDeviceInfoList = audioManager?.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
@@ -572,47 +510,31 @@ object CallEngine {
                 when (device.type) {
                     AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> {
                         devices.add("Bluetooth")
-                        if (audioManager?.isBluetoothScoOn == true && !device.isSource) currentRoute = "Bluetooth"
                     }
                     AudioDeviceInfo.TYPE_WIRED_HEADPHONES, AudioDeviceInfo.TYPE_WIRED_HEADSET -> {
                         devices.add("Headset")
-                        if (audioManager?.isWiredHeadsetOn == true && !device.isSource) currentRoute = "Headset"
                     }
                     AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> {
                         devices.add("Speaker")
-                        if (audioManager?.isSpeakerphoneOn == true && !device.isSource) currentRoute = "Speaker"
                     }
                     AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> {
                         devices.add("Earpiece")
-                        if (audioManager?.isSpeakerphoneOn == false && audioManager?.isWiredHeadsetOn == false && audioManager?.isBluetoothScoOn == false && !device.isSource) {
-                            currentRoute = "Earpiece"
-                        }
                     }
-                    else -> Log.d(TAG, "Unknown audio device type: ${device.type}")
                 }
             }
         } else {
-            devices.add("Speaker")
-            devices.add("Earpiece")
-            if (audioManager?.isSpeakerphoneOn == true) currentRoute = "Speaker"
-            else currentRoute = "Earpiece"
+            devices.addAll(listOf("Speaker", "Earpiece"))
         }
 
-        val distinctDevices = devices.distinct().toTypedArray()
-
-        if (currentRoute == "Unknown" || currentRoute == "Earpiece") {
-            if (audioManager?.isBluetoothScoOn == true) {
-                currentRoute = "Bluetooth"
-            } else if (audioManager?.isSpeakerphoneOn == true) {
-                currentRoute = "Speaker"
-            } else if (audioManager?.isWiredHeadsetOn == true) {
-                currentRoute = "Headset"
-            } else {
-                currentRoute = "Earpiece"
-            }
+        // Determine current route
+        currentRoute = when {
+            audioManager?.isBluetoothScoOn == true -> "Bluetooth"
+            audioManager?.isSpeakerphoneOn == true -> "Speaker"
+            audioManager?.isWiredHeadsetOn == true -> "Headset"
+            else -> "Earpiece"
         }
 
-        val result = AudioRoutesInfo(distinctDevices, currentRoute)
+        val result = AudioRoutesInfo(devices.toTypedArray(), currentRoute)
         Log.d(TAG, "Audio devices info: $result")
         return result
     }
@@ -621,6 +543,9 @@ object CallEngine {
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         Log.d(TAG, "Attempting to set audio route to: $route. Current mode: ${audioManager?.mode}")
 
+        val previousRoute = getCurrentAudioRoute()
+
+        // Reset all routes first
         audioManager?.isSpeakerphoneOn = false
         audioManager?.stopBluetoothSco()
         audioManager?.isBluetoothScoOn = false
@@ -633,7 +558,6 @@ object CallEngine {
             }
             "Earpiece" -> {
                 Log.d(TAG, "Setting audio route to Earpiece.")
-                audioManager?.isSpeakerphoneOn = false
                 audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
             }
             "Bluetooth" -> {
@@ -648,9 +572,43 @@ object CallEngine {
             }
             else -> {
                 Log.w(TAG, "Unknown audio route: $route. No action taken.")
+                return
             }
         }
-        emitEvent(CallEventType.AUDIO_ROUTE_CHANGED, JSONObject().put("route", route))
+
+        // Only emit event if route actually changed
+        val newRoute = getCurrentAudioRoute()
+        if (previousRoute != newRoute) {
+            emitEvent(CallEventType.AUDIO_ROUTE_CHANGED, JSONObject().put("route", newRoute))
+        }
+    }
+
+    private fun getCurrentAudioRoute(): String {
+        return when {
+            audioManager?.isBluetoothScoOn == true -> "Bluetooth"
+            audioManager?.isSpeakerphoneOn == true -> "Speaker"
+            audioManager?.isWiredHeadsetOn == true -> "Headset"
+            else -> "Earpiece"
+        }
+    }
+
+    private fun setInitialAudioRoute(context: Context, callType: String) {
+        // Get available audio devices to determine priority
+        val availableDevices = getAudioDevices()
+
+        val defaultRoute = when {
+            // Prioritize Bluetooth if available (latest connected device)
+            availableDevices.devices.contains("Bluetooth") -> "Bluetooth"
+            // Then wired headset
+            availableDevices.devices.contains("Headset") -> "Headset"
+            // For video calls, default to speaker if no priority device
+            callType == "Video" -> "Speaker"
+            // For audio calls, default to earpiece if no priority device
+            else -> "Earpiece"
+        }
+
+        Log.d(TAG, "Setting initial audio route for $callType call: $defaultRoute")
+        setAudioRoute(context, defaultRoute)
     }
 
     fun resetAudioMode(context: Context) {
@@ -666,7 +624,51 @@ object CallEngine {
         }
     }
 
-    // --- Screen Awake Management ---
+    // --- 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()
+        }
+    }
+
+    fun registerAudioDeviceCallback(context: Context) {
+        appContext = context.applicationContext
+        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        audioManager?.registerAudioDeviceCallback(audioDeviceCallback, null)
+        Log.d(TAG, "Audio device callback registered.")
+    }
+
+    fun unregisterAudioDeviceCallback(context: Context) {
+        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
+        Log.d(TAG, "Audio device callback unregistered.")
+    }
+
+    private fun emitAudioDevicesChangedIfNeeded() {
+        val context = appContext ?: return
+        val currentAudioInfo = getAudioDevices()
+
+        // Only emit if something actually changed
+        if (lastAudioRoutesInfo == null ||
+            !currentAudioInfo.devices.contentEquals(lastAudioRoutesInfo!!.devices) ||
+            currentAudioInfo.currentRoute != lastAudioRoutesInfo!!.currentRoute) {
+
+            lastAudioRoutesInfo = currentAudioInfo
+            val jsonPayload = JSONObject().apply {
+                put("devices", JSONArray(currentAudioInfo.devices.toList()))
+                put("currentRoute", currentAudioInfo.currentRoute)
+            }
+            emitEvent(CallEventType.AUDIO_DEVICES_CHANGED, jsonPayload)
+        }
+    }
+
+    // --- Screen Management ---
     fun keepScreenAwake(context: Context, keepAwake: Boolean) {
         val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
         if (keepAwake) {
@@ -677,8 +679,6 @@ object CallEngine {
                 )
                 wakeLock?.acquire(10 * 60 * 1000L /* 10 minutes */)
                 Log.d(TAG, "Acquired SCREEN_DIM_WAKE_LOCK.")
-            } else {
-                Log.d(TAG, "Wake lock already held.")
             }
         } else {
             wakeLock?.let {
@@ -691,61 +691,58 @@ object CallEngine {
         }
     }
 
-    // --- Audio Device Change Listener ---
-    private val audioDeviceCallback = object : AudioDeviceCallback() {
-        override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
-            Log.d(TAG, "Audio devices added. Emitting AUDIO_DEVICES_CHANGED.")
-            emitAudioDevicesChanged()
-        }
-        override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
-            Log.d(TAG, "Audio devices removed. Emitting AUDIO_DEVICES_CHANGED.")
-            emitAudioDevicesChanged()
-        }
+    // --- Utility Methods ---
+    fun getActiveCalls(): List<CallInfo> = activeCalls.values.toList()
+    fun getCurrentCallId(): String? = currentCallId
+    fun isCallActive(): Boolean = activeCalls.any {
+        it.value.state == CallState.ACTIVE ||
+        it.value.state == CallState.INCOMING ||
+        it.value.state == CallState.DIALING
     }
 
-    fun registerAudioDeviceCallback(context: Context) {
-        appContext = context.applicationContext
-        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-        audioManager?.registerAudioDeviceCallback(audioDeviceCallback, null)
-        Log.d(TAG, "Audio device callback registered.")
+    private fun validateOutgoingCallRequest(): Boolean {
+        return !activeCalls.any {
+            it.value.state == CallState.INCOMING || it.value.state == CallState.ACTIVE
+        }
     }
 
-    fun unregisterAudioDeviceCallback(context: Context) {
-        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-        audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
-        Log.d(TAG, "Audio device callback unregistered.")
+    private fun extractCallerName(callData: String): String {
+        return try {
+            JSONObject(callData).optString("name", "Unknown")
+        } catch (e: Exception) {
+            "Unknown"
+        }
     }
 
-    fun emitAudioDevicesChanged() {
-        val context = appContext ?: run {
-            Log.w(TAG, "Cannot emit AudioDevicesChanged: appContext is null.")
-            return
-        }
-        val audioInfo = getAudioDevices()
-        val jsonPayload = JSONObject().apply {
-            put("devices", JSONArray(audioInfo.devices.toList()))
-            put("currentRoute", audioInfo.currentRoute)
+    private fun extractCallType(callData: String): String {
+        return try {
+            JSONObject(callData).optString("callType", "Audio")
+        } catch (e: Exception) {
+            "Audio"
         }
-        emitEvent(CallEventType.AUDIO_DEVICES_CHANGED, jsonPayload)
     }
 
-    // --- Call State Change Notification ---
-    private fun notifyCallStateChanged(context: Context) {
-        val calls = getActiveCalls()
-        val jsonArray = JSONArray()
-        calls.forEach {
-            val obj = JSONObject()
-            obj.put("callId", it.callId)
-            obj.put("callData", it.callData)
-            obj.put("state", it.state.name)
-            obj.put("callType", it.callType)
-            jsonArray.put(obj)
+    private fun rejectIncomingCallCollision(callId: String, reason: String) {
+        // Provide space for server HTTP request
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                // TODO: Add your server HTTP request here
+                // Example:
+                // ApiService.rejectCall(callId, reason)
+                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)
+            }
         }
-        val jsonPayload = JSONObject().put("calls", jsonArray)
-        Log.d(TAG, "Call state changed. Emitting CALL_STATE_CHANGED: $jsonPayload")
-        emitEvent(CallEventType.CALL_STATE_CHANGED, jsonPayload)
+
+        // Emit rejection event
+        emitEvent(CallEventType.CALL_REJECTED, JSONObject().apply {
+            put("callId", callId)
+            put("reason", reason)
+        })
     }
 
+    // --- Notification Management ---
     private fun createNotificationChannel(context: Context) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val channel = NotificationChannel(
@@ -757,6 +754,7 @@ object CallEngine {
             channel.enableLights(true)
             channel.lightColor = Color.GREEN
             channel.enableVibration(true)
+
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
                 channel.setSound(
                     RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE),
@@ -769,20 +767,138 @@ object CallEngine {
                 channel.setSound(null, null)
                 channel.importance = NotificationManager.IMPORTANCE_HIGH
             }
+
             val manager = context.getSystemService(NotificationManager::class.java)
             manager.createNotificationChannel(channel)
             Log.d(TAG, "Notification channel '$NOTIF_CHANNEL_ID' created/updated.")
         }
     }
 
-    // PhoneAccount registration is used for both INCOMING and OUTGOING calls when interacting with Telecom
+    fun showIncomingCallUI(context: Context, callId: String, callerName: String, callType: String) {
+        Log.d(TAG, "Showing incoming call UI for $callId, caller: $callerName, callType: $callType")
+        createNotificationChannel(context)
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        val answerIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
+            action = "com.qusaieilouti99.callmanager.ANSWER_CALL"
+            putExtra("callId", callId)
+        }
+        val answerPendingIntent = PendingIntent.getBroadcast(
+            context, 0, answerIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val declineIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
+            action = "com.qusaieilouti99.callmanager.DECLINE_CALL"
+            putExtra("callId", callId)
+        }
+        val declinePendingIntent = PendingIntent.getBroadcast(
+            context, 1, declineIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val fullScreenIntent = Intent(context, CallActivity::class.java).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            putExtra("callId", callId)
+            putExtra("callerName", callerName)
+            putExtra("callType", callType)
+        }
+        val fullScreenPendingIntent = PendingIntent.getActivity(
+            context, 2, fullScreenIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val person = android.app.Person.Builder().setName(callerName).setImportant(true).build()
+            Notification.Builder(context, NOTIF_CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.sym_call_incoming)
+                .setStyle(Notification.CallStyle.forIncomingCall(person, declinePendingIntent, answerPendingIntent))
+                .setFullScreenIntent(fullScreenPendingIntent, true)
+                .setOngoing(true)
+                .setAutoCancel(false)
+                .build()
+        } else {
+            Notification.Builder(context, NOTIF_CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.sym_call_incoming)
+                .setContentTitle("Incoming Call")
+                .setContentText(callerName)
+                .setPriority(Notification.PRIORITY_HIGH)
+                .setCategory(Notification.CATEGORY_CALL)
+                .setFullScreenIntent(fullScreenPendingIntent, true)
+                .addAction(android.R.drawable.sym_action_call, "Answer", answerPendingIntent)
+                .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Decline", declinePendingIntent)
+                .setOngoing(true)
+                .setAutoCancel(false)
+                .build()
+        }
+
+        notificationManager.notify(NOTIF_ID, notification)
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            playRingtone(context)
+        }
+
+        setInitialAudioRoute(context, callType)
+    }
+
+    fun cancelIncomingCallUI(context: Context) {
+        Log.d(TAG, "Cancelling incoming call UI.")
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.cancel(NOTIF_ID)
+        stopRingtone()
+    }
+
+    // --- Service Management ---
+    fun startForegroundService(context: Context) {
+        Log.d(TAG, "Starting CallForegroundService.")
+        val intent = Intent(context, CallForegroundService::class.java)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent)
+        } else {
+            context.startService(intent)
+        }
+    }
+
+    fun stopForegroundService(context: Context) {
+        Log.d(TAG, "Stopping CallForegroundService.")
+        val intent = Intent(context, CallForegroundService::class.java)
+        context.stopService(intent)
+    }
+
+    fun bringAppToForeground(context: Context) {
+        val packageName = context.packageName
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
+        launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+
+        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 {
+            context.startActivity(launchIntent)
+            Handler(Looper.getMainLooper()).postDelayed({
+                updateLockScreenBypass()
+            }, 100)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to bring app to foreground: ${e.message}")
+        }
+    }
+
+    // --- Phone Account Management ---
     private fun registerPhoneAccount(context: Context) {
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
         val phoneAccountHandle = getPhoneAccountHandle(context)
+
         if (telecomManager.getPhoneAccount(phoneAccountHandle) == null) {
             val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "PingMe Call")
                 .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
                 .build()
+
             try {
                 telecomManager.registerPhoneAccount(phoneAccount)
                 Log.d(TAG, "PhoneAccount registered successfully.")
@@ -803,12 +919,13 @@ object CallEngine {
         )
     }
 
-    // --- Ringtone Management (for incoming calls, pre-Android S) ---
+    // --- Media Management ---
     fun playRingtone(context: Context) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             Log.d(TAG, "playRingtone: Android S+ detected, system will handle ringtone via Telecom.")
             return
         }
+
         try {
             Log.d(TAG, "Playing ringtone (for Android < S).")
             val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
@@ -825,7 +942,7 @@ object CallEngine {
 
     fun stopRingtone() {
         try {
-            if (ringtone != null && ringtone!!.isPlaying) {
+            if (ringtone?.isPlaying == true) {
                 ringtone?.stop()
                 Log.d(TAG, "Ringtone stopped.")
             }
@@ -835,12 +952,12 @@ object CallEngine {
         ringtone = null
     }
 
-    // --- Ringback Tone Management (for outgoing calls) ---
     private fun startRingback() {
-        if (ringbackPlayer != null && ringbackPlayer!!.isPlaying) {
+        if (ringbackPlayer?.isPlaying == true) {
             Log.d(TAG, "Ringback tone already playing.")
             return
         }
+
         try {
             val ringbackUri = Uri.parse("android.resource://${appContext?.packageName}/raw/ringback_tone")
             ringbackPlayer = MediaPlayer.create(appContext, ringbackUri)
@@ -848,6 +965,7 @@ object CallEngine {
                 Log.e(TAG, "Failed to create MediaPlayer for ringback. Check raw/ringback_tone.mp3 exists.")
                 return
             }
+
             ringbackPlayer?.apply {
                 isLooping = true
                 setAudioAttributes(
@@ -866,7 +984,7 @@ object CallEngine {
 
     private fun stopRingback() {
         try {
-            if (ringbackPlayer != null && ringbackPlayer!!.isPlaying) {
+            if (ringbackPlayer?.isPlaying == true) {
                 ringbackPlayer?.stop()
                 ringbackPlayer?.release()
                 Log.d(TAG, "Ringback tone stopped and released.")
@@ -877,4 +995,46 @@ object CallEngine {
             ringbackPlayer = null
         }
     }
+
+    // --- Event Management ---
+    private fun notifySpecificCallStateChanged(context: Context, callId: String, newState: CallState) {
+        val callInfo = activeCalls[callId] ?: return
+
+        val jsonPayload = JSONObject().apply {
+            put("callId", callId)
+            put("callData", callInfo.callData)
+            put("state", newState.name)
+            put("callType", callInfo.callType)
+        }
+
+        Log.d(TAG, "Specific call state changed. Emitting CALL_STATE_CHANGED for $callId: $newState")
+        emitEvent(CallEventType.CALL_STATE_CHANGED, jsonPayload)
+    }
+
+    private fun updateForegroundNotification(context: Context) {
+        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("callData", it.callData)
+            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(context: Context) {
+        Log.d(TAG, "Performing final cleanup - no active calls remaining")
+        stopForegroundService(context)
+        keepScreenAwake(context, false)
+        resetAudioMode(context)
+    }
 }