@qusaieilouti99/call-manager 0.1.147 → 0.1.148

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

@@ -1,7 +1,6 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
 import android.app.ActivityManager
-import android.app.KeyguardManager
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
@@ -9,6 +8,8 @@ import android.app.PendingIntent
 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.AudioDeviceInfo
 import android.media.AudioManager
@@ -20,8 +21,6 @@ import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
 import android.os.PowerManager
-import android.os.VibrationEffect
-import android.os.Vibrator
 import android.telecom.Connection
 import android.telecom.DisconnectCause
 import android.telecom.PhoneAccount
@@ -33,857 +32,1357 @@ import org.json.JSONObject
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.atomic.AtomicBoolean
+import android.app.KeyguardManager
+import android.os.Vibrator
+import android.os.VibrationEffect
 
+/**
+ * Core call‐management engine. Manages self-managed telecom calls,
+ * audio routing, UI notifications, etc.
+ *
+ * NOTE: Volume key silencing is now handled by the system via `Connection.onSilence()`,
+ * which calls `silenceIncomingCall()` on this object.
+ */
 object CallEngine {
-    private const val TAG = "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
-
-    interface CallEndListener {
-        fun onCallEnded(callId: String)
+  private const val TAG = "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
+
+  interface CallEndListener {
+    fun onCallEnded(callId: String)
+  }
+
+  private val callEndListeners = CopyOnWriteArrayList<CallEndListener>()
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  fun registerCallEndListener(l: CallEndListener) {
+    callEndListeners.add(l)
+  }
+
+  fun unregisterCallEndListener(l: CallEndListener) {
+    callEndListeners.remove(l)
+  }
+
+  @Volatile private var appContext: Context? = null
+  private val isInitialized = AtomicBoolean(false)
+  private val initializationLock = Any()
+
+  private var ringtone: android.media.Ringtone? = null
+  private var ringbackPlayer: MediaPlayer? = null
+  private var vibrator: Vibrator? = null
+  private var audioManager: AudioManager? = null
+  private var wakeLock: PowerManager.WakeLock? = null
+
+  private val activeCalls = ConcurrentHashMap<String, CallInfo>()
+  private val telecomConnections = ConcurrentHashMap<String, Connection>()
+  private val callMetadata = ConcurrentHashMap<String, String>()
+
+  // NEW: Track incoming calls to prevent duplicates
+  private val incomingCallIds = ConcurrentHashMap<String, Long>()
+
+  private var currentCallId: String? = null
+  private var canMakeMultipleCalls: Boolean = false
+  private var lastAudioRoutesInfo: AudioRoutesInfo? = null
+  private var lockScreenBypassActive = false
+  private val lockScreenBypassCallbacks = mutableSetOf<LockScreenBypassCallback>()
+  private var eventHandler: ((CallEventType, String) -> Unit)? = null
+  private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
+
+  // NEW: Track ringtone state to prevent double ringing
+  private var isCustomRingtoneActive = false
+  private val ringtoneStateLock = Any()
+
+  interface LockScreenBypassCallback {
+    fun onLockScreenBypassChanged(shouldBypass: Boolean)
+  }
+
+  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")
+        if (isCallActive()) {
+          startForegroundService()
+        }
+      }
     }
-
-    interface LockScreenBypassCallback {
-        fun onLockScreenBypassChanged(shouldBypass: Boolean)
+  }
+
+  fun isInitialized(): Boolean = isInitialized.get()
+
+  private fun requireContext(): Context {
+    return appContext ?: throw IllegalStateException(
+      "CallEngine not initialized. Call initialize() in Application.onCreate()"
+    )
+  }
+
+  /**
+   * Get the application context. Returns null if not initialized.
+   */
+  fun getContext(): Context? = appContext
+
+  fun setEventHandler(handler: ((CallEventType, String) -> Unit)?) {
+    Log.d(TAG, "setEventHandler called. Handler present: ${handler != null}")
+    eventHandler = handler
+    handler?.let { h ->
+      if (cachedEvents.isNotEmpty()) {
+        Log.d(TAG, "Emitting ${cachedEvents.size} cached events.")
+        cachedEvents.forEach { (type, data) -> h.invoke(type, data) }
+        cachedEvents.clear()
+      }
     }
-
-    private val callEndListeners = CopyOnWriteArrayList<CallEndListener>()
-    private val mainHandler = Handler(Looper.getMainLooper())
-
-    fun registerCallEndListener(l: CallEndListener) {
-        callEndListeners.add(l)
+  }
+
+  fun emitEvent(type: CallEventType, data: JSONObject) {
+    Log.d(TAG, "Emitting event: $type")
+    val dataString = data.toString()
+    if (eventHandler != null) {
+      eventHandler?.invoke(type, dataString)
+    } else {
+      Log.d(TAG, "No event handler, caching event: $type")
+      cachedEvents.add(Pair(type, dataString))
     }
-
-    fun unregisterCallEndListener(l: CallEndListener) {
-        callEndListeners.remove(l)
+  }
+
+  /**
+   * NEW: Check if device supports CallStyle notifications
+   */
+  private fun supportsCallStyleNotifications(): Boolean {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return false
+
+    val manufacturer = Build.MANUFACTURER.lowercase()
+    val brand = Build.BRAND.lowercase()
+
+    // Known good manufacturers that support CallStyle properly
+    val supportedManufacturers = setOf(
+      "google", "samsung", "oneplus", "motorola", "sony", "lg", "htc"
+    )
+
+    val supportedBrands = setOf(
+      "google", "samsung", "oneplus", "motorola", "sony", "lg", "htc", "pixel"
+    )
+
+    val isSupported = supportedManufacturers.contains(manufacturer) ||
+                     supportedBrands.contains(brand) ||
+                     manufacturer.contains("google") ||
+                     brand.contains("pixel")
+
+    Log.d(TAG, "CallStyle support check - Manufacturer: $manufacturer, Brand: $brand, Supported: $isSupported")
+    return isSupported
+  }
+
+  /**
+   * Silences the incoming call ringtone. This is called by `Connection.onSilence()`
+   * when the user presses a volume key during ringing.
+   */
+  fun silenceIncomingCall() {
+    Log.d(TAG, "Silencing incoming call ringtone via Connection.onSilence()")
+    stopRingtone()
+  }
+
+  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)
+        }
+      }
     }
+  }
 
-    @Volatile private var appContext: Context? = null
-    private val isInitialized = AtomicBoolean(false)
-    private val initializationLock = Any()
-
-    private var ringtone: android.media.Ringtone? = null
-    private var ringbackPlayer: MediaPlayer? = null
-    private var vibrator: Vibrator? = null
-    private var audioManager: AudioManager? = null
-    private var wakeLock: PowerManager.WakeLock? = null
+  fun isLockScreenBypassActive(): Boolean = lockScreenBypassActive
 
-    private val activeCalls = ConcurrentHashMap<String, CallInfo>()
-    private val telecomConnections = ConcurrentHashMap<String, Connection>()
-    private val callMetadata = ConcurrentHashMap<String, String>()
-    private val incomingCallIds = ConcurrentHashMap<String, Long>()
+  fun addTelecomConnection(callId: String, connection: Connection) {
+    telecomConnections[callId] = connection
+    Log.d(TAG, "Added Telecom Connection for callId: $callId")
+  }
 
-    private var currentCallId: String? = null
-    private var canMakeMultipleCalls: Boolean = false
-    private var eventHandler: ((CallEventType, String) -> Unit)? = null
-    private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
+  fun removeTelecomConnection(callId: String) {
+    telecomConnections.remove(callId)
+    Log.d(TAG, "Removed Telecom Connection for callId: $callId")
+  }
 
-    private var userSelectedAudioRoute: String? = null
-    private val audioStateLock = Any()
+  fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
 
-    private var lockScreenBypassActive = false
-    private val lockScreenBypassCallbacks = mutableSetOf<LockScreenBypassCallback>()
+  fun setCanMakeMultipleCalls(allow: Boolean) {
+    canMakeMultipleCalls = allow
+    Log.d(TAG, "canMakeMultipleCalls set to: $allow")
+  }
 
