@qusaieilouti99/call-manager 0.1.142 → 0.1.144

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

@@ -1,6 +1,7 @@
 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
@@ -8,8 +9,6 @@ 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
@@ -21,6 +20,8 @@ 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
@@ -32,1357 +33,797 @@ 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 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()
-        }
-      }
-    }
-  }
-
-  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()
-      }
-    }
-  }
-
-  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))
-    }
-  }
-
-  /**
-   * 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)
-        }
-      }
-    }
-  }
-
-  fun isLockScreenBypassActive(): Boolean = lockScreenBypassActive
+    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
 
-  fun addTelecomConnection(callId: String, connection: Connection) {
-    telecomConnections[callId] = connection
-    Log.d(TAG, "Added Telecom Connection for callId: $callId")
-  }
-
-  fun removeTelecomConnection(callId: String) {
-    telecomConnections.remove(callId)
-    Log.d(TAG, "Removed Telecom Connection for callId: $callId")
-  }
-
-  fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
+    interface CallEndListener {
+        fun onCallEnded(callId: String)
+    }
 
-  fun setCanMakeMultipleCalls(allow: Boolean) {
-    canMakeMultipleCalls = allow
-    Log.d(TAG, "canMakeMultipleCalls set to: $allow")
-  }
+    private val callEndListeners = CopyOnWriteArrayList<CallEndListener>()
+    private val mainHandler = Handler(Looper.getMainLooper())
 
-  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 registerCallEndListener(l: CallEndListener) {
+        callEndListeners.add(l)
     }
 
-    // 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
+    fun unregisterCallEndListener(l: CallEndListener) {
+        callEndListeners.remove(l)
     }
-    incomingCallIds[callId] = currentTime
 
-    // Clean up old entries (older than 30 seconds)
-    val cutoffTime = currentTime - 30000
-    incomingCallIds.entries.removeAll { it.value < cutoffTime }
+    @Volatile private var appContext: Context? = null
+    private val isInitialized = AtomicBoolean(false)
+    private val initializationLock = Any()
 
-    Log.d(TAG, "reportIncomingCall: callId=$callId, type=$callType, name=$displayName")
-    metadata?.let { callMetadata[callId] = it }
+    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
 
-    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
-    }
+    private val activeCalls = ConcurrentHashMap<String, CallInfo>()
+    private val telecomConnections = ConcurrentHashMap<String, Connection>()
+    private val callMetadata = ConcurrentHashMap<String, String>()
+    private val incomingCallIds = ConcurrentHashMap<String, Long>()
 
-    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 var currentCallId: String? = null
+    private var canMakeMultipleCalls: Boolean = false
+    private var eventHandler: ((CallEventType, String) -> Unit)? = null
+    private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
+
+    // --- Modern Audio Management State ---
+    private var userSelectedAudioRoute: String? = null
+    private val audioStateLock = Any()
 
-    val isVideoCall = callType == "Video"
-    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
-      activeCalls.values.forEach {
-        if (it.state == CallState.ACTIVE) {
-          holdCallInternal(it.callId, heldBySystem = false)
+    fun initialize(context: Context) {
+        synchronized(initializationLock) {
+            if (isInitialized.compareAndSet(false, true)) {
+                appContext = context.applicationContext
+                audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+                registerAudioDeviceCallback() // Register callback on init
+                Log.d(TAG, "CallEngine initialized successfully")
+            }
         }
-      }
     }
 
-    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 isInitialized(): Boolean = isInitialized.get()
 
-    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)
+    private fun requireContext(): Context {
+        return appContext ?: throw IllegalStateException(
+            "CallEngine not initialized. Call initialize() in Application.onCreate()"
+        )
     }
 
-    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
-    }
+    fun getContext(): Context? = appContext
 
-    val isVideoCall = callType == "Video"
-    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
-      activeCalls.values.forEach {
-        if (it.state == CallState.ACTIVE) {
-          holdCallInternal(it.callId, heldBySystem = false)
+    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()
+            }
         }
-      }
     }
 
-    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 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 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) }
+    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 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 silenceIncomingCall() {
+        Log.d(TAG, "Silencing incoming call ringtone via Connection.onSilence()")
+        stopRingtone()
     }
 
-    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 addTelecomConnection(callId: String, connection: Connection) {
+        telecomConnections[callId] = connection
     }
 
-    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
+    fun removeTelecomConnection(callId: String) {
+        telecomConnections.remove(callId)
     }
 
-    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
-      activeCalls.values.forEach {
-        if (it.state == CallState.ACTIVE) {
-          holdCallInternal(it.callId, heldBySystem = false)
+    fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
+
+    fun reportIncomingCall(
+        context: Context,
+        callId: String,
+        callType: String,
+        displayName: String,
+        pictureUrl: String? = null,
+        metadata: String? = null
+    ) {
+        if (!isInitialized.get()) {
+            initialize(context)
+        }
+
+        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) }
         }
-      }
-    }
 
-    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
+        try {
+            telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
+            startForegroundService()
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to report incoming call: ${e.message}", e)
+            endCallInternal(callId)
+        }
     }
 
-    activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
-    currentCallId = callId
-    Log.d(TAG, "Call $callId set to ACTIVE state")
+    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) }
+        }
 
-    stopRingtone()
-    stopRingback()
-    cancelIncomingCallUI()
+        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")
+        }
 
-    if (!canMakeMultipleCalls) {
-      activeCalls.filter { it.key != callId }.values.forEach { otherCall ->
-        if (otherCall.state == CallState.ACTIVE) {
-          holdCallInternal(otherCall.callId, heldBySystem = false)
+        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)
         }
-      }
     }
 
-    bringAppToForeground()
-    startForegroundService()
-    keepScreenAwake(true)
-    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
+        }
 
-    setAudioMode()
+        activeCalls[callId] =
+            CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
+        currentCallId = callId
+        Log.d(TAG, "Call $callId started as ACTIVE")
 
-    // NEW: Improved initial audio route with longer delay and retry mechanism
-    mainHandler.postDelayed({
-      setInitialAudioRoute(callInfo.callType, isCallStart = true)
+        registerPhoneAccount()
+        bringAppToForeground()
+        startForegroundService()
+        keepScreenAwake(true)
 
-      // Retry after additional delay if needed for video calls
-      if (callInfo.callType == "Video") {
+        synchronized(audioStateLock) {
+            userSelectedAudioRoute = null
+        }
         mainHandler.postDelayed({
-          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)
+            updateAndApplyAudioRoute()
+        }, 300)
+
+        emitEvent(CallEventType.OUTGOING_CALL_ANSWERED, JSONObject().apply {
+            put("callId", callId)
+            put("callType", callType)
+            put("displayName", targetName)
+        })
     }
 
-    Log.d(TAG, "Call $callId successfully answered")
-  }
+    fun answerCall(callId: String) {
+        Log.d(TAG, "answerCall: $callId - local party answering")
+        coreCallAnswered(callId, isLocalAnswer = true)
+    }
 
-  private fun emitCallAnsweredWithMetadata(callId: String) {
-    val callInfo = activeCalls[callId] ?: return
-    val metadata = callMetadata[callId]
+    private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
+        val callInfo = activeCalls[callId] ?: return
+        activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
+        currentCallId = callId
 
-    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)
+        stopRingtone()
+        stopRingback()
+        cancelIncomingCallUI()
+
+        bringAppToForeground()
+        startForegroundService()
+        keepScreenAwake(true)
+
+        // Set initial audio route using the new robust system
+        synchronized(audioStateLock) {
+            userSelectedAudioRoute = null // Reset any previous user selection
         }
-      }
-    })
-  }
-
-  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)
+        // Give the audio system a moment to initialize after the call becomes active
+        mainHandler.postDelayed({
+            updateAndApplyAudioRoute()
+        }, 300)
+
+        if (isLocalAnswer) {
+            emitCallAnsweredWithMetadata(callId)
         }
-      }
-    })
-  }
-
-  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
     }
 
-    if (onHold && callInfo.state == CallState.ACTIVE) {
-      holdCallInternal(callId, heldBySystem = false)
-    } else if (!onHold && callInfo.state == CallState.HELD) {
-      unholdCallInternal(callId, resumedBySystem = false)
-    }
-  }
-
-  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
+    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) }
+        })
     }
 
-    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 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))
     }
 
-    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 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))
     }
 
-    val context = requireContext()
-    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-
-    val wasMuted = audioManager?.isMicrophoneMute ?: false
-    audioManager?.isMicrophoneMute = muted
-
-    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 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))
     }
-  }
 
-  fun endCall(callId: String) {
-    Log.d(TAG, "endCall: $callId")
-    endCallInternal(callId)
-  }
+    fun endCall(callId: String) {
+        endCallInternal(callId)
+    }
 
-  fun endAllCalls() {
-    Log.d(TAG, "endAllCalls: Ending all active calls")
-    if (activeCalls.isEmpty()) return
+    fun endAllCalls() {
+        Log.d(TAG, "endAllCalls: Ending all active calls")
+        if (activeCalls.isEmpty()) return
 
-    activeCalls.keys.toList().forEach { callId ->
-      endCallInternal(callId)
+        activeCalls.keys.toList().forEach { callId ->
+            endCallInternal(callId)
+        }
     }
 
-    activeCalls.clear()
-    telecomConnections.clear()
-    callMetadata.clear()
-    incomingCallIds.clear() // NEW: Clear duplicate tracking
-    currentCallId = null
+    private fun endCallInternal(callId: String) {
+        val callInfo = activeCalls.remove(callId) ?: return
+        incomingCallIds.remove(callId)
+        callMetadata.remove(callId)
 
-    cleanup()
-    updateLockScreenBypass()
-  }
+        stopRingtone()
+        stopRingback()
+        cancelIncomingCallUI()
 
-  private fun endCallInternal(callId: String) {
-    Log.d(TAG, "endCallInternal: $callId")
+        telecomConnections.remove(callId)?.let {
+            it.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+            it.destroy()
+        }
 
-    val callInfo = activeCalls[callId] ?: run {
-      Log.w(TAG, "Call $callId not found in active calls")
-      return
+        if (activeCalls.isEmpty()) {
+            cleanup()
+        } else {
+            updateForegroundNotification()
+        }
+
+        callEndListeners.forEach { it.onCallEnded(callId) }
+        emitEvent(CallEventType.CALL_ENDED, JSONObject().put("callId", callId))
     }
 
-    val metadata = callMetadata.remove(callId)
-    activeCalls.remove(callId)
-    incomingCallIds.remove(callId) // NEW: Clean up duplicate tracking
+    /**
+     * Sets the user's desired audio route. This will be respected until a
+     * higher-priority device connects or this route becomes unavailable.
+     */
+    fun setAudioRoute(route: String) {
+        synchronized(audioStateLock) {
+            Log.d(TAG, "User requested audio route: $route")
+            userSelectedAudioRoute = route
+        }
+        updateAndApplyAudioRoute()
+    }
+
+    /**
+     * Central function to determine and apply the correct audio route.
+     * This is the single source of truth for audio routing decisions.
+     */
+    private fun updateAndApplyAudioRoute() {
+        val call = activeCalls[currentCallId]
+        if (call == null || call.state != CallState.ACTIVE) {
+            Log.d(TAG, "Skipping audio route update: No active call.")
+            return
+        }
 
-    stopRingback()
-    stopRingtone()
-    cancelIncomingCallUI()
+        synchronized(audioStateLock) {
+            val am = audioManager ?: return
+            val availableDevices = getAvailableAudioDevices()
+
+            // Determine the target route based on priority
+            val targetRoute = if (userSelectedAudioRoute != null && availableDevices.contains(userSelectedAudioRoute)) {
+                userSelectedAudioRoute!! // Respect user's choice if available
+            } else {
+                // Auto-select based on priority
+                when {
+                    availableDevices.contains("Bluetooth") -> "Bluetooth"
+                    availableDevices.contains("Headset") -> "Headset"
+                    call.callType == "Video" -> "Speaker"
+                    else -> "Earpiece"
+                }
+            }
 
-    if (currentCallId == callId) {
-      currentCallId =
-        activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
+            Log.d(TAG, "Updating audio route. Available: $availableDevices, User Pref: $userSelectedAudioRoute, Target: $targetRoute")
+
+            // Apply the target route
+            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
+                }
+            }
+
+            // After applying, emit the result
+            mainHandler.postDelayed({ emitAudioRouteChanged() }, 100)
+        }
     }
 
