@qusaieilouti99/call-manager 0.1.164 → 0.1.166

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

@@ -1,7 +1,7 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
-import android.telecom.CallAudioState
 import android.app.ActivityManager
+import android.app.KeyguardManager
 import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
@@ -10,9 +10,6 @@ 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
 import android.media.MediaPlayer
 import android.media.RingtoneManager
@@ -22,21 +19,29 @@ 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.CallAudioState
 import android.telecom.Connection
 import android.telecom.DisconnectCause
 import android.telecom.PhoneAccount
 import android.telecom.PhoneAccountHandle
 import android.telecom.TelecomManager
 import android.util.Log
-import org.json.JSONArray
-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
+import org.json.JSONArray
+import org.json.JSONObject
 
+/**
+ * Core call‐management engine. Manages self-managed telecom calls,
+ * audio routing, UI notifications, etc.
+ *
+ * Audio routing is now fully delegated to the Android Telecom framework,
+ * which is the correct approach for self-managed calls. This ensures
+ * consistency and proper handling of device changes (BT, headset, etc.).
+ */
 object CallEngine {
   private const val TAG = "CallEngine"
   private const val PHONE_ACCOUNT_ID = "com.qusaieilouti99.callmanager.SELF_MANAGED"
@@ -79,8 +84,6 @@ object CallEngine {
   private var eventHandler: ((CallEventType, String) -> Unit)? = null
   private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
 
-  private var currentAudioRoute: String = "Unknown"
-
   interface LockScreenBypassCallback {
     fun onLockScreenBypassChanged(shouldBypass: Boolean)
   }
@@ -135,8 +138,12 @@ object CallEngine {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) return false
     val manufacturer = Build.MANUFACTURER.lowercase()
     val brand = Build.BRAND.lowercase()
-    val supportedManufacturers = setOf("google", "samsung", "oneplus", "motorola", "sony", "lg", "htc")
-    val supportedBrands = setOf("google", "samsung", "oneplus", "motorola", "sony", "lg", "htc", "pixel")
+    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") ||
@@ -212,20 +219,26 @@ object CallEngine {
     if (!isInitialized.get()) {
       initialize(context)
     }
+
     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) {
       Log.d(TAG, "Incoming call collision detected. Auto-rejecting new call: $callId")
       rejectIncomingCallCollision(callId, "Another call is already incoming")
       return
     }
-    val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE || it.state == CallState.HELD }
+
+    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
     }
+
     val isVideoCall = callType == "Video"
     if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
       activeCalls.values.forEach {
@@ -234,12 +247,17 @@ object CallEngine {
         }
       }
     }
-    activeCalls[callId] = CallInfo(callId, callType, displayName, pictureUrl, CallState.INCOMING)
+
+    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 telecomManager =
+      requireContext().getSystemService(Context.TELECOM_SERVICE) as TelecomManager
     val phoneAccountHandle = getPhoneAccountHandle()
     val extras = Bundle().apply {
       putString(MyConnectionService.EXTRA_CALL_ID, callId)
@@ -248,6 +266,7 @@ object CallEngine {
       putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, isVideoCall)
       pictureUrl?.let { putString(MyConnectionService.EXTRA_PICTURE_URL, it) }
     }
+
     try {
       telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
       startForegroundService()
@@ -256,6 +275,7 @@ object CallEngine {
       Log.e(TAG, "Failed to report incoming call: ${e.message}", e)
       endCallInternal(callId)
     }
+
     updateLockScreenBypass()
   }
 
@@ -268,6 +288,7 @@ object CallEngine {
     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 {
@@ -276,6 +297,7 @@ object CallEngine {
       })
       return
     }
+
     val isVideoCall = callType == "Video"
     if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
       activeCalls.values.forEach {
@@ -284,14 +306,18 @@ object CallEngine {
         }
       }
     }
+
     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 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)
@@ -299,11 +325,14 @@ object CallEngine {
       putBoolean(MyConnectionService.EXTRA_IS_VIDEO_CALL_BOOLEAN, isVideoCall)
       metadata?.let { putString("metadata", it) }
     }