-    fun initialize(context: Context) {
-        synchronized(initializationLock) {
-            if (isInitialized.compareAndSet(false, true)) {
-                appContext = context.applicationContext
-                audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
-                registerAudioDeviceCallback()
-                Log.d(TAG, "CallEngine initialized successfully")
-            }
-        }
+  fun getCurrentCallState(): String {
+    val calls = getActiveCalls()
+    val jsonArray = JSONArray()
+    calls.forEach {
+      jsonArray.put(it.toJsonObject())
+    }
+    return jsonArray.toString()
+  }
+
+  fun reportIncomingCall(
+    context: Context,
+    callId: String,
+    callType: String,
+    displayName: String,
+    pictureUrl: String? = null,
+    metadata: String? = null
+  ) {
+    if (!isInitialized.get()) {
+      initialize(context)
     }
 
-    fun isInitialized(): Boolean = isInitialized.get()
-
-    private fun requireContext(): Context {
-        return appContext ?: throw IllegalStateException(
-            "CallEngine not initialized. Call initialize() in Application.onCreate()"
-        )
+    // NEW: Guard against duplicate calls
+    val currentTime = System.currentTimeMillis()
+    val lastCallTime = incomingCallIds[callId]
+    if (lastCallTime != null && (currentTime - lastCallTime) < 5000) {
+      Log.w(TAG, "Ignoring duplicate incoming call for callId: $callId (last call ${currentTime - lastCallTime}ms ago)")
+      return
     }
+    incomingCallIds[callId] = currentTime
 
-    fun getContext(): Context? = appContext
+    // Clean up old entries (older than 30 seconds)
+    val cutoffTime = currentTime - 30000
+    incomingCallIds.entries.removeAll { it.value < cutoffTime }
 
-    fun setEventHandler(handler: ((CallEventType, String) -> Unit)?) {
-        Log.d(TAG, "setEventHandler called. Handler present: ${handler != null}")
-        eventHandler = handler
-        handler?.let { h ->
-            if (cachedEvents.isNotEmpty()) {
-                Log.d(TAG, "Emitting ${cachedEvents.size} cached events.")
-                cachedEvents.forEach { (type, data) -> h.invoke(type, data) }
-                cachedEvents.clear()
-            }
-        }
+    Log.d(TAG, "reportIncomingCall: callId=$callId, type=$callType, name=$displayName")
+    metadata?.let { callMetadata[callId] = it }
+
+    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")
+      rejectIncomingCallCollision(callId, "Another call is already incoming")
+      return
     }
 
-    fun emitEvent(type: CallEventType, data: JSONObject) {
-        Log.d(TAG, "Emitting event: $type")
-        val dataString = data.toString()
-        if (eventHandler != null) {
-            eventHandler?.invoke(type, dataString)
-        } else {
-            Log.d(TAG, "No event handler, caching event: $type")
-            cachedEvents.add(Pair(type, dataString))
-        }
+    val activeCall = activeCalls.values.find {
+      it.state == CallState.ACTIVE || it.state == CallState.HELD
+    }
+    if (activeCall != null && !canMakeMultipleCalls) {
+      Log.d(TAG, "Active call exists when receiving incoming call. Auto-rejecting: $callId")
+      rejectIncomingCallCollision(callId, "Another call is already active")
+      return
     }
 
-    private fun supportsCallStyleNotifications(): Boolean {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return false
-        val manufacturer = Build.MANUFACTURER.lowercase()
-        val supportedManufacturers = setOf("google", "samsung")
-        return supportedManufacturers.contains(manufacturer)
+    val isVideoCall = callType == "Video"
+    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
+      activeCalls.values.forEach {
+        if (it.state == CallState.ACTIVE) {
+          holdCallInternal(it.callId, heldBySystem = false)
+        }
+      }
     }
 
-    fun silenceIncomingCall() {
-        Log.d(TAG, "Silencing incoming call ringtone via Connection.onSilence()")
-        stopRingtone()
+    activeCalls[callId] =
+      CallInfo(callId, callType, displayName, pictureUrl, CallState.INCOMING)
+    currentCallId = callId
+    Log.d(TAG, "Call $callId added to activeCalls. State: INCOMING")
+
+    showIncomingCallUI(callId, displayName, callType, pictureUrl)
+    registerPhoneAccount()
+
+    val telecomManager =
+      requireContext().getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+    val phoneAccountHandle = getPhoneAccountHandle()
+    val extras = Bundle().apply {
+      putString(MyConnectionService.EXTRA_CALL_ID, callId)
+      putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
+      putString(MyConnectionService.EXTRA_DISPLAY_NAME, displayName)
+      putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, isVideoCall)
+      pictureUrl?.let { putString(MyConnectionService.EXTRA_PICTURE_URL, it) }
     }
 
-    fun registerLockScreenBypassCallback(callback: LockScreenBypassCallback) {
-        lockScreenBypassCallbacks.add(callback)
+    try {
+      telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
+      startForegroundService()
+      Log.d(TAG, "Successfully reported incoming call to TelecomManager for $callId")
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to report incoming call: ${e.message}", e)
+      endCallInternal(callId)
     }
 
-    fun unregisterLockScreenBypassCallback(callback: LockScreenBypassCallback) {
-        lockScreenBypassCallbacks.remove(callback)
+    updateLockScreenBypass()
+  }
+
+  fun startOutgoingCall(
+    callId: String,
+    callType: String,
+    targetName: String,
+    metadata: String? = null
+  ) {
+    val context = requireContext()
+    Log.d(TAG, "startOutgoingCall: callId=$callId, type=$callType, target=$targetName")
+    metadata?.let { callMetadata[callId] = it }
+
+    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
     }
 
-    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)
-                }
-            }
+    val isVideoCall = callType == "Video"
+    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
+      activeCalls.values.forEach {
+        if (it.state == CallState.ACTIVE) {
+          holdCallInternal(it.callId, heldBySystem = false)
         }
+      }
     }
 
-    fun isLockScreenBypassActive(): Boolean = lockScreenBypassActive
+    activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.DIALING)
+    currentCallId = callId
+    Log.d(TAG, "Call $callId added to activeCalls. State: DIALING")
+
+    setAudioMode()
+    registerPhoneAccount()
+
+    val telecomManager =
+      context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+    val phoneAccountHandle = getPhoneAccountHandle()
+    val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, targetName, null)
 
-    fun addTelecomConnection(callId: String, connection: Connection) {
-        telecomConnections[callId] = connection
+    val outgoingExtras = Bundle().apply {
+      putString(MyConnectionService.EXTRA_CALL_ID, callId)
+      putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
+      putString(MyConnectionService.EXTRA_DISPLAY_NAME, targetName)
+      putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, isVideoCall)
+      metadata?.let { putString("metadata", it) }
     }
 
-    fun removeTelecomConnection(callId: String) {
-        telecomConnections.remove(callId)
+    val extras = Bundle().apply {
+      putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
+      putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
+      putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, isVideoCall)
     }
 
-    fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
+    try {
+      telecomManager.placeCall(addressUri, extras)
+      startForegroundService()
+      startRingback()
+      bringAppToForeground()
+      keepScreenAwake(true)
+      Log.d(TAG, "Successfully reported outgoing call to TelecomManager")
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to start outgoing call: ${e.message}", e)
+      endCallInternal(callId)
+    }
 
-    fun reportIncomingCall(
-        context: Context,
-        callId: String,
-        callType: String,
-        displayName: String,
-        pictureUrl: String? = null,
-        metadata: String? = null
-    ) {
-        if (!isInitialized.get()) {
-            initialize(context)
-        }
+    updateLockScreenBypass()
+  }
+
+  fun startCall(
+    callId: String,
+    callType: String,
+    targetName: String,
+    metadata: String? = null
+  ) {
+    Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
+    metadata?.let { callMetadata[callId] = it }
+
+    if (activeCalls.containsKey(callId)) {
+      Log.w(TAG, "Call $callId already exists, cannot start again")
+      return
+    }
 
-        val currentTime = System.currentTimeMillis()
-        if (incomingCallIds.containsKey(callId) || activeCalls.containsKey(callId)) {
-            Log.w(TAG, "Ignoring duplicate incoming call report for callId: $callId")
-            return
-        }
-        incomingCallIds[callId] = currentTime
-
-        Log.d(TAG, "reportIncomingCall: callId=$callId, type=$callType, name=$displayName")
-        metadata?.let { callMetadata[callId] = it }
-
-        activeCalls[callId] =
-            CallInfo(callId, callType, displayName, pictureUrl, CallState.INCOMING)
-        currentCallId = callId
-
-        showIncomingCallUI(callId, displayName, callType, pictureUrl)
-        registerPhoneAccount()
-
-        val telecomManager =
-            requireContext().getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle()
-        val extras = Bundle().apply {
-            putString(MyConnectionService.EXTRA_CALL_ID, callId)
-            putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
-            putString(MyConnectionService.EXTRA_DISPLAY_NAME, displayName)
-            putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, callType == "Video")
-            pictureUrl?.let { putString(MyConnectionService.EXTRA_PICTURE_URL, it) }
+    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
+      activeCalls.values.forEach {
+        if (it.state == CallState.ACTIVE) {
+          holdCallInternal(it.callId, heldBySystem = false)
         }
+      }
+    }
 