-    val context = requireContext()
-    val closeActivityIntent = Intent("com.qusaieilouti99.callmanager.CLOSE_CALL_ACTIVITY")
-      .setPackage(context.packageName)
-      .putExtra("callId", callId)
+    private fun getAvailableAudioDevices(): Set<String> {
+        val am = audioManager ?: return emptySet()
+        val devices = mutableSetOf<String>()
+        devices.add("Earpiece") // Always available
+        devices.add("Speaker")  // Always available
 
-    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}")
+        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")
+                }
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            if (am.isBluetoothScoAvailableOffCall) devices.add("Bluetooth")
+            @Suppress("DEPRECATION")
+            if (am.isWiredHeadsetOn) devices.add("Headset")
+        }
+        return devices
     }
 
-    telecomConnections[callId]?.let { connection ->
-      connection.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
-      connection.destroy()
-      removeTelecomConnection(callId)
+    fun getAudioDevices(): AudioRoutesInfo {
+        val available = getAvailableAudioDevices().map { StringHolder(it) }.toTypedArray()
+        val current = getCurrentAudioRoute()
+        return AudioRoutesInfo(available, current)
     }
 
-    if (activeCalls.isEmpty()) {
-      cleanup()
-    } else {
-      updateForegroundNotification()
+    private fun getCurrentAudioRoute(): String {
+        val am = audioManager ?: return "Unknown"
+        return when {
+            am.isBluetoothScoOn -> "Bluetooth"
+            am.isWiredHeadsetOn -> "Headset"
+            am.isSpeakerphoneOn -> "Speaker"
+            else -> "Earpiece"
+        }
     }
 
-    updateLockScreenBypass()
-
-    for (listener in callEndListeners) {
-      mainHandler.post {
-        try {
-          listener.onCallEnded(callId)
-        } catch (_: Throwable) {
-          // swallow
+    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 }}")
     }
 
-    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")
+    private val audioDeviceCallback = object : AudioDeviceCallback() {
+        override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>) {
+            Log.d(TAG, "Audio devices added. Triggering audio route update.")
+            // A new device was added, reset user preference to allow auto-switch to higher priority device
+            synchronized(audioStateLock) {
+                userSelectedAudioRoute = null
+            }
+            updateAndApplyAudioRoute()
+        }
+        override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>) {
+            Log.d(TAG, "Audio devices removed. Triggering audio route update.")
+            // A device was removed, if it was the user's selection, clear it
+            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
+                }
+            }
+            updateAndApplyAudioRoute()
         }