+
     val extras = Bundle().apply {
       putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
       putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
+      // Let Telecom decide the initial audio route based on devices and video state
       putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, isVideoCall)
     }
+
     try {
       telecomManager.placeCall(addressUri, extras)
       startForegroundService()
@@ -315,9 +344,15 @@ object CallEngine {
       Log.e(TAG, "Failed to start outgoing call: ${e.message}", e)
       endCallInternal(callId)
     }
+
     updateLockScreenBypass()
   }
 
+  /**
+   * Starts a call and immediately sets it to active.
+   * Use this for joining an already-established call.
+   * If a call with the same ID is already incoming, it answers it instead.
+   */
   fun startCall(
     callId: String,
     callType: String,
@@ -325,57 +360,96 @@ object CallEngine {
     metadata: String? = null
   ) {
     Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
+
     val existingCall = activeCalls[callId]
-    if (existingCall != null && existingCall.state == CallState.INCOMING) {
-      Log.d(TAG, "startCall: Answering existing incoming call $callId")
-      answerCall(callId)
+    if (existingCall != null) {
+      if (existingCall.state == CallState.INCOMING) {
+        Log.d(TAG, "startCall: Call $callId is incoming, answering it.")
+        answerCall(callId)
+      } else {
+        Log.w(TAG, "startCall: Call $callId already exists with state ${existingCall.state}. Ignoring.")
+      }
       return
     }
-    if (activeCalls.containsKey(callId)) {
-      Log.w(TAG, "Call $callId already exists and is not incoming, cannot start again.")
-      return
+
+    metadata?.let { callMetadata[callId] = it }
+
+    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
+      activeCalls.values.forEach {
+        if (it.state == CallState.ACTIVE) {
+          holdCallInternal(it.callId, heldBySystem = false)
+        }
+      }
+    }
+
+    // This call will be set to ACTIVE immediately by MyConnectionService
+    activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
+    currentCallId = callId
+    Log.d(TAG, "Call $callId will be started as ACTIVE.")
+
+    registerPhoneAccount()
+
+    val context = requireContext()
+    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")
+      putBoolean(MyConnectionService.EXTRA_START_IMMEDIATELY_ACTIVE, true) // Custom flag
+      metadata?.let { putString("metadata", it) }
+    }
+
+    val extras = Bundle().apply {
+      putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
+      putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
+    }
+
+    try {
+      telecomManager.placeCall(addressUri, extras)
+      startForegroundService()
+      bringAppToForeground()
+      keepScreenAwake(true)
+      updateLockScreenBypass()
+      // Event is emitted by coreCallAnswered once the connection is active
+      Log.d(TAG, "Successfully placed call to be immediately active with TelecomManager.")
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to start call: ${e.message}", e)
+      endCallInternal(callId)
     }
-    Log.d(TAG, "startCall: Starting new outgoing call $callId and connecting immediately.")
-    startOutgoingCall(callId, callType, targetName, metadata)
-    mainHandler.postDelayed({
-      callAnsweredFromJS(callId)
-    }, 200)
   }
 
   fun callAnsweredFromJS(callId: String) {
     Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
-    val callInfo = activeCalls[callId]
-    if (callInfo?.state != CallState.DIALING) {
-        Log.w(TAG, "Cannot answer outgoing call $callId from JS - not in DIALING state. State is ${callInfo?.state}")
-        return
-    }
     coreCallAnswered(callId, isLocalAnswer = false)
   }
 
   fun answerCall(callId: String) {
     Log.d(TAG, "answerCall: $callId - local party answering")
-    val callInfo = activeCalls[callId]
-    if (callInfo?.state != CallState.INCOMING) {
-        Log.w(TAG, "Cannot answer call $callId - not in INCOMING state. State is ${callInfo?.state}")
-        return
-    }
     coreCallAnswered(callId, isLocalAnswer = true)
   }
 
-  private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
+  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
     }
-    telecomConnections[callId]?.setActive()
+
+    // The connection state change (e.g., onAnswer) is the source of truth.
+    // We just update our internal state and UI.
     activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
     currentCallId = callId
     Log.d(TAG, "Call $callId set to ACTIVE state")