-        try {
-            telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
-            startForegroundService()
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to report incoming call: ${e.message}", e)
-            endCallInternal(callId)
-        }
-        updateLockScreenBypass()
+    activeCalls[callId] =
+      CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
+    currentCallId = callId
+    Log.d(TAG, "Call $callId started as ACTIVE")
+
+    registerPhoneAccount()
+    setAudioMode()
+    bringAppToForeground()
+    startForegroundService()
+    keepScreenAwake(true)
+
+    // NEW: Improved initial audio route setting with better timing
+    mainHandler.postDelayed({
+      setInitialAudioRoute(callType, isCallStart = true)
+    }, 500L)
+
+    updateLockScreenBypass()
+    emitOutgoingCallAnsweredWithMetadata(callId)
+  }
+
+  fun callAnsweredFromJS(callId: String) {
+    Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
+    coreCallAnswered(callId, isLocalAnswer = false)
+  }
+
+  fun answerCall(callId: String) {
+    Log.d(TAG, "answerCall: $callId - local party answering")
+    coreCallAnswered(callId, isLocalAnswer = true)
+  }
+
+  private fun coreCallAnswered(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
     }
 
-    fun startOutgoingCall(
-        callId: String,
-        callType: String,
-        targetName: String,
-        metadata: String? = null
-    ) {
-        val context = requireContext()
-        Log.d(TAG, "startOutgoingCall: callId=$callId, type=$callType, target=$targetName")
-        metadata?.let { callMetadata[callId] = it }
-
-        activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.DIALING)
-        currentCallId = callId
-        Log.d(TAG, "Call $callId added to activeCalls. State: DIALING")
-
-        registerPhoneAccount()
-
-        val telecomManager =
-            context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle()
-        val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, targetName, null)
-
-        val outgoingExtras = Bundle().apply {
-            putString(MyConnectionService.EXTRA_CALL_ID, callId)
-            putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
-            putString(MyConnectionService.EXTRA_DISPLAY_NAME, targetName)
-            putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, callType == "Video")
-            metadata?.let { putString("metadata", it) }
-        }
+    activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
+    currentCallId = callId
+    Log.d(TAG, "Call $callId set to ACTIVE state")
 
-        val extras = Bundle().apply {
-            putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
-            putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
-            putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, callType == "Video")
-        }
+    stopRingtone()
+    stopRingback()
+    cancelIncomingCallUI()
 
-        try {
-            telecomManager.placeCall(addressUri, extras)
-            startForegroundService()
-            startRingback()
-            bringAppToForeground()
-            keepScreenAwake(true)
-            Log.d(TAG, "Successfully reported outgoing call to TelecomManager")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to start outgoing call: ${e.message}", e)
-            endCallInternal(callId)
+    if (!canMakeMultipleCalls) {
+      activeCalls.filter { it.key != callId }.values.forEach { otherCall ->
+        if (otherCall.state == CallState.ACTIVE) {
+          holdCallInternal(otherCall.callId, heldBySystem = false)
         }
-        updateLockScreenBypass()
+      }
     }
 
-    fun startCall(
-        callId: String,
-        callType: String,
-        targetName: String,
-        metadata: String? = null
-    ) {
-        Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
-        metadata?.let { callMetadata[callId] = it }
-
-        if (activeCalls.containsKey(callId)) {
-            Log.w(TAG, "Call $callId already exists, cannot start again")
-            return
-        }
+    bringAppToForeground()
+    startForegroundService()
+    keepScreenAwake(true)
+    updateLockScreenBypass()
 
-        activeCalls[callId] =
-            CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
-        currentCallId = callId
-        Log.d(TAG, "Call $callId started as ACTIVE")
+    setAudioMode()
 
-        registerPhoneAccount()
-        bringAppToForeground()
-        startForegroundService()
-        keepScreenAwake(true)
+    // NEW: Improved initial audio route with longer delay and retry mechanism
+    mainHandler.postDelayed({
+      setInitialAudioRoute(callInfo.callType, isCallStart = true)
 
-        synchronized(audioStateLock) {
-            userSelectedAudioRoute = null
-        }
+      // Retry after additional delay if needed for video calls
+      if (callInfo.callType == "Video") {
         mainHandler.postDelayed({
-            updateAndApplyAudioRoute()
-        }, 300)
-
-        emitEvent(CallEventType.OUTGOING_CALL_ANSWERED, JSONObject().apply {
-            put("callId", callId)
-            put("callType", callType)
-            put("displayName", targetName)
-        })
-        updateLockScreenBypass()
-    }
-
-    fun callAnsweredFromJS(callId: String) {
-        Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
-        coreCallAnswered(callId, isLocalAnswer = false)
-    }
-
-    fun answerCall(callId: String) {
-        Log.d(TAG, "answerCall: $callId - local party answering")
-        coreCallAnswered(callId, isLocalAnswer = true)
+          val currentRoute = getCurrentAudioRoute()
+          if (currentRoute != "Speaker") {
+            Log.d(TAG, "Retrying audio route for video call - current: $currentRoute")
+            setAudioRoute("Speaker")
+          }
+        }, 1000L)
+      }
+    }, 800L)
+
+    if (isLocalAnswer) {
+      emitCallAnsweredWithMetadata(callId)
+    } else {
+      emitOutgoingCallAnsweredWithMetadata(callId)
     }
 
-    private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
-        val callInfo = activeCalls[callId] ?: return
-        activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
-        currentCallId = callId
+    Log.d(TAG, "Call $callId successfully answered")
+  }
 