-      }
-    } else {
-      @Suppress("DEPRECATION")
-      if (audioManager?.isBluetoothA2dpOn == true || audioManager?.isBluetoothScoOn == true)
-        devices.add("Bluetooth")
-      @Suppress("DEPRECATION")
-      if (audioManager?.isWiredHeadsetOn == true) devices.add("Headset")
     }
 
-    val current = getCurrentAudioRoute()
-    Log.d(TAG, "Available audio devices: ${devices.toList()}, current: $current")
-
-    // Convert strings to StringHolder objects
-    val deviceHolders = devices.map { StringHolder(it) }.toTypedArray()
-    lastAudioRoutesInfo = AudioRoutesInfo(deviceHolders, current)
-    return AudioRoutesInfo(deviceHolders, current)
-  }
-
-  fun setAudioRoute(route: String) {
-    Log.d(TAG, "setAudioRoute called: $route")
-
-    val ctx = requireContext()
-    if (audioManager == null) {
-      audioManager = ctx.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    private fun registerAudioDeviceCallback() {
+        audioManager?.registerAudioDeviceCallback(audioDeviceCallback, mainHandler)
     }
-    val am = audioManager!!
 
-    if (am.mode != AudioManager.MODE_IN_COMMUNICATION) {
-      am.mode = AudioManager.MODE_IN_COMMUNICATION
+    private fun cleanup() {
+        Log.d(TAG, "Performing cleanup")
+        stopForegroundService()
+        keepScreenAwake(false)
+        // Reset audio state
+        synchronized(audioStateLock) {
+            userSelectedAudioRoute = null
+        }
+        audioManager?.mode = AudioManager.MODE_NORMAL
+        audioManager?.isSpeakerphoneOn = false
+        audioManager?.stopBluetoothSco()
     }
 
-    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) {
-          am.startBluetoothSco()
-          am.isBluetoothScoOn = true
-          Log.d(TAG, "Audio routed to BLUETOOTH")
-        } else {
-          Log.w(TAG, "Bluetooth SCO not supported on this OS version")
-        }
-      }
-      "Headset" -> {
-        am.isSpeakerphoneOn = false
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && am.isBluetoothScoOn) {
-          am.stopBluetoothSco()
-          am.isBluetoothScoOn = false
+    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
+                // **CRITICAL FIX**: Set sound to null. We will manage the ringtone manually.
+                setSound(null, null)
+            }
+            val manager = context.getSystemService(NotificationManager::class.java)
+            manager.createNotificationChannel(channel)
         }