+
     stopRingtone()
     stopRingback()
     cancelIncomingCallUI()
+
     if (!canMakeMultipleCalls) {
       activeCalls.filter { it.key != callId }.values.forEach { otherCall ->
         if (otherCall.state == CallState.ACTIVE) {
@@ -383,31 +457,39 @@ object CallEngine {
         }
       }
     }
+
     bringAppToForeground()
     startForegroundService()
     keepScreenAwake(true)
     updateLockScreenBypass()
-    setAudioMode()
-    registerAudioDeviceCallback()
-    // The initial audio route will be set automatically by the onStateChanged(STATE_ACTIVE) callback
+
+    // Audio is now managed by the Connection. We don't need to do anything here.
+    // The initial audio route is set by MyConnection when it becomes active.
+
     if (isLocalAnswer) {
       emitCallAnsweredWithMetadata(callId)
     } else {
       emitOutgoingCallAnsweredWithMetadata(callId)
     }
+
     Log.d(TAG, "Call $callId successfully answered")
   }
 
   private fun emitCallAnsweredWithMetadata(callId: String) {
     val callInfo = activeCalls[callId] ?: return
     val metadata = callMetadata[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) }
+        try {
+          put("metadata", JSONObject(it))
+        } catch (e: Exception) {
+          put("metadata", it)
+        }
       }
     })
   }
@@ -415,13 +497,18 @@ object CallEngine {
   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) }
+        try {
+          put("metadata", JSONObject(it))
+        } catch (e: Exception) {
+          put("metadata", it)
+        }
       }
     })
   }
@@ -437,6 +524,7 @@ object CallEngine {
       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) {
@@ -451,7 +539,12 @@ object CallEngine {
       Log.w(TAG, "Cannot hold call $callId - not in active state")
       return
     }
-    activeCalls[callId] = callInfo.copy(state = CallState.HELD, wasHeldBySystem = heldBySystem)
+
+    activeCalls[callId] = callInfo.copy(
+      state = CallState.HELD,
+      wasHeldBySystem = heldBySystem
+    )
+
     telecomConnections[callId]?.setOnHold()
     updateForegroundNotification()
     emitEvent(CallEventType.CALL_HELD, JSONObject().put("callId", callId))
@@ -469,7 +562,12 @@ object CallEngine {
       Log.w(TAG, "Cannot unhold call $callId - not in held state")
       return
     }
-    activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE, wasHeldBySystem = false)
+
+    activeCalls[callId] = callInfo.copy(
+      state = CallState.ACTIVE,
+      wasHeldBySystem = false
+    )
+
     telecomConnections[callId]?.setActive()
     updateForegroundNotification()
     emitEvent(CallEventType.CALL_UNHELD, JSONObject().put("callId", callId))
@@ -477,45 +575,25 @@ object CallEngine {
   }
 
   fun muteCall(callId: String) {
-    setMuted(callId, true)
+    setMutedInternal(callId, true)
   }
 
   fun unmuteCall(callId: String) {
-    setMuted(callId, false)
+    setMutedInternal(callId, false)
   }
 
-  /**
-   * FIX: This is the correct way to handle mute requests from the app's UI.
-   * It uses the AudioManager, which is the source of truth for microphone state.
-   */
   fun setMuted(callId: String, muted: Boolean) {
-    if (!activeCalls.containsKey(callId)) {
-      Log.w(TAG, "Cannot set mute state for call $callId - not found")
-      return
-    }
-    audioManager?.isMicrophoneMute = muted
-    Log.d(TAG, "Set mute state to $muted for call $callId via AudioManager")
-
-    // We must also emit the event to keep the JS UI in sync.
-    onTelecomMuteStateChanged(callId, muted)
+    setMutedInternal(callId, muted)
   }
 