-        stopRingtone()
-        stopRingback()
-        cancelIncomingCallUI()
+  private fun emitCallAnsweredWithMetadata(callId: String) {
+    val callInfo = activeCalls[callId] ?: return
+    val metadata = callMetadata[callId]
 
-        bringAppToForeground()
-        startForegroundService()
-        keepScreenAwake(true)
-
-        synchronized(audioStateLock) {
-            userSelectedAudioRoute = null
+    emitEvent(CallEventType.CALL_ANSWERED, JSONObject().apply {
+      put("callId", callId)
+      put("callType", callInfo.callType)
+      put("displayName", callInfo.displayName)
+      callInfo.pictureUrl?.let { put("pictureUrl", it) }
+      metadata?.let {
+        try {
+          put("metadata", JSONObject(it))
+        } catch (e: Exception) {
+          put("metadata", it)
         }
-        mainHandler.postDelayed({
-            updateAndApplyAudioRoute()
-        }, 300)
-
-        if (isLocalAnswer) {
-            emitCallAnsweredWithMetadata(callId)
+      }
+    })
+  }
+
+  private fun emitOutgoingCallAnsweredWithMetadata(callId: String) {
+    val callInfo = activeCalls[callId] ?: return
+    val metadata = callMetadata[callId]
+
+    emitEvent(CallEventType.OUTGOING_CALL_ANSWERED, JSONObject().apply {
+      put("callId", callId)
+      put("callType", callInfo.callType)
+      put("displayName", callInfo.displayName)
+      callInfo.pictureUrl?.let { put("pictureUrl", it) }
+      metadata?.let {
+        try {
+          put("metadata", JSONObject(it))
+        } catch (e: Exception) {
+          put("metadata", it)
         }
-        updateLockScreenBypass()
+      }
+    })
+  }
+
+  fun holdCall(callId: String) {
+    holdCallInternal(callId, heldBySystem = false)
+  }
+
+  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")
+      return
     }
 
-    private fun emitCallAnsweredWithMetadata(callId: String) {
-        val callInfo = activeCalls[callId] ?: return
-        emitEvent(CallEventType.CALL_ANSWERED, JSONObject().apply {
-            put("callId", callId)
-            put("callType", callInfo.callType)
-            put("displayName", callInfo.displayName)
-            callInfo.pictureUrl?.let { put("pictureUrl", it) }
-        })
+    if (onHold && callInfo.state == CallState.ACTIVE) {
+      holdCallInternal(callId, heldBySystem = false)
+    } else if (!onHold && callInfo.state == CallState.HELD) {
+      unholdCallInternal(callId, resumedBySystem = false)
     }
-
-    fun setOnHold(callId: String, onHold: Boolean) {
-        if (onHold) {
-            holdCall(callId)
-        } else {
-            unholdCall(callId)
-        }
+  }
+
+  private fun holdCallInternal(callId: String, heldBySystem: Boolean) {
+    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")
+      return
     }
 
-    fun holdCall(callId: String) {
-        val callInfo = activeCalls[callId]
-        if (callInfo?.state != CallState.ACTIVE) {
-            Log.w(TAG, "Cannot hold call $callId - not in active state")
-            return
-        }
-        activeCalls[callId] = callInfo.copy(state = CallState.HELD)
-        telecomConnections[callId]?.setOnHold()
-        updateForegroundNotification()
-        emitEvent(CallEventType.CALL_HELD, JSONObject().put("callId", callId))
-        updateLockScreenBypass()
+    activeCalls[callId] = callInfo.copy(
+      state = CallState.HELD,
+      wasHeldBySystem = heldBySystem
+    )
+
+    telecomConnections[callId]?.setOnHold()
+    updateForegroundNotification()
+    emitEvent(CallEventType.CALL_HELD, JSONObject().put("callId", callId))
+    updateLockScreenBypass()
+  }
+
+  fun unholdCall(callId: String) {
+    unholdCallInternal(callId, resumedBySystem = false)
+  }
+
+  private fun unholdCallInternal(callId: String, resumedBySystem: Boolean) {
+    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")
+      return
     }
 
-    fun unholdCall(callId: String) {
-        val callInfo = activeCalls[callId]
-        if (callInfo?.state != CallState.HELD) {
-            Log.w(TAG, "Cannot unhold call $callId - not in held state")
-            return
-        }
-        activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
-        telecomConnections[callId]?.setActive()
-        updateForegroundNotification()
-        emitEvent(CallEventType.CALL_UNHELD, JSONObject().put("callId", callId))
-        updateLockScreenBypass()
+    activeCalls[callId] = callInfo.copy(
+      state = CallState.ACTIVE,
+      wasHeldBySystem = false
+    )
+
+    telecomConnections[callId]?.setActive()
+    updateForegroundNotification()
+    emitEvent(CallEventType.CALL_UNHELD, JSONObject().put("callId", callId))
+    updateLockScreenBypass()
+  }
+
+  fun muteCall(callId: String) {
+    setMutedInternal(callId, true)
+  }
+
+  fun unmuteCall(callId: String) {
+    setMutedInternal(callId, false)
+  }
+
+  fun setMuted(callId: String, muted: Boolean) {
+    setMutedInternal(callId, muted)
+  }
+
+  private fun setMutedInternal(callId: String, muted: Boolean) {
+    val callInfo = activeCalls[callId]
+    if (callInfo == null) {
+      Log.w(TAG, "Cannot set mute state for call $callId - not found")
+      return
     }
 
-    fun muteCall(callId: String) {
-        setMuted(callId, true)
-    }
+    val context = requireContext()
+    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
-    fun unmuteCall(callId: String) {
-        setMuted(callId, false)
-    }
+    val wasMuted = audioManager?.isMicrophoneMute ?: false
+    audioManager?.isMicrophoneMute = muted
 
-    fun setMuted(callId: String, muted: Boolean) {
-        val callInfo = activeCalls[callId]
-        if (callInfo == null) {
-            Log.w(TAG, "Cannot set mute state for call $callId - not found")
-            return
-        }
-        val am = audioManager ?: return
-        am.isMicrophoneMute = muted
-        val eventType = if (muted) CallEventType.CALL_MUTED else CallEventType.CALL_UNMUTED
-        emitEvent(eventType, JSONObject().put("callId", callId))
+    if (wasMuted != muted) {
+      val eventType = if (muted) CallEventType.CALL_MUTED else CallEventType.CALL_UNMUTED
+      emitEvent(eventType, JSONObject().put("callId", callId))
+      Log.d(TAG, "Call $callId mute state changed to: $muted")
     }
+  }
+
+  fun endCall(callId: String) {
+    Log.d(TAG, "endCall: $callId")
+    endCallInternal(callId)
+  }
+
+  fun endAllCalls() {
+    Log.d(TAG, "endAllCalls: Ending all active calls")
+    if (activeCalls.isEmpty()) return
 
-    fun endCall(callId: String) {
-        endCallInternal(callId)
+    activeCalls.keys.toList().forEach { callId ->
+      endCallInternal(callId)
     }
 
-    fun endAllCalls() {
-        Log.d(TAG, "endAllCalls: Ending all active calls")
-        if (activeCalls.isEmpty()) return
+    activeCalls.clear()
+    telecomConnections.clear()
+    callMetadata.clear()
+    incomingCallIds.clear() // NEW: Clear duplicate tracking
+    currentCallId = null
 
-        activeCalls.keys.toList().forEach { callId ->
-            endCallInternal(callId)
-        }
-        updateLockScreenBypass()
+    cleanup()
+    updateLockScreenBypass()
+  }
+
+  private fun endCallInternal(callId: String) {
+    Log.d(TAG, "endCallInternal: $callId")
+
+    val callInfo = activeCalls[callId] ?: run {
+      Log.w(TAG, "Call $callId not found in active calls")
+      return
     }
 
-    private fun endCallInternal(callId: String) {
-        val callInfo = activeCalls.remove(callId) ?: return
-        incomingCallIds.remove(callId)
-        callMetadata.remove(callId)
+    val metadata = callMetadata.remove(callId)
+    activeCalls.remove(callId)
+    incomingCallIds.remove(callId) // NEW: Clean up duplicate tracking
 
-        stopRingtone()
-        stopRingback()
-        cancelIncomingCallUI()
+    stopRingback()
+    stopRingtone()
+    cancelIncomingCallUI()
 
-        telecomConnections.remove(callId)?.let {
-            it.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
-            it.destroy()
-        }
+    if (currentCallId == callId) {
+      currentCallId =
+        activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
+    }
 
-        if (activeCalls.isEmpty()) {
-            cleanup()
-        } else {
-            updateForegroundNotification()
-        }
+    val context = requireContext()
+    val closeActivityIntent = Intent("com.qusaieilouti99.callmanager.CLOSE_CALL_ACTIVITY")
+      .setPackage(context.packageName)
+      .putExtra("callId", callId)
 
-        callEndListeners.forEach { it.onCallEnded(callId) }
-        emitEvent(CallEventType.CALL_ENDED, JSONObject().put("callId", callId))
-        updateLockScreenBypass()
+    try {
+      context.sendBroadcast(closeActivityIntent)
+      Log.d(TAG, "Sent close broadcast for CallActivity: $callId")
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to send close broadcast: ${e.message}")
     }
 
-    fun isCallActive(): Boolean = activeCalls.any {
-        it.value.state == CallState.ACTIVE ||
-                it.value.state == CallState.INCOMING ||
-                it.value.state == CallState.DIALING ||
-                it.value.state == CallState.HELD
+    telecomConnections[callId]?.let { connection ->
+      connection.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+      connection.destroy()
+      removeTelecomConnection(callId)
     }
 
-    fun setAudioRoute(route: String) {
-        synchronized(audioStateLock) {
-            Log.d(TAG, "User requested audio route: $route")
-            userSelectedAudioRoute = route
-        }
-        updateAndApplyAudioRoute()
+    if (activeCalls.isEmpty()) {
+      cleanup()
+    } else {
+      updateForegroundNotification()
     }
 
-    private fun updateAndApplyAudioRoute() {
-        // *** CRITICAL FIX ***
-        // Check for null currentCallId *before* using it as a key.
-        val callId = currentCallId
-        if (callId == null) {
-            Log.d(TAG, "Skipping audio route update: currentCallId is null.")
-            return
+    updateLockScreenBypass()
+
+    for (listener in callEndListeners) {
+      mainHandler.post {
+        try {
+          listener.onCallEnded(callId)
+        } catch (_: Throwable) {
+          // swallow
         }
+      }
+    }
 
-        val call = activeCalls[callId]
-        if (call == null || call.state != CallState.ACTIVE) {
-            Log.d(TAG, "Skipping audio route update: No active call.")
-            return
+    emitEvent(CallEventType.CALL_ENDED, JSONObject().apply {
+      put("callId", callId)
+      metadata?.let {
+        try { put("metadata", JSONObject(it)) }
+        catch (e: Exception) { put("metadata", it) }
+      }
+    })
+  }
+
+  fun getAudioDevices(): AudioRoutesInfo {
+    val context = requireContext()
+    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+      ?: return AudioRoutesInfo(emptyArray(), "Unknown")
+
+    val devices = mutableSetOf<String>()
+    devices.add("Speaker")
+    devices.add("Earpiece")
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      val infos = audioManager?.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
+      infos?.forEach { d ->
+        when (d.type) {
+          AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+          AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> devices.add("Bluetooth")
+          AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+          AudioDeviceInfo.TYPE_WIRED_HEADSET -> devices.add("Headset")
         }
+      }
+    } else {
+      @Suppress("DEPRECATION")
+      if (audioManager?.isBluetoothA2dpOn == true || audioManager?.isBluetoothScoOn == true)
+        devices.add("Bluetooth")
+      @Suppress("DEPRECATION")
+      if (audioManager?.isWiredHeadsetOn == true) devices.add("Headset")
+    }
 
-        synchronized(audioStateLock) {
-            val am = audioManager ?: return
-            val availableDevices = getAvailableAudioDevices()
-
-            val targetRoute = if (userSelectedAudioRoute != null && availableDevices.contains(userSelectedAudioRoute)) {
-                userSelectedAudioRoute!!
-            } else {
-                when {
-                    availableDevices.contains("Bluetooth") -> "Bluetooth"
-                    availableDevices.contains("Headset") -> "Headset"
-                    call.callType == "Video" -> "Speaker"
-                    else -> "Earpiece"
-                }
-            }
+    val current = getCurrentAudioRoute()
+    Log.d(TAG, "Available audio devices: ${devices.toList()}, current: $current")
 
-            Log.d(TAG, "Updating audio route. Available: $availableDevices, User Pref: $userSelectedAudioRoute, Target: $targetRoute")
-
-            am.mode = AudioManager.MODE_IN_COMMUNICATION
-
-            when (targetRoute) {
-                "Bluetooth" -> {
-                    am.isSpeakerphoneOn = false
-                    am.startBluetoothSco()
-                    am.isBluetoothScoOn = true
-                }
-                "Headset" -> {
-                    am.isSpeakerphoneOn = false
-                    am.stopBluetoothSco()
-                    am.isBluetoothScoOn = false
-                }
-                "Speaker" -> {
-                    am.isSpeakerphoneOn = true
-                    am.stopBluetoothSco()
-                    am.isBluetoothScoOn = false
-                }
-                "Earpiece" -> {
-                    am.isSpeakerphoneOn = false
-                    am.stopBluetoothSco()
-                    am.isBluetoothScoOn = false
-                }
-            }
+    // Convert strings to StringHolder objects
+    val deviceHolders = devices.map { StringHolder(it) }.toTypedArray()
+    lastAudioRoutesInfo = AudioRoutesInfo(deviceHolders, current)
+    return AudioRoutesInfo(deviceHolders, current)
+  }
 
-            mainHandler.postDelayed({ emitAudioRouteChanged() }, 100)
-        }
+  fun setAudioRoute(route: String) {
+    Log.d(TAG, "setAudioRoute called: $route")
+
+    val ctx = requireContext()
+    if (audioManager == null) {
+      audioManager = ctx.getSystemService(Context.AUDIO_SERVICE) as AudioManager
     }
+    val am = audioManager!!
 
-    private fun getAvailableAudioDevices(): Set<String> {
-        val am = audioManager ?: return emptySet()
-        val devices = mutableSetOf<String>()
-        devices.add("Earpiece")
-        devices.add("Speaker")
+    if (am.mode != AudioManager.MODE_IN_COMMUNICATION) {
+      am.mode = AudioManager.MODE_IN_COMMUNICATION
+    }
 
+    when (route) {
+      "Speaker" -> {
+        am.isSpeakerphoneOn = true
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && am.isBluetoothScoOn) {
+          am.stopBluetoothSco()
+          am.isBluetoothScoOn = false
+        }
+        Log.d(TAG, "Audio routed to SPEAKER")
+      }
+      "Earpiece" -> {
+        am.isSpeakerphoneOn = false
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && am.isBluetoothScoOn) {
+          am.stopBluetoothSco()
+          am.isBluetoothScoOn = false
+        }
+        Log.d(TAG, "Audio routed to EARPIECE")
+      }
+      "Bluetooth" -> {
+        am.isSpeakerphoneOn = false
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            val audioDevices = am.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
-            audioDevices.forEach {
-                when (it.type) {
-                    AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> devices.add("Bluetooth")
-                    AudioDeviceInfo.TYPE_WIRED_HEADSET, AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> devices.add("Headset")
-                }
-            }
+          am.startBluetoothSco()
+          am.isBluetoothScoOn = true
+          Log.d(TAG, "Audio routed to BLUETOOTH")
         } else {
-            @Suppress("DEPRECATION")
-            if (am.isBluetoothScoAvailableOffCall) devices.add("Bluetooth")
-            @Suppress("DEPRECATION")
-            if (am.isWiredHeadsetOn) devices.add("Headset")
+          Log.w(TAG, "Bluetooth SCO not supported on this OS version")
         }
-        return devices
+      }
+      "Headset" -> {
+        am.isSpeakerphoneOn = false
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && am.isBluetoothScoOn) {
+          am.stopBluetoothSco()
+          am.isBluetoothScoOn = false
+        }
+        Log.d(TAG, "Audio routed to HEADSET")
+      }
+      else -> {
+        Log.w(TAG, "Unknown audio route: $route")
+        return
+      }
     }
-
-    fun getAudioDevices(): AudioRoutesInfo {
-        val available = getAvailableAudioDevices().map { StringHolder(it) }.toTypedArray()
-        val current = getCurrentAudioRoute()
-        return AudioRoutesInfo(available, current)
+    emitAudioRouteChanged()
+  }
+
+  private fun getCurrentAudioRoute(): String {
+    return when {
+      audioManager?.isBluetoothScoOn == true -> "Bluetooth"
+      audioManager?.isSpeakerphoneOn == true -> "Speaker"
+      audioManager?.isWiredHeadsetOn == true -> "Headset"
+      else -> "Earpiece"
     }
-
-    private fun getCurrentAudioRoute(): String {
-        val am = audioManager ?: return "Unknown"
-        return when {
-            am.isBluetoothScoOn -> "Bluetooth"
-            am.isWiredHeadsetOn -> "Headset"
-            am.isSpeakerphoneOn -> "Speaker"
-            else -> "Earpiece"
-        }
+  }
+
+  // NEW: Improved initial audio route setting
+  private fun setInitialAudioRoute(callType: String, isCallStart: Boolean = false) {
+    val avail = getAudioDevices()
+    // Extract string values for comparison
+    val deviceStrings = avail.devices.map { it.value }
+
+    val defaultRoute = when {
+      deviceStrings.contains("Bluetooth") -> "Bluetooth"
+      deviceStrings.contains("Headset") -> "Headset"
+      callType == "Video" -> "Speaker"
+      else -> "Earpiece"
     }
 
-    private fun emitAudioRouteChanged() {
-        val info = getAudioDevices()
-        val payload = JSONObject().apply {
-            put("devices", JSONArray(info.devices.map { it.value }))
-            put("currentRoute", info.currentRoute)
-        }
-        emitEvent(CallEventType.AUDIO_ROUTE_CHANGED, payload)
-        Log.d(TAG, "Emitted AUDIO_ROUTE_CHANGED: Current='${info.currentRoute}', Available=${info.devices.map { it.value }}")
-    }
+    Log.d(TAG, "Setting initial audio route: $defaultRoute for call type: $callType (isCallStart: $isCallStart)")
 
-    private val audioDeviceCallback = object : AudioDeviceCallback() {
-        override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>) {
-            Log.d(TAG, "Audio devices added. Triggering audio route update.")
-            synchronized(audioStateLock) {
-                userSelectedAudioRoute = null
-            }
-            updateAndApplyAudioRoute()
-        }
-        override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>) {
-            Log.d(TAG, "Audio devices removed. Triggering audio route update.")
-            synchronized(audioStateLock) {
-                val removedDeviceTypes = removedDevices.map {
-                    when(it.type) {
-                        AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> "Bluetooth"
-                        AudioDeviceInfo.TYPE_WIRED_HEADSET -> "Headset"
-                        else -> ""
-                    }
-                }
-                if (removedDeviceTypes.contains(userSelectedAudioRoute)) {
-                    userSelectedAudioRoute = null
-                }
+    // For call start, ensure audio mode is properly set first
+    if (isCallStart) {
+      setAudioMode()
+
+      // Additional delay for audio system to be ready
+      if (callType == "Video") {
+        mainHandler.postDelayed({
+          setAudioRoute(defaultRoute)
+
+          // Force speaker for video calls with additional verification
+          mainHandler.postDelayed({
+            val currentRoute = getCurrentAudioRoute()
+            if (currentRoute != "Speaker" && !deviceStrings.contains("Bluetooth") && !deviceStrings.contains("Headset")) {
+              Log.d(TAG, "Forcing speaker for video call - current route was: $currentRoute")
+              setAudioRoute("Speaker")
             }
-            updateAndApplyAudioRoute()
-        }
+          }, 300L)
+        }, 200L)
+      } else {
+        setAudioRoute(defaultRoute)
+      }
+    } else {
+      setAudioRoute(defaultRoute)
     }
-
-    private fun registerAudioDeviceCallback() {
-        audioManager?.registerAudioDeviceCallback(audioDeviceCallback, mainHandler)
+  }
+
+  private fun setAudioMode() {
+    audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
+    Log.d(TAG, "Audio mode set to MODE_IN_COMMUNICATION")
+  }
+
+  private fun resetAudioMode() {
+    if (activeCalls.isEmpty()) {
+      audioManager?.mode = AudioManager.MODE_NORMAL
+      audioManager?.stopBluetoothSco()
+      audioManager?.isBluetoothScoOn = false
+      audioManager?.isSpeakerphoneOn = false
+      Log.d(TAG, "Audio mode reset to MODE_NORMAL")
     }
-
-    private fun cleanup() {
-        Log.d(TAG, "Performing cleanup")
-        stopForegroundService()
-        keepScreenAwake(false)
-        synchronized(audioStateLock) {
-            userSelectedAudioRoute = null
-        }
-        audioManager?.mode = AudioManager.MODE_NORMAL
-        audioManager?.isSpeakerphoneOn = false
-        audioManager?.stopBluetoothSco()
+  }
+
+  private fun emitAudioRouteChanged() {
+    val info = getAudioDevices()
+    // Extract string values from StringHolder objects
+    val deviceStrings = info.devices.map { it.value }
+    val payload = JSONObject().apply {
+      put("devices", JSONArray(deviceStrings))
+      put("currentRoute", info.currentRoute)
     }
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val context = requireContext()
-            val channel = NotificationChannel(
-                NOTIF_CHANNEL_ID,
-                "Incoming Call Channel",
-                NotificationManager.IMPORTANCE_HIGH
-            ).apply {
-                description = "Notifications for incoming calls"
-                setBypassDnd(true)
-                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
-                setSound(null, null)
-            }
-            val manager = context.getSystemService(NotificationManager::class.java)
-            manager.createNotificationChannel(channel)
-        }
+    emitEvent(CallEventType.AUDIO_ROUTE_CHANGED, payload)
+    Log.d(TAG, "Audio route changed: ${info.currentRoute}, available: $deviceStrings")
+  }
+
+  private val audioDeviceCallback = object : AudioDeviceCallback() {
+    override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
+      Log.d(TAG, "Audio devices added")
+      emitAudioDevicesChanged()
     }
-
-    private fun showIncomingCallUI(callId: String, callerName: String, callType: String, callerPicUrl: String?) {
-        val context = requireContext()
-        Log.d(TAG, "Showing incoming call UI for $callId")
-        createNotificationChannel()
-
-        showCallActivityOverlay(context, callId, callerName, callType, callerPicUrl)
-        showStandardNotification(context, callId, callerName, callType, callerPicUrl)
-
-        playRingtone()
+    override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
+      Log.d(TAG, "Audio devices removed")
+      emitAudioDevicesChanged()
     }
-
-    private fun showCallActivityOverlay(context: Context, callId: String, callerName: String, callType: String, callerPicUrl: String?) {
-        val overlayIntent = Intent(context, CallActivity::class.java).apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
-            putExtra("callId", callId)
-            putExtra("callerName", callerName)
-            putExtra("callType", callType)
-            callerPicUrl?.let { putExtra("callerAvatar", it) }
-        }
-        try {
-            context.startActivity(overlayIntent)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to launch CallActivity overlay: ${e.message}")
-        }
+  }
+
+  private fun emitAudioDevicesChanged() {
+    val info = getAudioDevices()
+    // Extract string values from StringHolder objects
+    val deviceStrings = info.devices.map { it.value }
+    val payload = JSONObject().apply {
+      put("devices", JSONArray(deviceStrings))
+      put("currentRoute", info.currentRoute)
     }
-
-    private fun showStandardNotification(context: Context, callId: String, callerName: String, callType: String, callerPicUrl: String?) {
-        val fullScreenIntent = Intent(context, CallActivity::class.java).apply {
-            putExtra("callId", callId)
-        }
-        val fullScreenPendingIntent = PendingIntent.getActivity(
-            context, callId.hashCode(), fullScreenIntent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+    emitEvent(CallEventType.AUDIO_DEVICES_CHANGED, payload)
+    Log.d(TAG, "Audio devices changed: available: $deviceStrings")
+  }
+
+  fun registerAudioDeviceCallback() {
+    val context = requireContext()
+    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    audioManager?.registerAudioDeviceCallback(audioDeviceCallback, null)
+  }
+
+  fun unregisterAudioDeviceCallback() {
+    val context = requireContext()
+    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
+  }
+
+  fun keepScreenAwake(keepAwake: Boolean) {
+    val context = requireContext()
+    val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+    if (keepAwake) {
+      if (wakeLock == null || wakeLock!!.isHeld.not()) {
+        wakeLock = powerManager.newWakeLock(
+          PowerManager.SCREEN_DIM_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP,
+          "CallEngine:WakeLock"
         )
-
-        val builder = Notification.Builder(context, NOTIF_CHANNEL_ID)
-            .setSmallIcon(android.R.drawable.sym_call_incoming)
-            .setContentTitle("Incoming Call")
-            .setContentText(callerName)
-            .setPriority(Notification.PRIORITY_MAX)
-            .setCategory(Notification.CATEGORY_CALL)
-            .setFullScreenIntent(fullScreenPendingIntent, true)
-            .setOngoing(true)
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && supportsCallStyleNotifications()) {
-            val person = android.app.Person.Builder().setName(callerName).build()
-            val answerIntent = Intent(context, CallNotificationActionReceiver::class.java).apply { action = "com.qusaieilouti99.callmanager.ANSWER_CALL"; putExtra("callId", callId) }
-            val declineIntent = Intent(context, CallNotificationActionReceiver::class.java).apply { action = "com.qusaieilouti99.callmanager.DECLINE_CALL"; putExtra("callId", callId) }
-            val answerPI = PendingIntent.getBroadcast(context, callId.hashCode() + 1, answerIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-            val declinePI = PendingIntent.getBroadcast(context, callId.hashCode() + 2, declineIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-            builder.setStyle(Notification.CallStyle.forIncomingCall(person, declinePI, answerPI))
+        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")
         }
-
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.notify(NOTIF_ID, builder.build())
+      }
+      wakeLock = null
     }
-
-    fun cancelIncomingCallUI() {
-        val context = requireContext()
-        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        notificationManager.cancel(NOTIF_ID)
-        stopRingtone()
+  }
+
+  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 ||
+    it.value.state == CallState.HELD
+  }
+
+  private fun validateOutgoingCallRequest(): Boolean {
+    return !activeCalls.any {
+      it.value.state == CallState.INCOMING || it.value.state == CallState.ACTIVE
     }
+  }
+
+  private fun rejectIncomingCallCollision(callId: String, reason: String) {
+    callMetadata.remove(callId)
+    incomingCallIds.remove(callId) // NEW: Clean up duplicate tracking
+    emitEvent(CallEventType.CALL_REJECTED, JSONObject().apply {
+      put("callId", callId)
+      put("reason", reason)
+    })
+  }
+
+  private fun createNotificationChannel() {
+    val context = requireContext()
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val channel = NotificationChannel(
+        NOTIF_CHANNEL_ID,
+        "Incoming Call Channel",
+        NotificationManager.IMPORTANCE_HIGH
+      )
+      channel.description = "Notifications for incoming calls"
+      channel.enableLights(true)
+      channel.lightColor = Color.GREEN
+      channel.enableVibration(true)
+      channel.setBypassDnd(true)
+      channel.lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+
+      // NEW: Improved sound handling to prevent double ringing
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+        channel.setSound(
+          RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE),
+          AudioAttributes.Builder()
+            .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+            .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+            .build()
+        )
+      } else {
+        // For API 31+, disable notification sound to prevent conflicts with custom ringtone
+        channel.setSound(null, null)
+        channel.importance = NotificationManager.IMPORTANCE_HIGH
+      }
+      val manager = context.getSystemService(NotificationManager::class.java)
+      manager.createNotificationChannel(channel)
+    }
+  }
 
-    private fun playRingtone() {
-        if (ringtone?.isPlaying == true) return
-        val context = requireContext()
-        audioManager?.mode = AudioManager.MODE_RINGTONE
+  private fun showIncomingCallUI(callId: String, callerName: String, callType: String, callerPicUrl: String?) {
+    val context = requireContext()
+    Log.d(TAG, "Showing incoming call UI for $callId")
 
-        vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
-        val pattern = longArrayOf(0, 1000, 500)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            vibrator?.vibrate(VibrationEffect.createWaveform(pattern, 0))
-        } else {
-            @Suppress("DEPRECATION")
-            vibrator?.vibrate(pattern, 0)
-        }
+    val useCallStyleNotification = supportsCallStyleNotifications()
+    Log.d(TAG, "Using CallStyle notification: $useCallStyleNotification")
 
-        try {
-            val ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
-            ringtone = RingtoneManager.getRingtone(context, ringtoneUri)
-            ringtone?.play()
-            Log.d(TAG, "Manual ringtone started.")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to play ringtone", e)
-        }
+    if (isDeviceLocked(context) || !useCallStyleNotification) {
+      Log.d(TAG, "Device is locked or CallStyle not supported - using overlay/fallback approach")
+      showCallActivityOverlay(context, callId, callerName, callType, callerPicUrl)
+    } else {
+      Log.d(TAG, "Device is unlocked and supports CallStyle - using enhanced notification")
+      showStandardNotification(context, callId, callerName, callType, callerPicUrl)
     }
 
-    fun stopRingtone() {
-        vibrator?.cancel()
-        vibrator = null
-        ringtone?.stop()
-        ringtone = null
-        Log.d(TAG, "Manual ringtone stopped.")
+    // NEW: Improved ringtone handling to prevent double ringing
+    playRingtone()
+  }
+
+  private fun isDeviceLocked(context: Context): Boolean {
+    val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+    return keyguardManager.isKeyguardLocked
+  }
+
+  private fun showCallActivityOverlay(context: Context, callId: String, callerName: String, callType: String, callerPicUrl: String?) {
+    val overlayIntent = Intent(context, CallActivity::class.java).apply {
+      addFlags(
+        Intent.FLAG_ACTIVITY_NEW_TASK or
+        Intent.FLAG_ACTIVITY_CLEAR_TASK or
+        Intent.FLAG_ACTIVITY_NO_ANIMATION or
+        Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
+      )
+      putExtra("callId", callId)
+      putExtra("callerName", callerName)
+      putExtra("callType", callType)
+      callerPicUrl?.let { putExtra("callerAvatar", it) }
+      putExtra("LOCK_SCREEN_MODE", true)
     }
 
-    private fun startRingback() {
-        val context = requireContext()
-        if (ringbackPlayer?.isPlaying == true) return
+    try {
+      val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+      val wakeLock = powerManager.newWakeLock(
+        PowerManager.SCREEN_BRIGHT_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP,
+        "CallEngine:LockScreenWake"
+      )
+      wakeLock.acquire(5000)
+      context.startActivity(overlayIntent)
+      Log.d(TAG, "Successfully launched CallActivity overlay")
+    } catch (e: Exception) {
+      Log.e(TAG, "Overlay failed, falling back to standard notification: ${e.message}")
+      showStandardNotification(context, callId, callerName, callType, callerPicUrl)
+    }
+  }
+
+  private fun showStandardNotification(context: Context, callId: String, callerName: String, callType: String, callerPicUrl: String?) {
+    createNotificationChannel()
+    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+    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)
+      callerPicUrl?.let { putExtra("callerAvatar", it) }
+    }
 
-        try {
-            val ringbackUri =
-                Uri.parse("android.resource://${context.packageName}/raw/ringback_tone")
-            ringbackPlayer = MediaPlayer.create(context, ringbackUri)
-            ringbackPlayer?.apply {
-                isLooping = true
-                start()
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to play ringback tone: ${e.message}")
-        }
+    val fullScreenPendingIntent = PendingIntent.getActivity(
+      context, callId.hashCode(), fullScreenIntent,
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+    )
+
+    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 notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && supportsCallStyleNotifications()) {
+      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)
+        .setCategory(Notification.CATEGORY_CALL)
+        .setPriority(Notification.PRIORITY_MAX)
+        .setVisibility(Notification.VISIBILITY_PUBLIC)
+        .build()
+    } else {
+      Notification.Builder(context, NOTIF_CHANNEL_ID)
+        .setSmallIcon(android.R.drawable.sym_call_incoming)
+        .setContentTitle("Incoming Call")
+        .setContentText(callerName)
+        .setPriority(Notification.PRIORITY_MAX)
+        .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)
+        .setVisibility(Notification.VISIBILITY_PUBLIC)
+        .build()
     }
 
-    private fun stopRingback() {
-        try {
-            ringbackPlayer?.stop()
-            ringbackPlayer?.release()
-        } catch (e: Exception) {
-            Log.e(TAG, "Error stopping ringback: ${e.message}")
-        } finally {
-            ringbackPlayer = null
-        }
+    notificationManager.notify(NOTIF_ID, notification)
+  }
+
+  fun cancelIncomingCallUI() {
+    val context = requireContext()
+    val notificationManager =
+      context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    notificationManager.cancel(NOTIF_ID)
+    stopRingtone()
+  }
+
+  private fun startForegroundService() {
+    val context = requireContext()
+    val currentCall = activeCalls.values.find {
+      it.state == CallState.ACTIVE ||
+      it.state == CallState.INCOMING ||
+      it.state == CallState.DIALING ||
+      it.state == CallState.HELD
     }
 
-    fun keepScreenAwake(keepAwake: Boolean) {
-        val context = requireContext()
-        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
-        if (keepAwake) {
-            if (wakeLock == null || wakeLock!!.isHeld.not()) {
-                wakeLock = powerManager.newWakeLock(
-                    PowerManager.SCREEN_DIM_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP,
-                    "CallEngine:WakeLock"
-                )
-                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")
-                }
-            }
-            wakeLock = null
-        }
+    val intent = Intent(context, CallForegroundService::class.java)
+    currentCall?.let {
+      intent.putExtra("callId", it.callId)
+      intent.putExtra("callType", it.callType)
+      intent.putExtra("displayName", it.displayName)
+      intent.putExtra("state", it.state.name)
     }
 
-    private fun bringAppToForeground() {
-        val context = requireContext()
-        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
-        )
-        try {
-            context.startActivity(launchIntent)
-            Handler(Looper.getMainLooper()).postDelayed({
-                updateLockScreenBypass()
-            }, 100)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to bring app to foreground: ${e.message}")
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      context.startForegroundService(intent)
+    } else {
+      context.startService(intent)
+    }
+  }
+
+  private fun stopForegroundService() {
+    val context = requireContext()
+    val intent = Intent(context, CallForegroundService::class.java)
+    context.stopService(intent)
+  }
+
+  private fun updateForegroundNotification() {
+    startForegroundService()
+  }
+
+  private fun isMainActivityInForeground(): Boolean {
+    val context = requireContext()
+    val activityManager =
+      context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      try {
+        val tasks = activityManager.appTasks
+        if (tasks.isNotEmpty()) {
+          val taskInfo = tasks[0].taskInfo
+          return taskInfo.topActivity?.className?.contains("MainActivity") == true
         }
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to get app tasks: ${e.message}")
+      }
+    } else {
+      try {
+        @Suppress("DEPRECATION")
+        val tasks = activityManager.getRunningTasks(1)
+        if (tasks.isNotEmpty()) {
+          val runningTaskInfo = tasks[0]
+          return runningTaskInfo.topActivity?.className?.contains("MainActivity") == true
+        }
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to get running tasks: ${e.message}")
+      }
     }
+    return false
+  }
 
-    private fun registerPhoneAccount() {
-        val context = requireContext()
-        val telecomManager =
-            context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle()
-
-        if (telecomManager.getPhoneAccount(phoneAccountHandle) == null) {
-            val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "PingMe Call")
-                .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED)
-                .build()
+  private fun bringAppToForeground() {
+    if (isMainActivityInForeground()) {
+      Log.d(TAG, "MainActivity is already in foreground, skipping")
+      return
+    }
 
-            try {
-                telecomManager.registerPhoneAccount(phoneAccount)
-                Log.d(TAG, "PhoneAccount registered successfully")
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to register PhoneAccount: ${e.message}", e)
-            }
-        }
+    Log.d(TAG, "Bringing app to foreground")
+    val context = requireContext()
+    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)
     }
 
-    private fun getPhoneAccountHandle(): PhoneAccountHandle {
-        val context = requireContext()
-        return PhoneAccountHandle(
-            ComponentName(context, MyConnectionService::class.java),
-            PHONE_ACCOUNT_ID
-        )
+    try {
+      context.startActivity(launchIntent)
+      Handler(Looper.getMainLooper()).postDelayed({
+        updateLockScreenBypass()
+      }, 100)
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to bring app to foreground: ${e.message}")
+    }
+  }
+
+  private fun registerPhoneAccount() {
+    val context = requireContext()
+    val telecomManager =
+      context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+    val phoneAccountHandle = getPhoneAccountHandle()
+
+    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")
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to register PhoneAccount: ${e.message}", e)
+      }
     }
+  }
+
+  private fun getPhoneAccountHandle(): PhoneAccountHandle {
+    val context = requireContext()
+    return PhoneAccountHandle(
+      ComponentName(context, MyConnectionService::class.java),
+      PHONE_ACCOUNT_ID
+    )
+  }
+
+  // NEW: Improved ringtone handling to prevent double ringing
+  private fun playRingtone() {
+    synchronized(ringtoneStateLock) {
+      if (isCustomRingtoneActive) {
+        Log.d(TAG, "Custom ringtone already active, skipping")
+        return
+      }
+
+      val context = requireContext()
+      audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+      // Only set ringtone mode if not already in communication mode
+      val currentMode = audioManager?.mode ?: AudioManager.MODE_NORMAL
+      if (currentMode != AudioManager.MODE_IN_COMMUNICATION) {
+        audioManager?.mode = AudioManager.MODE_RINGTONE
+      }
 
-    private fun startForegroundService() {
-        val context = requireContext()
-        val currentCall = activeCalls.values.find {
-            it.state == CallState.ACTIVE ||
-                    it.state == CallState.INCOMING ||
-                    it.state == CallState.DIALING ||
-                    it.state == CallState.HELD
+      vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
+      vibrator?.let { v ->
+        val pattern = longArrayOf(0L, 500L, 500L)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          v.vibrate(VibrationEffect.createWaveform(pattern, 0))
+        } else {
+          @Suppress("DEPRECATION")
+          v.vibrate(pattern, 0)
         }
-
-        val intent = Intent(context, CallForegroundService::class.java)
-        currentCall?.let {
-            intent.putExtra("callId", it.callId)
-            intent.putExtra("callType", it.callType)
-            intent.putExtra("displayName", it.displayName)
-            intent.putExtra("state", it.state.name)
+      }
+
+      try {
+        // Check if system ringtone is already playing for this call (API 31+)
+        val shouldPlayCustomRingtone = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+          // For newer APIs, be more cautious about playing custom ringtone
+          // if CallStyle notification is being used
+          !supportsCallStyleNotifications()
+        } else {
+          true
         }
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            context.startForegroundService(intent)
+        if (shouldPlayCustomRingtone) {
+          val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+          ringtone = RingtoneManager.getRingtone(context, uri)
+          ringtone?.play()
+          isCustomRingtoneActive = true
+          Log.d(TAG, "Custom ringtone started playing")
         } else {
-            context.startService(intent)
+          Log.d(TAG, "Skipping custom ringtone - system should handle it")
         }
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to play ringtone", e)
+      }
     }
+  }
 
-    private fun stopForegroundService() {
-        val context = requireContext()
-        val intent = Intent(context, CallForegroundService::class.java)
-        context.stopService(intent)
+  fun stopRingtone() {
+    synchronized(ringtoneStateLock) {
+      try {
+        ringtone?.stop()
+        isCustomRingtoneActive = false
+        Log.d(TAG, "Ringtone stopped")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error stopping ringtone", e)
+      }
+      ringtone = null
+
+      vibrator?.cancel()
+      vibrator = null
     }
-
-    private fun updateForegroundNotification() {
-        startForegroundService()
+  }
+
+  private fun startRingback() {
+    val context = requireContext()
+    if (ringbackPlayer?.isPlaying == true) return
+
+    try {
+      val ringbackUri =
+        Uri.parse("android.resource://${context.packageName}/raw/ringback_tone")
+      ringbackPlayer = MediaPlayer.create(context, ringbackUri)
+      ringbackPlayer?.apply {
+        isLooping = true
+        start()
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to play ringback tone: ${e.message}")
     }
-
-    fun onApplicationTerminate() {
-        Log.d(TAG, "Application terminating")
-        activeCalls.keys.toList().forEach { callId ->
-            telecomConnections[callId]?.let { conn ->
-                conn.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
-                conn.destroy()
-            }
-        }
-        activeCalls.clear()
-        telecomConnections.clear()
-        callMetadata.clear()
-        incomingCallIds.clear()
-        currentCallId = null
-        cleanup()
-        audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
-        eventHandler = null
-        cachedEvents.clear()
-        isInitialized.set(false)
-        appContext = null
+  }
+
+  private fun stopRingback() {
+    try {
+      ringbackPlayer?.stop()
+      ringbackPlayer?.release()
+    } catch (e: Exception) {
+      Log.e(TAG, "Error stopping ringback: ${e.message}")
+    } finally {
+      ringbackPlayer = null
+    }
+  }
+
+  private fun cleanup() {
+    Log.d(TAG, "Performing cleanup")
+    stopForegroundService()
+    keepScreenAwake(false)
+    resetAudioMode()
+    synchronized(ringtoneStateLock) {
+      isCustomRingtoneActive = false
+    }
+  }
+
+  fun onApplicationTerminate() {
+    Log.d(TAG, "Application terminating")
+    activeCalls.keys.toList().forEach { callId ->
+      telecomConnections[callId]?.let { conn ->
+        conn.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+        conn.destroy()
+      }
     }
+    activeCalls.clear()
+    telecomConnections.clear()
+    callMetadata.clear()
+    incomingCallIds.clear() // NEW: Clear duplicate tracking
+    currentCallId = null
+    cleanup()
+    lockScreenBypassCallbacks.clear()
+    eventHandler = null
+    cachedEvents.clear()
+    isInitialized.set(false)
+    appContext = null
+  }
 }