-        Log.d(TAG, "Audio routed to HEADSET")
-      }
-      else -> {
-        Log.w(TAG, "Unknown audio route: $route")
-        return
-      }
-    }
-    emitAudioRouteChanged()
-  }
-
-  private fun getCurrentAudioRoute(): String {
-    return when {
-      audioManager?.isBluetoothScoOn == true -> "Bluetooth"
-      audioManager?.isSpeakerphoneOn == true -> "Speaker"
-      audioManager?.isWiredHeadsetOn == true -> "Headset"
-      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"
     }
 
-    Log.d(TAG, "Setting initial audio route: $defaultRoute for call type: $callType (isCallStart: $isCallStart)")
+    private fun showIncomingCallUI(callId: String, callerName: String, callType: String, callerPicUrl: String?) {
+        val context = requireContext()
+        Log.d(TAG, "Showing incoming call UI for $callId")
+        createNotificationChannel() // Ensure channel is created with correct settings
 
-    // For call start, ensure audio mode is properly set first
-    if (isCallStart) {
-      setAudioMode()
+        showCallActivityOverlay(context, callId, callerName, callType, callerPicUrl)
+        showStandardNotification(context, callId, callerName, callType, callerPicUrl)
 
-      // 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")
-            }
-          }, 300L)
-        }, 200L)
-      } else {
-        setAudioRoute(defaultRoute)
-      }
-    } else {
-      setAudioRoute(defaultRoute)
-    }
-  }
-
-  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 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)
-    }
-    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()
+        playRingtone()
     }