-  /**
-   * Internal callback from MyConnection when Telecom reports a mute state change.
-   * This method ensures our state is consistent and emits the event to JS.
-   */
-  fun onTelecomMuteStateChanged(callId: String, isMuted: Boolean) {
-    if (!activeCalls.containsKey(callId)) {
-      Log.w(TAG, "Received mute state change for unknown call $callId")
+  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
     }
-    // Ensure our audio manager state is consistent with the system's request
-    if (audioManager?.isMicrophoneMute != isMuted) {
-        audioManager?.isMicrophoneMute = isMuted
-    }
-    Log.d(TAG, "Telecom reported mute state for $callId is now: $isMuted. Emitting event.")
-    val eventType = if (isMuted) CallEventType.CALL_MUTED else CallEventType.CALL_UNMUTED
-    emitEvent(eventType, JSONObject().put("callId", callId))
+    // The Connection's onCallAudioStateChanged will handle the event emission
+    (telecomConnections[callId] as? MyConnection)?.setMuted(muted)
   }
 
   fun endCall(callId: String) {
@@ -526,237 +604,169 @@ object CallEngine {
   fun endAllCalls() {
     Log.d(TAG, "endAllCalls: Ending all active calls")
     if (activeCalls.isEmpty()) return
+
     activeCalls.keys.toList().forEach { callId ->
       endCallInternal(callId)
     }
-    activeCalls.clear()
-    telecomConnections.clear()
-    callMetadata.clear()
-    currentCallId = null
-    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
     }
+
     val metadata = callMetadata.remove(callId)
     activeCalls.remove(callId)
+
     stopRingback()
     stopRingtone()
     cancelIncomingCallUI()
+
     if (currentCallId == callId) {
-      currentCallId = activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
+      currentCallId =
+        activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
     }
+
     val context = requireContext()
     val closeActivityIntent = Intent("com.qusaieilouti99.callmanager.CLOSE_CALL_ACTIVITY")
       .setPackage(context.packageName)
       .putExtra("callId", callId)
+
     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}")
     }
+
     telecomConnections[callId]?.let { connection ->
       connection.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
       connection.destroy()
       removeTelecomConnection(callId)
     }
+
     if (activeCalls.isEmpty()) {
       cleanup()
     } else {
       updateForegroundNotification()
     }
+
     updateLockScreenBypass()
+
     for (listener in callEndListeners) {
       mainHandler.post {
-        try { listener.onCallEnded(callId) } catch (_: Throwable) { /* swallow */ }
+        try {
+          listener.onCallEnded(callId)
+        } catch (_: Throwable) {
+          // swallow
+        }
       }
     }
+
     emitEvent(CallEventType.CALL_ENDED, JSONObject().apply {
       put("callId", callId)
       metadata?.let {
-        try { put("metadata", JSONObject(it)) } catch (e: Exception) { put("metadata", it) }
+        try { put("metadata", JSONObject(it)) }
+        catch (e: Exception) { put("metadata", it) }
       }
     })
   }
 