-    override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
-      Log.d(TAG, "Audio devices removed")
-      emitAudioDevicesChanged()
-    }
-  }
-
-  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)
-    }
-    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"
-        )
-        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")
+
+    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}")
         }
-      }
-      wakeLock = null
-    }
-  }
-
-  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 showIncomingCallUI(callId: String, callerName: String, callType: String, callerPicUrl: String?) {
-    val context = requireContext()
-    Log.d(TAG, "Showing incoming call UI for $callId")
+    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
+        )
 
-    val useCallStyleNotification = supportsCallStyleNotifications()
-    Log.d(TAG, "Using CallStyle notification: $useCallStyleNotification")
+        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))
+        }
 
-    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)
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.notify(NOTIF_ID, builder.build())
     }
 
-    // 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)
+    fun cancelIncomingCallUI() {
+        val context = requireContext()
+        val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.cancel(NOTIF_ID)
+        stopRingtone()
     }
 
-    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) }
-    }
+    private fun playRingtone() {
+        if (ringtone?.isPlaying == true) return
+        val context = requireContext()
+        audioManager?.mode = AudioManager.MODE_RINGTONE
 
-    val fullScreenPendingIntent = PendingIntent.getActivity(
-      context, callId.hashCode(), fullScreenIntent,
-      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-    )
+        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 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()
+        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)
+        }
     }
 