+  // ====== NEW TELECOM-DRIVEN AUDIO ROUTING SYSTEM ======
+
   fun getAudioDevices(): AudioRoutesInfo {
     val context = requireContext()
-    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+    val am = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
       ?: return AudioRoutesInfo(emptyArray(), "Unknown")
+
     val devices = mutableSetOf<String>()
     devices.add("Earpiece")
     devices.add("Speaker")
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-      val outputDevices = audioManager?.getDevices(AudioManager.GET_DEVICES_OUTPUTS) ?: emptyArray()
-      var hasBluetooth = false
-      var hasHeadset = false
-      for (device in outputDevices) {
-        when (device.type) {
-          AudioDeviceInfo.TYPE_BLUETOOTH_A2DP, AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLE_HEADSET -> if (!hasBluetooth) { devices.add("Bluetooth"); hasBluetooth = true }
-          AudioDeviceInfo.TYPE_WIRED_HEADPHONES, AudioDeviceInfo.TYPE_WIRED_HEADSET, AudioDeviceInfo.TYPE_USB_HEADSET -> if (!hasHeadset) { devices.add("Headset"); hasHeadset = true }
-        }
+
+    val outputDevices = am.getDevices(AudioManager.GET_DEVICES_OUTPUTS)
+    for (device in outputDevices) {
+      when (device.type) {
+        android.media.AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+        android.media.AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
+        android.media.AudioDeviceInfo.TYPE_BLE_HEADSET -> devices.add("Bluetooth")
+        android.media.AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+        android.media.AudioDeviceInfo.TYPE_WIRED_HEADSET,
+        android.media.AudioDeviceInfo.TYPE_USB_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") }
     }
-    Log.d(TAG, "Available audio devices: ${devices.toList()}, current: $currentAudioRoute")
-    val deviceHolders = devices.map { StringHolder(it) }.toTypedArray()
-    return AudioRoutesInfo(deviceHolders, currentAudioRoute)
-  }
 
-  fun onTelecomAudioRouteChanged(callId: String, audioState: CallAudioState) {
-      Log.d(TAG, "onTelecomAudioRouteChanged for $callId: route=${audioState.route}")
-      val routeString = when (audioState.route) {
-          CallAudioState.ROUTE_EARPIECE -> "Earpiece"
-          CallAudioState.ROUTE_SPEAKER -> "Speaker"
-          CallAudioState.ROUTE_BLUETOOTH -> "Bluetooth"
-          CallAudioState.ROUTE_WIRED_HEADSET -> "Headset"
-          else -> "Unknown"
-      }
-      if (currentAudioRoute != routeString) {
-          Log.d(TAG, "Audio route has changed. New route: $routeString")
-          currentAudioRoute = routeString
-          emitAudioRouteChanged(currentAudioRoute)
-      }
+    val currentRoute = (telecomConnections[currentCallId] as? MyConnection)
+      ?.getCurrentRouteString() ?: "Unknown"
+
+    Log.d(TAG, "getAudioDevices: Available=${devices.toList()}, Current=$currentRoute")
+    val deviceHolders = devices.map { StringHolder(it) }.toTypedArray()
+    return AudioRoutesInfo(deviceHolders, currentRoute)
   }
 
   fun setAudioRoute(route: String) {
-     Log.d(TAG, "User requested audio route change to: $route")
-     val telecomRoute = when (route) {
-         "Speaker" -> CallAudioState.ROUTE_SPEAKER
-         "Earpiece" -> CallAudioState.ROUTE_EARPIECE
-         "Bluetooth" -> CallAudioState.ROUTE_BLUETOOTH
-         "Headset" -> CallAudioState.ROUTE_WIRED_HEADSET
-         else -> {
-             Log.w(TAG, "Unknown audio route requested: $route")
-             return
-         }
-     }
-     currentCallId?.let { callId ->
-         val connection = telecomConnections[callId] as? MyConnection
-         if (connection != null) {
-             Log.d(TAG, "Requesting audio route change via MyConnection for call $callId")
-             connection.requestAudioRoute(telecomRoute)
-         } else {
-             Log.w(TAG, "Could not find MyConnection for active call $callId to set audio route.")
-         }
-     }
-  }
-
-  private fun isWiredHeadsetConnected(): Boolean {
-    val am = audioManager ?: return false
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-      val devices = am.getDevices(AudioManager.GET_DEVICES_ALL)
-      return devices.any { it.type == AudioDeviceInfo.TYPE_WIRED_HEADSET || it.type == AudioDeviceInfo.TYPE_WIRED_HEADPHONES || it.type == AudioDeviceInfo.TYPE_USB_HEADSET }
-    } else {
-      @Suppress("DEPRECATION")
-      return am.isWiredHeadsetOn
+    Log.d(TAG, "setAudioRoute requested for: $route")
+    val connection = telecomConnections[currentCallId] as? MyConnection ?: run {
+      Log.w(TAG, "Cannot set audio route, no active connection found for callId: $currentCallId")
+      return
     }
-  }
 
-  private fun isBluetoothDeviceConnected(): Boolean {
-    val am = audioManager ?: return false
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-      val devices = am.getDevices(AudioManager.GET_DEVICES_ALL)
-      return devices.any { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_A2DP || it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO || it.type == AudioDeviceInfo.TYPE_BLE_HEADSET }
-    } else {
-      @Suppress("DEPRECATION")
-      return am.isBluetoothA2dpOn || am.isBluetoothScoOn
+    val telecomRoute = when (route) {
+      "Speaker" -> CallAudioState.ROUTE_SPEAKER
+      "Earpiece" -> CallAudioState.ROUTE_EARPIECE
+      "Bluetooth" -> CallAudioState.ROUTE_BLUETOOTH
+      "Headset" -> CallAudioState.ROUTE_WIRED_HEADSET
+      else -> {
+        Log.w(TAG, "Unknown audio route string: $route")
+        return
+      }
     }
+    connection.requestAudioRouteChange(telecomRoute)
   }
 
   /**
-   * FIX: This is now called from MyConnection when the call becomes active.
+   * Called by MyConnection when the audio route changes. This is the single
+   * source of truth for route updates.
+   */
+  fun onTelecomAudioRouteChanged(callId: String, newRoute: String) {
+    Log.d(TAG, "onTelecomAudioRouteChanged for callId $callId, new route: $newRoute")
+    emitAudioRouteChanged()
+  }
+
+  /**
+   * Called by MyConnection when it becomes active to set the initial, logical
+   * audio route.
    */
   fun setInitialAudioRouteForCall(callId: String, callType: String) {
-    Log.d(TAG, "Setting initial audio route for call $callId, type: $callType")
+    val am = audioManager ?: return
+    val connection = telecomConnections[callId] as? MyConnection ?: return
+
+    // Determine default route based on Android standards
     val defaultRoute = when {
-      isBluetoothDeviceConnected() -> "Bluetooth"
-      isWiredHeadsetConnected() -> "Headset"
+      connection.isBluetoothAvailable() -> "Bluetooth"
+      am.isWiredHeadsetOn -> "Headset"
       callType.equals("Video", ignoreCase = true) -> "Speaker"
       else -> "Earpiece"
     }
-    Log.d(TAG, "Requesting initial audio route to be: $defaultRoute")
-    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
-      currentAudioRoute = "Unknown"
-      unregisterAudioDeviceCallback()
-      Log.d(TAG, "Audio mode reset to MODE_NORMAL")
-    }
-  }
 
-  private fun emitAudioRouteChanged(currentRoute: String) {
-      val info = getAudioDevices()
-      val deviceStrings = info.devices.map { it.value }
-      val payload = JSONObject().apply {
-          put("devices", JSONArray(deviceStrings))
-          put("currentRoute", currentRoute)
-      }
-      emitEvent(CallEventType.AUDIO_ROUTE_CHANGED, payload)
-      Log.d(TAG, "Emitted AUDIO_ROUTE_CHANGED: $currentRoute, available: $deviceStrings")
-  }
-
-  private val audioDeviceCallback = object : AudioDeviceCallback() {
-    override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
-      Log.d(TAG, "Audio devices added, emitting change event.")
-      emitAudioDevicesChanged()
-    }
-    override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
-      Log.d(TAG, "Audio devices removed, emitting change event.")
-      emitAudioDevicesChanged()
-    }
+    Log.d(TAG, "Requesting initial audio route for call $callId: $defaultRoute")
+    setAudioRoute(defaultRoute)
   }
 
-  private fun emitAudioDevicesChanged() {
+  private fun emitAudioRouteChanged() {
     val info = getAudioDevices()
     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, "Emitted AUDIO_DEVICES_CHANGED: available: $deviceStrings")
+    emitEvent(CallEventType.AUDIO_ROUTE_CHANGED, payload)
+    Log.d(TAG, "Emitted AUDIO_ROUTE_CHANGED: current=${info.currentRoute}, available=$deviceStrings")
   }
 
-  fun registerAudioDeviceCallback() {
-    if (isCallActive()) {
-      val context = requireContext()
-      audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-      try {
-        audioManager?.registerAudioDeviceCallback(audioDeviceCallback, mainHandler)
-        Log.d(TAG, "Audio device callback registered")
-      } catch (e: Exception) {
-        Log.w(TAG, "Failed to register audio device callback: ${e.message}")
-      }
-    }
-  }
-
-  fun unregisterAudioDeviceCallback() {
-    try {
-      audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
-      Log.d(TAG, "Audio device callback unregistered")
-    } catch (e: Exception) {
-      Log.w(TAG, "Failed to unregister audio device callback: ${e.message}")
-    }
-  }
+  // ====== END AUDIO ROUTING SYSTEM ======
 
   fun keepScreenAwake(keepAwake: Boolean) {
     val context = requireContext()
@@ -791,7 +801,6 @@ object CallEngine {
   }
 
   private fun validateOutgoingCallRequest(): Boolean {
-    if (canMakeMultipleCalls) return true
     return !activeCalls.any {
       it.value.state == CallState.INCOMING || it.value.state == CallState.ACTIVE
     }
@@ -802,37 +811,33 @@ object CallEngine {
       put("callId", callId)
       put("reason", reason)
     })
-     // Only remove metadata if there's NO existing active call with this ID
-        val existingCall = activeCalls[callId]
-        if (existingCall == null) {
-          callMetadata.remove(callId)
-          Log.d(TAG, "Removed metadata for rejected call $callId (no existing call)")
-        } else {
-          Log.d(TAG, "Kept metadata for callId: $callId (existing call: ${existingCall.state})")
-        }
+
+    // Only remove metadata if there's NO existing active call with this ID
+    val existingCall = activeCalls[callId]
+    if (existingCall == null) {
+      callMetadata.remove(callId)
+      Log.d(TAG, "Removed metadata for rejected call $callId (no existing call)")
+    } else {
+      Log.d(TAG, "Kept metadata for callId: $callId (existing call: ${existingCall.state})")
+    }
   }
 
   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