-    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 stopRingtone() {
+        vibrator?.cancel()
+        vibrator = null
+        ringtone?.stop()
+        ringtone = null
+        Log.d(TAG, "Manual ringtone stopped.")
     }
 
-    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 startRingback() {
+        val context = requireContext()
+        if (ringbackPlayer?.isPlaying == true) return
 
-    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
+        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}")
         }
-      } 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
+    }
+
+    private fun stopRingback() {
+        try {
+            ringbackPlayer?.stop()
+            ringbackPlayer?.release()
+        } catch (e: Exception) {
+            Log.e(TAG, "Error stopping ringback: ${e.message}")
+        } finally {
+            ringbackPlayer = null
         }
-      } catch (e: Exception) {
-        Log.w(TAG, "Failed to get running tasks: ${e.message}")
-      }
     }
-    return false
-  }
 
-  private fun bringAppToForeground() {
-    if (isMainActivityInForeground()) {
-      Log.d(TAG, "MainActivity is already in foreground, skipping")
-      return
+    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
+        }
     }
 
-    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 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)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to bring app to foreground: ${e.message}")
+        }
     }
 
-    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 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
+        )
     }
-  }
-
-  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
-      }
 
-      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)
+    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
         }
-      }
-
-      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
+
+        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)
         }
 
-        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")
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent)
         } else {
-          Log.d(TAG, "Skipping custom ringtone - system should handle it")
+            context.startService(intent)
         }
-      } catch (e: Exception) {
-        Log.e(TAG, "Failed to play ringtone", e)
-      }
     }
-  }
 
-  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 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}")
-    }
-  }
-
-  private fun stopRingback() {
-    try {
-      ringbackPlayer?.stop()
-      ringbackPlayer?.release()
-    } catch (e: Exception) {
-      Log.e(TAG, "Error stopping ringback: ${e.message}")
-    } finally {
-      ringbackPlayer = null
+    private fun stopForegroundService() {
+        val context = requireContext()
+        val intent = Intent(context, CallForegroundService::class.java)
+        context.stopService(intent)
     }
-  }
-
-  private fun cleanup() {
-    Log.d(TAG, "Performing cleanup")
-    stopForegroundService()
-    keepScreenAwake(false)
-    resetAudioMode()
-    synchronized(ringtoneStateLock) {
-      isCustomRingtoneActive = false
+
+    private fun updateForegroundNotification() {
+        startForegroundService()
     }
-  }
-
-  fun onApplicationTerminate() {
-    Log.d(TAG, "Application terminating")
-    activeCalls.keys.toList().forEach { callId ->
-      telecomConnections[callId]?.let { conn ->
-        conn.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
-        conn.destroy()
-      }
+
+    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
     }
-    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
-  }
 }