-      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 {
-        channel.setSound(null, null)
-        channel.importance = NotificationManager.IMPORTANCE_HIGH
+      val channel = NotificationChannel(
+        NOTIF_CHANNEL_ID,
+        "Incoming Call Channel",
+        NotificationManager.IMPORTANCE_HIGH
+      ).apply {
+        description = "Notifications for incoming calls"
+        enableLights(true)
+        lightColor = Color.GREEN
+        enableVibration(true)
+        setBypassDnd(true)
+        lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+        // Sound is handled by the RingtoneManager directly for better control
+        setSound(null, null)
       }
       val manager = context.getSystemService(NotificationManager::class.java)
       manager.createNotificationChannel(channel)
@@ -842,36 +847,37 @@ object CallEngine {
   private fun showIncomingCallUI(callId: String, callerName: String, callType: String, callerPicUrl: String?) {
     val context = requireContext()
     Log.d(TAG, "Showing incoming call UI for $callId")
+
     val useCallStyleNotification = supportsCallStyleNotifications()
     Log.d(TAG, "Using CallStyle notification: $useCallStyleNotification")
-    if (isDeviceLocked(context) || !useCallStyleNotification) {
-      Log.d(TAG, "Device is locked or CallStyle not supported - using overlay/fallback approach")
+
+    val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+    if (keyguardManager.isKeyguardLocked || !useCallStyleNotification) {
+      Log.d(TAG, "Device is locked or CallStyle not supported - using full-screen CallActivity.")
       showCallActivityOverlay(context, callId, callerName, callType, callerPicUrl)
     } else {
-      Log.d(TAG, "Device is unlocked and supports CallStyle - using enhanced notification")
+      Log.d(TAG, "Device is unlocked and supports CallStyle - using heads-up notification.")
       showStandardNotification(context, callId, callerName, callType, callerPicUrl)
     }
     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)
+      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)
     }
+
     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) {
@@ -883,6 +889,7 @@ object CallEngine {
   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)
@@ -890,48 +897,84 @@ object CallEngine {
       putExtra("callType", callType)
       callerPicUrl?.let { putExtra("callerAvatar", it) }
     }
-    val fullScreenPendingIntent = PendingIntent.getActivity(context, callId.hashCode(), fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
+
+    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 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 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()
+      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))
+        .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()
+        .setOngoing(true)
+        .setCategory(Notification.CATEGORY_CALL)
+        .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)
+        .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()
+        .setOngoing(true)
+        .setVisibility(Notification.VISIBILITY_PUBLIC)
+        .build()
     }
+
     notificationManager.notify(NOTIF_ID, notification)
   }
 
   fun cancelIncomingCallUI() {
     val context = requireContext()
-    val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    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 }
+    val currentCall = activeCalls.values.find {
+      it.state == CallState.ACTIVE ||
+      it.state == CallState.INCOMING ||
+      it.state == CallState.DIALING ||
+      it.state == CallState.HELD
+    }
+
     val intent = Intent(context, CallForegroundService::class.java)
     currentCall?.let {
       intent.putExtra("callId", it.callId)
@@ -939,6 +982,7 @@ object CallEngine {
       intent.putExtra("displayName", it.displayName)
       intent.putExtra("state", it.state.name)
     }
+
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       context.startForegroundService(intent)
     } else {
@@ -958,28 +1002,16 @@ object CallEngine {
 
   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}")
+    val activityManager =
+      context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+    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}")
     }
     return false
   }
@@ -989,17 +1021,23 @@ object CallEngine {
       Log.d(TAG, "MainActivity is already in foreground, skipping")
       return
     }
+
     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)
+    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)
     }
+
     try {
       context.startActivity(launchIntent)
-      Handler(Looper.getMainLooper()).postDelayed({ updateLockScreenBypass() }, 100)
     } catch (e: Exception) {
       Log.e(TAG, "Failed to bring app to foreground: ${e.message}")
     }
@@ -1007,12 +1045,15 @@ object CallEngine {
 
   private fun registerPhoneAccount() {
     val context = requireContext()
-    val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+    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")
@@ -1024,13 +1065,16 @@ object CallEngine {
 
   private fun getPhoneAccountHandle(): PhoneAccountHandle {
     val context = requireContext()
-    return PhoneAccountHandle(ComponentName(context, MyConnectionService::class.java), PHONE_ACCOUNT_ID)
+    return PhoneAccountHandle(
+      ComponentName(context, MyConnectionService::class.java),
+      PHONE_ACCOUNT_ID
+    )
   }
 
   private fun playRingtone() {
     val context = requireContext()
-    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
     audioManager?.mode = AudioManager.MODE_RINGTONE
+
     vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
     vibrator?.let { v ->
       val pattern = longArrayOf(0L, 500L, 500L)
@@ -1041,6 +1085,7 @@ object CallEngine {
         v.vibrate(pattern, 0)
       }
     }
+
     try {
       val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
       ringtone = RingtoneManager.getRingtone(context, uri)
@@ -1059,6 +1104,7 @@ object CallEngine {
       Log.e(TAG, "Error stopping ringtone", e)
     }
     ringtone = null
+
     vibrator?.cancel()
     vibrator = null
   }
@@ -1066,8 +1112,10 @@ object CallEngine {
   private fun startRingback() {
     val context = requireContext()
     if (ringbackPlayer?.isPlaying == true) return
+
     try {
-      val ringbackUri = Uri.parse("android.resource://${context.packageName}/raw/ringback_tone")
+      val ringbackUri =
+        Uri.parse("android.resource://${context.packageName}/raw/ringback_tone")
       ringbackPlayer = MediaPlayer.create(context, ringbackUri)
       ringbackPlayer?.apply {
         isLooping = true
@@ -1093,14 +1141,15 @@ object CallEngine {
     Log.d(TAG, "Performing cleanup")
     stopForegroundService()
     keepScreenAwake(false)
-    resetAudioMode()
+    // Reset audio mode via AudioManager when all calls are truly gone
+    audioManager?.mode = AudioManager.MODE_NORMAL
   }
 
   fun onApplicationTerminate() {
     Log.d(TAG, "Application terminating")
     activeCalls.keys.toList().forEach { callId ->
       telecomConnections[callId]?.let { conn ->
-        conn.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+        conn.setDisconnected(DisconnectCause(DisconnectCause.OTHER))
         conn.destroy()
       }
     }