@qusaieilouti99/call-manager 0.1.170 → 0.1.172

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

@@ -1,6 +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
@@ -21,6 +22,10 @@ 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.CallEndpoint
 import android.telecom.Connection
 import android.telecom.DisconnectCause
 import android.telecom.PhoneAccount
@@ -32,9 +37,6 @@ 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,
@@ -88,10 +90,8 @@ object CallEngine {
   private var eventHandler: ((CallEventType, String) -> Unit)? = null
   private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
 
-  // Audio routing state
-  private var currentAudioRoute: String = "Earpiece"
-  private var wasManuallySet: Boolean = false
-  private var callStartTime: Long = 0
+  // Audio routing state no longer directly managed here, but we keep AudioManager
+  // instance for mute control and mode settings.
 
   interface LockScreenBypassCallback {
     fun onLockScreenBypassChanged(shouldBypass: Boolean)
@@ -325,7 +325,7 @@ object CallEngine {
     currentCallId = callId
     Log.d(TAG, "Call $callId added to activeCalls. State: DIALING")
 
-    setAudioMode()
+    setAudioMode() // Set audio mode early
     registerPhoneAccount()
 
     val telecomManager =
@@ -344,6 +344,7 @@ object CallEngine {
     val extras = Bundle().apply {
       putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
       putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
+      // Pass the speakerphone hint to Telecom
       putBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, isVideoCall)
     }
 
@@ -363,96 +364,47 @@ object CallEngine {
   }
 
   fun startCall(
-      callId: String,
-      callType: String,
-      targetName: String,
-      metadata: String? = null
+    callId: String,
+    callType: String,
+    targetName: String,
+    metadata: String? = null
   ) {
-      Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
-      metadata?.let { callMetadata[callId] = it }
-
-      // Check if this is an existing incoming call that should be answered
-      val existingCall = activeCalls[callId]
-      if (existingCall != null && existingCall.state == CallState.INCOMING) {
-          Log.d(TAG, "startCall for existing incoming call - answering: $callId")
-          answerCall(callId)
-          return
-      }
-
-      // If call doesn't exist, create it as a direct active call (like conference join)
-      if (existingCall == null) {
-          Log.d(TAG, "startCall creating new direct active call: $callId")
-
-          if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
-              activeCalls.values.forEach {
-                  if (it.state == CallState.ACTIVE) {
-                      holdCallInternal(it.callId, heldBySystem = false)
-                  }
-              }
-          }
-
-          activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
-          currentCallId = callId
-          callStartTime = System.currentTimeMillis()
-          wasManuallySet = false
-          Log.d(TAG, "Call $callId started as ACTIVE")
-
-          registerPhoneAccount()
-          setAudioMode()
-          bringAppToForeground()
-          startForegroundService()
-          keepScreenAwake(true)
+    Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
+    metadata?.let { callMetadata[callId] = it }
 
-          // Register audio device callback to handle dynamic device changes
-          registerAudioDeviceCallback()
+    if (activeCalls.containsKey(callId)) {
+      Log.w(TAG, "Call $callId already exists, cannot start again")
+      return
+    }
 
-          // Set initial audio route with proper timing
-          mainHandler.postDelayed({
-              setInitialAudioRouteForCall(callId, callType)
-          }, 500L)
+    if (!canMakeMultipleCalls && activeCalls.isNotEmpty()) {
+      activeCalls.values.forEach {
+        if (it.state == CallState.ACTIVE) {
+          holdCallInternal(it.callId, heldBySystem = false)
+        }
+      }
+    }
 
-          updateLockScreenBypass()
-          emitOutgoingCallAnsweredWithMetadata(callId)
+    activeCalls[callId] =
+      CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
+    currentCallId = callId
+    // callStartTime = System.currentTimeMillis() // CallInfo handles timestamp
+    Log.d(TAG, "Call $callId started as ACTIVE")
 
-          // Report to telecom as an outgoing call that immediately becomes active
-          reportOutgoingCallToTelecom(callId, callType, targetName, metadata)
-      } else {
-          Log.w(TAG, "startCall called for existing call in state: ${existingCall.state}")
-      }
-  }
+    registerPhoneAccount()
+    setAudioMode() // Set audio mode early
+    bringAppToForeground()
+    startForegroundService()
+    keepScreenAwake(true)
 
-  private fun reportOutgoingCallToTelecom(
-      callId: String,
-      callType: String,
-      targetName: String,
-      metadata: String?
-  ) {
-      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 isVideoCall = callType == "Video"
-
-      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) }
-      }
+    // Register audio device callback to handle dynamic device changes (only for event emission)
+    registerAudioDeviceCallback()
 
-      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)
-      }
+    // The initial audio route setting will be handled by MyConnection
+    // when it receives STATE_ACTIVE callback from Telecom.
 
-      try {
-          telecomManager.placeCall(addressUri, extras)
-          Log.d(TAG, "Successfully reported startCall to TelecomManager")
-      } catch (e: Exception) {
-          Log.e(TAG, "Failed to report startCall to telecom: ${e.message}", e)
-      }
+    updateLockScreenBypass()
+    emitOutgoingCallAnsweredWithMetadata(callId) // Assuming this is for a call that's immediately active, not dialing.
   }
 
   fun callAnsweredFromJS(callId: String) {
@@ -475,8 +427,7 @@ object CallEngine {
 
     activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
     currentCallId = callId
-    callStartTime = System.currentTimeMillis()
-    wasManuallySet = false
+    // callStartTime = System.currentTimeMillis() // CallInfo handles timestamp
     Log.d(TAG, "Call $callId set to ACTIVE state")
 
     stopRingtone()
@@ -496,15 +447,13 @@ object CallEngine {
     keepScreenAwake(true)
     updateLockScreenBypass()
 
-    setAudioMode()
+    setAudioMode() // Ensure communication audio mode
 
-    // Register audio device callback to handle dynamic device changes
+    // Register audio device callback to handle dynamic device changes (only for event emission)
     registerAudioDeviceCallback()
 
-    // Set initial audio route with proper timing
-    mainHandler.postDelayed({
-      setInitialAudioRoute(callInfo.callType)
-    }, 800L)
+    // MyConnection.onStateChanged(STATE_ACTIVE) will trigger setInitialAudioRouteForCall
+    // which delegates to MyConnection's method to interact with Telecom.
 
     if (isLocalAnswer) {
       emitCallAnsweredWithMetadata(callId)
@@ -585,7 +534,7 @@ object CallEngine {
       wasHeldBySystem = heldBySystem
     )
 
-    telecomConnections[callId]?.setOnHold()
+    telecomConnections[callId]?.setOnHold() // Request Telecom to hold
     updateForegroundNotification()
     emitEvent(CallEventType.CALL_HELD, JSONObject().put("callId", callId))
     updateLockScreenBypass()
@@ -608,7 +557,7 @@ object CallEngine {
       wasHeldBySystem = false
     )
 
-    telecomConnections[callId]?.setActive()
+    telecomConnections[callId]?.setActive() // Request Telecom to unhold/set active
     updateForegroundNotification()
     emitEvent(CallEventType.CALL_UNHELD, JSONObject().put("callId", callId))
     updateLockScreenBypass()
@@ -626,23 +575,21 @@ object CallEngine {
     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 setMutedInternal(callId: String, muted: Boolean) {
+    // This is called by MyConnection.onMuteStateChanged (API 34+)
+    // or MyConnection.onCallAudioStateChanged (pre-API 34)
+    // or directly from CallManager JS calls.
     val context = requireContext()
     audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
     val wasMuted = audioManager?.isMicrophoneMute ?: false
-    audioManager?.isMicrophoneMute = muted
-
     if (wasMuted != muted) {
+      audioManager?.isMicrophoneMute = 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")
+      Log.d(TAG, "Call $callId microphone mute state changed to: $muted")
+    } else {
+      Log.d(TAG, "Call $callId microphone mute state already $muted, no change.")
     }
   }
 
@@ -679,8 +626,8 @@ object CallEngine {
     val metadata = callMetadata.remove(callId)
     activeCalls.remove(callId)
 
-    stopRingback()
     stopRingtone()
+    stopRingback()
     cancelIncomingCallUI()
 
     if (currentCallId == callId) {
@@ -735,330 +682,146 @@ object CallEngine {
 
   // ====== IMPROVED AUDIO ROUTING SYSTEM ======
 
-
-fun getAudioDevices(): AudioRoutesInfo {
+  fun getAudioDevices(): AudioRoutesInfo {
     val context = requireContext()
     audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
-        ?: return AudioRoutesInfo(emptyArray(), "Unknown")
+      ?: return AudioRoutesInfo(emptyArray(), "Unknown")
 
     val devices = mutableSetOf<String>()
-    var hasWiredHeadset = false
-    var hasBluetoothDevice = false
-
-    // Always available
-    devices.add("Earpiece")
-    devices.add("Speaker")
-
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-        val outputDevices = audioManager?.getDevices(AudioManager.GET_DEVICES_OUTPUTS) ?: emptyArray()
-        for (device in outputDevices) {
-            when (device.type) {
-                AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
-                AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> {
-                    if (!hasBluetoothDevice) {
-                        devices.add("Bluetooth")
-                        hasBluetoothDevice = true
-                    }
-                }
-                AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
-                AudioDeviceInfo.TYPE_WIRED_HEADSET,
-                AudioDeviceInfo.TYPE_USB_HEADSET -> {
-                    if (!hasWiredHeadset) {
-                        devices.add("Headset")
-                        hasWiredHeadset = true
-                    }
-                }
-                AudioDeviceInfo.TYPE_BLE_HEADSET -> {
-                    if (!hasBluetoothDevice) {
-                        devices.add("Bluetooth")
-                        hasBluetoothDevice = true
-                    }
-                }
-            }
-        }
-    } else {
-        // Fallback for older API levels
-        @Suppress("DEPRECATION")
-        if (audioManager?.isBluetoothA2dpOn == true || audioManager?.isBluetoothScoOn == true) {
-            devices.add("Bluetooth")
-            hasBluetoothDevice = true
-        }
-        @Suppress("DEPRECATION")
-        if (audioManager?.isWiredHeadsetOn == true) {
-            devices.add("Headset")
-            hasWiredHeadset = true
+    var currentRouteString: String = "Unknown"
+
+    val currentCallConnection = currentCallId?.let { telecomConnections[it] as? MyConnection }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // API 34+
+      // For API 34+, prefer getting actual Telecom CallEndpoint info from MyConnection
+      currentCallConnection?.let { conn ->
+        val currentEndpoint = conn.getCurrentTelecomCallEndpoint()
+        currentEndpoint?.let {
+          currentRouteString = when (it.getEndpointType()) {
+            CallEndpoint.TYPE_EARPIECE -> "Earpiece"
+            CallEndpoint.TYPE_SPEAKER -> "Speaker"
+            CallEndpoint.TYPE_BLUETOOTH -> "Bluetooth"
+            CallEndpoint.TYPE_WIRED_HEADSET -> "Headset"
+            else -> "Unknown"
+          }
         }
-    }
-
-    val current = getCurrentAudioRoute()
-    Log.d(TAG, "Available audio devices: ${devices.toList()}, current: $current")
 
-    val deviceHolders = devices.map { StringHolder(it) }.toTypedArray()
-    return AudioRoutesInfo(deviceHolders, current)
-}
-
-  // NEW: Handle modern telecom call endpoint changes (API 34+)
-  fun onTelecomCallEndpointChanged(callId: String, callEndpoint: CallEndpoint) {
-      Log.d(TAG, "Telecom call endpoint changed for $callId: ${callEndpoint.endpointName}, type=${callEndpoint.endpointType}")
-
-      val routeString = when (callEndpoint.endpointType) {
-          CallEndpoint.TYPE_EARPIECE -> "Earpiece"
-          CallEndpoint.TYPE_SPEAKER -> "Speaker"
-          CallEndpoint.TYPE_BLUETOOTH -> "Bluetooth"
-          CallEndpoint.TYPE_WIRED_HEADSET -> "Headset"
-          else -> "Unknown"
+        val availableEndpoints = conn.getAvailableTelecomCallEndpoints()
+        availableEndpoints.forEach { endpoint ->
+          when (endpoint.getEndpointType()) {
+            CallEndpoint.TYPE_EARPIECE -> devices.add("Earpiece")
+            CallEndpoint.TYPE_SPEAKER -> devices.add("Speaker")
+            CallEndpoint.TYPE_BLUETOOTH -> devices.add("Bluetooth")
+            CallEndpoint.TYPE_WIRED_HEADSET -> devices.add("Headset")
+            // TYPE_STREAMING, TYPE_UNKNOWN are not typically user selectable audio routes
+          }
+        }
       }
 
-      currentAudioRoute = routeString
-      Log.d(TAG, "Emitting AUDIO_ROUTE_CHANGED: currentRoute=$routeString")
-      emitAudioRouteChanged(routeString)
-  }
-
-  // NEW: Handle available call endpoints change (API 34+)
-  fun onAvailableCallEndpointsChanged(callId: String, availableEndpoints: List<CallEndpoint>) {
-      Log.d(TAG, "Available call endpoints changed for $callId: ${availableEndpoints.size} endpoints")
+      // If no active call connection or API < 34, fallback to traditional device checks
+      if (devices.isEmpty()) {
+        devices.add("Earpiece")
+        devices.add("Speaker")
+        if (isBluetoothDeviceConnectedLegacy()) devices.add("Bluetooth")
+        if (isWiredHeadsetConnectedLegacy()) devices.add("Headset")
+      }
+      if (currentRouteString == "Unknown") {
+          currentRouteString = getCurrentAudioRouteLegacy()
+      }
 
-      val availableRoutes = availableEndpoints.map { endpoint ->
-          when (endpoint.endpointType) {
-              CallEndpoint.TYPE_EARPIECE -> "Earpiece"
-              CallEndpoint.TYPE_SPEAKER -> "Speaker"
-              CallEndpoint.TYPE_BLUETOOTH -> "Bluetooth"
-              CallEndpoint.TYPE_WIRED_HEADSET -> "Headset"
-              else -> "Unknown"
-          }
-      }.distinct()
+    } else { // Pre API 34
+      devices.add("Earpiece")
+      devices.add("Speaker")
+      if (isBluetoothDeviceConnectedLegacy()) devices.add("Bluetooth")
+      if (isWiredHeadsetConnectedLegacy()) devices.add("Headset")
+      currentRouteString = getCurrentAudioRouteLegacy()
+    }
 
-      Log.d(TAG, "Available routes: $availableRoutes")
-      emitAudioDevicesChanged()
+    Log.d(TAG, "Available audio devices: ${devices.toList()}, current: $currentRouteString")
+    val deviceHolders = devices.map { StringHolder(it) }.toTypedArray()
+    return AudioRoutesInfo(deviceHolders, currentRouteString)
   }
 
-  // Handle legacy audio route changes (API 28-33)
+  /**
+   * Called by MyConnection when Telecom reports an audio route change.
+   * This method translates the route to string and emits to JS.
+   * For API 34+, onCallEndpointChanged in MyConnection is the primary way to get route changes.
+   * For pre-API 34, onCallAudioStateChanged in MyConnection reports via CallAudioState.
+   */
   fun onTelecomAudioRouteChanged(callId: String, audioState: CallAudioState) {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-          return // Use modern system instead
-      }
-
-      Log.d(TAG, "Telecom audio route changed (legacy) 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"
-      }
-
-      currentAudioRoute = routeString
-      Log.d(TAG, "Emitting AUDIO_ROUTE_CHANGED: currentRoute=$routeString")
-      emitAudioRouteChanged(routeString)
+    Log.d(TAG, "onTelecomAudioRouteChanged (deprecated callback for API < 34): 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"
+    }
+    emitAudioRouteChanged(routeString) // Emit based on route provided by Telecom
   }
-  // Set initial audio route using appropriate API
+
+  // NEW: Set initial audio route using telecom's connection method.
+  // This is called by MyConnection.onStateChanged(STATE_ACTIVE).
   fun setInitialAudioRouteForCall(callId: String, callType: String) {
       Log.d(TAG, "Setting initial audio route for $callId, type: $callType")
 
-      // Don't override if user manually set a route
-      if (wasManuallySet) {
-          Log.d(TAG, "Audio route was manually set, skipping initial route")
+      val connection = telecomConnections[callId] as? MyConnection ?: run {
+          Log.w(TAG, "MyConnection not found for callId: $callId, cannot set initial audio route.")
           return
       }
 
-      mainHandler.postDelayed({
-          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-              setInitialAudioRouteModern(callId, callType)
-          } else {
-              setInitialAudioRouteLegacy(callId, callType)
-          }
-      }, 200)
-  }
-
-  @TargetApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
-  private fun setInitialAudioRouteModern(callId: String, callType: String) {
-      Log.d(TAG, "Setting initial audio route (modern) for $callId, type: $callType")
-
-      telecomConnections[callId]?.let { connection ->
-          if (connection is MyConnection) {
-              val currentEndpoint = connection.getCurrentCallEndpoint()
-              Log.d(TAG, "Current endpoint: ${currentEndpoint?.endpointName}, type: ${currentEndpoint?.endpointType}")
-
-              // Determine desired route based on call type and available devices
-              val isVideoCall = callType.equals("Video", ignoreCase = true)
-              val desiredEndpointType = when {
-                  isBluetoothDeviceConnected() -> CallEndpoint.TYPE_BLUETOOTH
-                  isWiredHeadsetConnected() -> CallEndpoint.TYPE_WIRED_HEADSET
-                  isVideoCall -> CallEndpoint.TYPE_SPEAKER
-                  else -> CallEndpoint.TYPE_EARPIECE
-              }
-
-              // Only change if current endpoint is different from desired
-              if (currentEndpoint == null || currentEndpoint.endpointType != desiredEndpointType) {
-                  // Create desired endpoint (this is a simplified approach)
-                  // In reality, you should use the endpoints from onAvailableCallEndpointsChanged
-                  val desiredEndpoint = createCallEndpoint(desiredEndpointType)
-                  connection.requestTelecomAudioRouteChange(desiredEndpoint)
-                  Log.d(TAG, "Requested audio route change to type: $desiredEndpointType")
-              }
-          }
-      }
-  }
-
-  private fun setInitialAudioRouteLegacy(callId: String, callType: String) {
-      Log.d(TAG, "Setting initial audio route (legacy) for $callId, type: $callType")
-
-      val desiredRoute = when {
-          isBluetoothDeviceConnected() -> CallAudioState.ROUTE_BLUETOOTH
-          isWiredHeadsetConnected() -> CallAudioState.ROUTE_WIRED_HEADSET
+      val desiredRouteTelecomInt = when {
+          isBluetoothDeviceConnectedLegacy() -> CallAudioState.ROUTE_BLUETOOTH
+          isWiredHeadsetConnectedLegacy() -> CallAudioState.ROUTE_WIRED_HEADSET
           callType.equals("Video", ignoreCase = true) -> CallAudioState.ROUTE_SPEAKER
           else -> CallAudioState.ROUTE_EARPIECE
       }
 
-      telecomConnections[callId]?.let { connection ->
-          if (connection is MyConnection) {
-              @Suppress("DEPRECATION")
-              connection.setAudioRoute(desiredRoute)
-              Log.d(TAG, "Set legacy audio route to: $desiredRoute")
-          }
-      }
-  }
-
-  @TargetApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
-  private fun createCallEndpoint(endpointType: Int): CallEndpoint {
-      val name = when (endpointType) {
-          CallEndpoint.TYPE_EARPIECE -> "Earpiece"
-          CallEndpoint.TYPE_SPEAKER -> "Speaker"
-          CallEndpoint.TYPE_BLUETOOTH -> "Bluetooth"
-          CallEndpoint.TYPE_WIRED_HEADSET -> "Headset"
-          else -> "Unknown"
-      }
-
-      return CallEndpoint(
-          name,
-          endpointType,
-          android.os.ParcelUuid.randomUUID()
-      )
+      // Delegate to MyConnection to handle routing via Telecom APIs (new or deprecated based on API level)
+      connection.setTelecomAudioRoute(desiredRouteTelecomInt)
+      Log.d(TAG, "Requested initial telecom audio route for $callId to: $desiredRouteTelecomInt")
   }
 
- // UPDATED: Use appropriate API for manual route changes
- fun setAudioRoute(route: String) {
+  // UPDATED: Use MyConnection's method to handle manual route changes via Telecom
+  fun setAudioRoute(route: String) {
      Log.d(TAG, "setAudioRoute called: $route (manual)")
-     wasManuallySet = true
+
+     val telecomRouteInt = 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: $route")
+             return
+         }
+     }
 
      currentCallId?.let { callId ->
          telecomConnections[callId]?.let { connection ->
              if (connection is MyConnection) {
-                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                     val endpointType = when (route) {
-                         "Speaker" -> CallEndpoint.TYPE_SPEAKER
-                         "Earpiece" -> CallEndpoint.TYPE_EARPIECE
-                         "Bluetooth" -> CallEndpoint.TYPE_BLUETOOTH
-                         "Headset" -> CallEndpoint.TYPE_WIRED_HEADSET
-                         else -> {
-                             Log.w(TAG, "Unknown audio route: $route")
-                             return
-                         }
-                     }
-                     val endpoint = createCallEndpoint(endpointType)
-                     connection.requestTelecomAudioRouteChange(endpoint)
-                 } else {
-                     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: $route")
-                             return
-                         }
-                     }
-                     @Suppress("DEPRECATION")
-                     connection.setAudioRoute(telecomRoute)
-                 }
-                 Log.d(TAG, "Requested audio route change to: $route")
+                 connection.setTelecomAudioRoute(telecomRouteInt)
+                 Log.d(TAG, "Set telecom audio route to: $telecomRouteInt for $route (via MyConnection)")
+             } else {
+                 Log.w(TAG, "No MyConnection found for $callId or wrong type for manual audio route.")
              }
-         }
-     }
+         } ?: Log.w(TAG, "No current call ID set for manual audio route.")
+     } ?: Log.w(TAG, "No current call ID set for manual audio route.")
  }
 
-  private fun applyAudioRoute(route: String) {
-    val ctx = requireContext()
-    if (audioManager == null) {
-      audioManager = ctx.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    }
-    val am = audioManager!!
-
-    // Ensure we're in the correct audio mode
-    if (am.mode != AudioManager.MODE_IN_COMMUNICATION) {
-      am.mode = AudioManager.MODE_IN_COMMUNICATION
-    }
-
-    val previousRoute = currentAudioRoute
-
-    when (route) {
-      "Speaker" -> {
-        am.isSpeakerphoneOn = true
-        if (am.isBluetoothScoOn) {
-          am.stopBluetoothSco()
-          am.isBluetoothScoOn = false
-        }
-        currentAudioRoute = "Speaker"
-        Log.d(TAG, "Audio route set to SPEAKER")
-      }
-      "Earpiece" -> {
-        am.isSpeakerphoneOn = false
-        if (am.isBluetoothScoOn) {
-          am.stopBluetoothSco()
-          am.isBluetoothScoOn = false
-        }
-        currentAudioRoute = "Earpiece"
-        Log.d(TAG, "Audio route set to EARPIECE")
-      }
-      "Bluetooth" -> {
-        am.isSpeakerphoneOn = false
-        if (!am.isBluetoothScoOn) {
-          am.startBluetoothSco()
-          am.isBluetoothScoOn = true
-        }
-        currentAudioRoute = "Bluetooth"
-        Log.d(TAG, "Audio route set to BLUETOOTH")
-      }
-      "Headset" -> {
-        am.isSpeakerphoneOn = false
-        if (am.isBluetoothScoOn) {
-          am.stopBluetoothSco()
-          am.isBluetoothScoOn = false
-        }
-        // For wired headsets, the system automatically routes audio when connected
-        currentAudioRoute = "Headset"
-        Log.d(TAG, "Audio route set to HEADSET")
-      }
-      else -> {
-        Log.w(TAG, "Unknown audio route: $route")
-        return
-      }
-    }
+  private fun getCurrentAudioRouteLegacy(): String {
+    val am = audioManager ?: return "Unknown"
 
-    // Only emit event if route actually changed
-    if (currentAudioRoute != previousRoute) {
-      emitAudioRouteChanged(currentAudioRoute)
+    // Check in order of priority: Bluetooth -> Headset -> Speaker -> Earpiece
+    return when {
+      am.isBluetoothScoOn -> "Bluetooth"
+      isWiredHeadsetConnectedLegacy() -> "Headset"
+      am.isSpeakerphoneOn -> "Speaker"
+      else -> "Earpiece"
     }
   }
 
-  private fun getCurrentAudioRoute(): String {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-          // For modern API, we rely on the stored currentAudioRoute from callbacks
-          return currentAudioRoute
-      }
-
-      // Legacy detection
-      val am = audioManager ?: return "Unknown"
-      return when {
-          am.isBluetoothScoOn -> "Bluetooth"
-          isWiredHeadsetConnected() -> "Headset"
-          am.isSpeakerphoneOn -> "Speaker"
-          else -> "Earpiece"
-      }
-  }
-
-  private fun isWiredHeadsetConnected(): Boolean {
+  private fun isWiredHeadsetConnectedLegacy(): Boolean {
     val am = audioManager ?: return false
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -1074,7 +837,7 @@ fun getAudioDevices(): AudioRoutesInfo {
     }
   }
 
-  private fun isBluetoothDeviceConnected(): Boolean {
+  private fun isBluetoothDeviceConnectedLegacy(): Boolean {
     val am = audioManager ?: return false
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -1090,27 +853,6 @@ fun getAudioDevices(): AudioRoutesInfo {
     }
   }
 
-  private fun setInitialAudioRoute(callType: String) {
-    Log.d(TAG, "Setting initial audio route for call type: $callType")
-
-    // Don't override if user manually set a route
-    if (wasManuallySet) {
-      Log.d(TAG, "Audio route was manually set, skipping initial route")
-      return
-    }
-
-    // Determine default route based on Android standards
-    val defaultRoute = when {
-      isBluetoothDeviceConnected() -> "Bluetooth"
-      isWiredHeadsetConnected() -> "Headset"
-      callType.equals("Video", ignoreCase = true) -> "Speaker"
-      else -> "Earpiece" // Default for audio calls
-    }
-
-    Log.d(TAG, "Setting initial audio route to: $defaultRoute")
-    applyAudioRoute(defaultRoute)
-  }
-
   private fun setAudioMode() {
     audioManager?.mode = AudioManager.MODE_IN_COMMUNICATION
     Log.d(TAG, "Audio mode set to MODE_IN_COMMUNICATION")
@@ -1126,16 +868,16 @@ fun getAudioDevices(): AudioRoutesInfo {
         }
         am.isSpeakerphoneOn = false
       }
-      currentAudioRoute = "Earpiece"
-      wasManuallySet = false
       unregisterAudioDeviceCallback()
       Log.d(TAG, "Audio mode reset to MODE_NORMAL")
     }
   }
 
-  // UPDATED: Fix the method signature
-  private fun emitAudioRouteChanged(currentRoute: String) {
-      val info = getAudioDevices()
+  // REVISED: Emit audio route changed event with current route.
+  // This is called from MyConnection.onCallEndpointChanged (API 34+)
+  // or CallEngine.onTelecomAudioRouteChanged (pre-API 34).
+  fun emitAudioRouteChanged(currentRoute: String) {
+      val info = getAudioDevices() // Re-query devices for the most up-to-date info
       val deviceStrings = info.devices.map { it.value }
       val payload = JSONObject().apply {
           put("devices", JSONArray(deviceStrings))
@@ -1157,76 +899,15 @@ fun getAudioDevices(): AudioRoutesInfo {
     }
   }
 
+  // REVISED: This method only triggers an update to JS, it does not
+  // influence the actual audio routing as Telecom handles that directly.
   private fun handleAudioDeviceChange(devices: Array<out AudioDeviceInfo>?, isAdded: Boolean) {
     if (devices == null || !isCallActive()) return
 
-    val context = requireContext()
-    val currentCallInfo = getCurrentActiveCall()
-    if (currentCallInfo == null) {
-      Log.d(TAG, "No active call, ignoring device change")
-      return
-    }
+    Log.d(TAG, "Relevant audio device change detected. Added: $isAdded.")
 
-    val relevantDevices = devices.filter { device ->
-      device.type == AudioDeviceInfo.TYPE_BLUETOOTH_A2DP ||
-      device.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO ||
-      device.type == AudioDeviceInfo.TYPE_BLE_HEADSET ||
-      device.type == AudioDeviceInfo.TYPE_WIRED_HEADSET ||
-      device.type == AudioDeviceInfo.TYPE_WIRED_HEADPHONES ||
-      device.type == AudioDeviceInfo.TYPE_USB_HEADSET
-    }
-
-    if (relevantDevices.isEmpty()) {
-      Log.d(TAG, "No relevant devices in change event")
-      return
-    }
-
-    Log.d(TAG, "Relevant device change detected. Added: $isAdded, wasManuallySet: $wasManuallySet")
-
-    if (isAdded && !wasManuallySet) {
-      // Device connected - switch to it automatically if user hasn't manually set route
-      val deviceType = relevantDevices.first().type
-      val newRoute = when (deviceType) {
-        AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
-        AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
-        AudioDeviceInfo.TYPE_BLE_HEADSET -> "Bluetooth"
-        AudioDeviceInfo.TYPE_WIRED_HEADSET,
-        AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
-        AudioDeviceInfo.TYPE_USB_HEADSET -> "Headset"
-        else -> null
-      }
-
-      if (newRoute != null && newRoute != currentAudioRoute) {
-        Log.d(TAG, "Auto-switching to newly connected device: $newRoute")
-        // Add slight delay to ensure device is ready
-        mainHandler.postDelayed({
-          applyAudioRoute(newRoute)
-        }, 300)
-      }
-    } else if (!isAdded) {
-      // Device disconnected - fall back to appropriate route
-      val disconnectedType = relevantDevices.first().type
-      val wasCurrentRoute = when (disconnectedType) {
-        AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
-        AudioDeviceInfo.TYPE_BLUETOOTH_SCO,
-        AudioDeviceInfo.TYPE_BLE_HEADSET -> currentAudioRoute == "Bluetooth"
-        AudioDeviceInfo.TYPE_WIRED_HEADSET,
-        AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
-        AudioDeviceInfo.TYPE_USB_HEADSET -> currentAudioRoute == "Headset"
-        else -> false
-      }
-
-      if (wasCurrentRoute) {
-        Log.d(TAG, "Current audio device disconnected, falling back")
-        // Reset manual flag since the manually selected device is gone
-        wasManuallySet = false
-        mainHandler.postDelayed({
-          setInitialAudioRoute(currentCallInfo.callType)
-        }, 300)
-      }
-    }
-
-    // Always emit devices changed event
+    // Simply emit that available devices might have changed.
+    // Telecom's onCallEndpointChanged (or onCallAudioStateChanged) will report the actual route change.
     emitAudioDevicesChanged()
   }
 
@@ -1234,15 +915,16 @@ fun getAudioDevices(): AudioRoutesInfo {
     return activeCalls.values.find { it.state == CallState.ACTIVE }
   }
 
-  private fun emitAudioDevicesChanged() {
-      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, "Audio devices changed: available: $deviceStrings")
+  // This method gets available devices and emits to JS.
+  fun emitAudioDevicesChanged() {
+    val info = getAudioDevices()
+    val deviceStrings = info.devices.map { it.value }
+    val payload = JSONObject().apply {
+      put("devices", JSONArray(deviceStrings))
+      put("currentRoute", info.currentRoute) // Current route is part of audioDevices info
+    }
+    emitEvent(CallEventType.AUDIO_DEVICES_CHANGED, payload)
+    Log.d(TAG, "Audio devices changed: available: $deviceStrings")
   }
 
   fun registerAudioDeviceCallback() {
@@ -1250,7 +932,7 @@ fun getAudioDevices(): AudioRoutesInfo {
       val context = requireContext()
       audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
       try {
-        audioManager?.registerAudioDeviceCallback(audioDeviceCallback, null)
+        audioManager?.registerAudioDeviceCallback(audioDeviceCallback, mainHandler) // Pass handler for callback thread
         Log.d(TAG, "Audio device callback registered")
       } catch (e: Exception) {
         Log.w(TAG, "Failed to register audio device callback: ${e.message}")
@@ -1278,7 +960,8 @@ fun getAudioDevices(): AudioRoutesInfo {
           PowerManager.SCREEN_DIM_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP,
           "CallEngine:WakeLock"
         )
-        wakeLock?.acquire(10 * 60 * 1000L)
+        // Acquire with a timeout to prevent permanent wakelocks
+        wakeLock?.acquire(10 * 60 * 1000L) // 10 minutes
         Log.d(TAG, "Acquired SCREEN_DIM_WAKE_LOCK")
       }
     } else {
@@ -1313,7 +996,6 @@ fun getAudioDevices(): AudioRoutesInfo {
       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)
@@ -1398,7 +1080,7 @@ fun getAudioDevices(): AudioRoutesInfo {
         PowerManager.SCREEN_BRIGHT_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP,
         "CallEngine:LockScreenWake"
       )
-      wakeLock.acquire(5000)
+      wakeLock.acquire(5000) // Acquire for 5 seconds to ensure activity launch
       context.startActivity(overlayIntent)
       Log.d(TAG, "Successfully launched CallActivity overlay")
     } catch (e: Exception) {
@@ -1653,7 +1335,10 @@ fun getAudioDevices(): AudioRoutesInfo {
 
   private fun startRingback() {
     val context = requireContext()
-    if (ringbackPlayer?.isPlaying == true) return
+    if (ringbackPlayer?.isPlaying == true) {
+      Log.d(TAG, "Ringback player already playing.")
+      return
+    }
 
     try {
       val ringbackUri =
@@ -1663,6 +1348,7 @@ fun getAudioDevices(): AudioRoutesInfo {
         isLooping = true
         start()
       }
+      Log.d(TAG, "Ringback tone started playing")
     } catch (e: Exception) {
       Log.e(TAG, "Failed to play ringback tone: ${e.message}")
     }
@@ -1672,6 +1358,7 @@ fun getAudioDevices(): AudioRoutesInfo {
     try {
       ringbackPlayer?.stop()
       ringbackPlayer?.release()
+      Log.d(TAG, "Ringback tone stopped")
     } catch (e: Exception) {
       Log.e(TAG, "Error stopping ringback: ${e.message}")
     } finally {

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

@@ -2,14 +2,19 @@ package com.margelo.nitro.qusaieilouti99.callmanager
 
 import android.content.Context
 import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.OutcomeReceiver
 import android.telecom.CallAudioState
 import android.telecom.CallEndpoint
 import android.telecom.Connection
+import android.telecom.Connection.CallEndpointException
 import android.telecom.DisconnectCause
 import android.telecom.VideoProfile
 import android.util.Log
 import org.json.JSONObject
 import java.util.concurrent.Executor
+import java.util.UUID
 
 class MyConnection(
     private val context: Context,
@@ -23,9 +28,11 @@ class MyConnection(
         const val TAG = "MyConnection"
     }
 
-    private var lastAudioState: CallAudioState? = null
-    private var lastCallEndpoint: CallEndpoint? = null
-    private var lastMuteState: Boolean? = null
+    // NEW: Store available endpoints and current endpoint if API >= 34
+    private var availableEndpoints: List<CallEndpoint> = emptyList()
+    private var currentEndpoint: CallEndpoint? = null
+    // Executor for requestCallEndpointChange callbacks (main thread)
+    private val mainExecutor: Executor = { runnable -> Handler(Looper.getMainLooper()).post(runnable) }
 
     init {
         connectionProperties = Connection.PROPERTY_SELF_MANAGED
@@ -83,63 +90,57 @@ class MyConnection(
         CallEngine.unholdCall(callId)
     }
 
-    // ====== MODERN AUDIO ROUTING (API 34+) ======
-    override fun onCallEndpointChanged(callEndpoint: CallEndpoint) {
-        super.onCallEndpointChanged(callEndpoint)
-        Log.d(TAG, "Call endpoint changed for callId: $callId. New endpoint: ${callEndpoint.endpointName}, type: ${callEndpoint.endpointType}")
+    // This method is deprecated in API 34. Still used for API < 34.
+    @Suppress("DEPRECATION")
+    override fun onCallAudioStateChanged(state: CallAudioState) {
+        super.onCallAudioStateChanged(state)
+        Log.d(TAG, "onCallAudioStateChanged (deprecated): callId=$callId, muted=${state.isMuted}, route=${state.route}")
 
-        if (lastCallEndpoint == null || !endpointsEqual(lastCallEndpoint!!, callEndpoint)) {
-            lastCallEndpoint = callEndpoint
-            CallEngine.onTelecomCallEndpointChanged(callId, callEndpoint)
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // Before API 34
+            // For older APIs, CallAudioState is the primary way to get mute & route from Telecom.
+            CallEngine.setMutedInternal(callId, state.isMuted) // CallEngine.setMutedInternal handles AudioManager
+            CallEngine.onTelecomAudioRouteChanged(callId, state) // Notify CallEngine about the actual route change
         }
+        // For API 34+, onMuteStateChanged and onCallEndpointChanged will be used instead.
     }
 
-    override fun onAvailableCallEndpointsChanged(availableEndpoints: List<CallEndpoint>) {
-        super.onAvailableCallEndpointsChanged(availableEndpoints)
-        Log.d(TAG, "Available call endpoints changed for callId: $callId. Count: ${availableEndpoints.size}")
-        CallEngine.onAvailableCallEndpointsChanged(callId, availableEndpoints)
-    }
-
+    // NEW (API 34+): Notifies this Connection that its audio mute state has been changed.
+    @Suppress("NewApi")
     override fun onMuteStateChanged(isMuted: Boolean) {
         super.onMuteStateChanged(isMuted)
-        Log.d(TAG, "Mute state changed for callId: $callId. Muted: $isMuted")
-
-        if (lastMuteState == null || lastMuteState != isMuted) {
-            lastMuteState = isMuted
-            if (isMuted) {
-                CallEngine.muteCall(callId)
-            } else {
-                CallEngine.unmuteCall(callId)
-            }
+        Log.d(TAG, "onMuteStateChanged: callId=$callId, isMuted=$isMuted")
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // API 34+
+            CallEngine.setMutedInternal(callId, isMuted) // Delegate to CallEngine which manages AudioManager
         }
     }
 
-    // ====== LEGACY AUDIO ROUTING (API 28-33) ======
-    @Suppress("DEPRECATION")
-    override fun onCallAudioStateChanged(state: CallAudioState) {
-        super.onCallAudioStateChanged(state)
-
-        // Only use legacy system if we're on API < 34
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            return // Use modern system instead
+    // NEW (API 34+): Notifies this Connection that the available call endpoints have been changed.
+    @Suppress("NewApi")
+    override fun onAvailableCallEndpointsChanged(availableEndpoints: List<CallEndpoint>) {
+        super.onAvailableCallEndpointsChanged(availableEndpoints)
+        Log.d(TAG, "onAvailableCallEndpointsChanged for callId: $callId. Endpoints: ${availableEndpoints.map { "${it.endpointName} (${it.endpointType})" }}")
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // API 34+
+            this.availableEndpoints = availableEndpoints
+            CallEngine.emitAudioDevicesChanged() // Signal CallEngine to update device list in JS
         }
+    }
 
-        Log.d(TAG, "Audio state changed (legacy) for callId: $callId. muted=${state.isMuted}, route=${state.route}")
-
-        if (lastAudioState == null || lastAudioState!!.isMuted != state.isMuted) {
-            if (state.isMuted) {
-                CallEngine.muteCall(callId)
-            } else {
-                CallEngine.unmuteCall(callId)
+    // NEW (API 34+): Notifies this Connection that the audio endpoint has been changed.
+    @Suppress("NewApi")
+    override fun onCallEndpointChanged(callEndpoint: CallEndpoint) {
+        super.onCallEndpointChanged(callEndpoint)
+        Log.d(TAG, "onCallEndpointChanged for callId: $callId. New endpoint: ${callEndpoint.endpointName} (type: ${callEndpoint.endpointType})")
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // API 34+
+            this.currentEndpoint = callEndpoint
+            val routeString = when (callEndpoint.getEndpointType()) {
+                CallEndpoint.TYPE_EARPIECE -> "Earpiece"
+                CallEndpoint.TYPE_SPEAKER -> "Speaker"
+                CallEndpoint.TYPE_BLUETOOTH -> "Bluetooth"
+                CallEndpoint.TYPE_WIRED_HEADSET -> "Headset"
+                else -> "Unknown"
             }
+            CallEngine.emitAudioRouteChanged(routeString) // Notify CallEngine to update JS
         }
-
-        if (lastAudioState == null || lastAudioState!!.route != state.route) {
-            Log.d(TAG, "System audio route changed (legacy) for callId: $callId. Telecom route: ${state.route}")
-            CallEngine.onTelecomAudioRouteChanged(callId, state)
-        }
-
-        lastAudioState = state
     }
 
     override fun onPlayDtmfTone(digit: Char) {
@@ -163,19 +164,22 @@ class MyConnection(
 
     override fun onStateChanged(state: Int) {
         super.onStateChanged(state)
-        Log.d(TAG, "Connection state changed for callId: $callId. New state: $state")
+        Log.d(TAG, "Connection state changed for callId: $callId. New state: ${Connection.stateToString(state)}")
 
         when (state) {
             STATE_RINGING -> {
                 Log.d(TAG, "Connection is now ringing for callId: $callId")
+                CallEngine.setAudioMode() // Ensure audio mode for ringing
             }
             STATE_HOLDING -> {
                 Log.d(TAG, "Connection is now holding for callId: $callId")
             }
             STATE_ACTIVE -> {
                 Log.d(TAG, "Connection is now active for callId: $callId")
-                // Set initial audio route when call becomes active
+                // Request initial audio route from Telecom when the call becomes active.
+                // This ensures Telecom handles the routing change and reports back via callbacks.
                 CallEngine.setInitialAudioRouteForCall(callId, callType)
+                CallEngine.setAudioMode() // Ensure communication mode is set
             }
             STATE_DISCONNECTED -> {
                 Log.d(TAG, "Connection is now disconnected for callId: $callId")
@@ -184,35 +188,52 @@ class MyConnection(
         }
     }
 
-    // ====== MODERN AUDIO ROUTE CHANGE REQUEST (API 34+) ======
-    fun requestTelecomAudioRouteChange(endpoint: CallEndpoint) {
-        Log.d(TAG, "Requesting telecom audio route change to: ${endpoint.endpointName} for callId: $callId")
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            val executor = Executor { command -> command.run() }
-            requestCallEndpointChange(endpoint, executor) { result ->
-                result.onSuccess {
-                    Log.d(TAG, "Audio route change successful for callId: $callId")
-                }.onFailure { exception ->
-                    Log.e(TAG, "Audio route change failed for callId: $callId", exception)
+    /**
+     * Sets the telecom audio route for this connection. Uses requestCallEndpointChange for API 34+
+     * and the deprecated setAudioRoute(int) for older APIs.
+     * @param routeInt The desired audio route as a CallAudioState.ROUTE_X constant.
+     */
+    fun setTelecomAudioRoute(routeInt: Int) {
+        Log.d(TAG, "Attempting to set telecom audio route to int: $routeInt for callId: $callId")
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) { // API 34+
+            // Find the corresponding CallEndpoint from the available list
+            val desiredEndpoint = availableEndpoints.find { it.endpointType == routeInt }
+            if (desiredEndpoint != null) {
+                Log.d(TAG, "Requesting CallEndpoint change to ${desiredEndpoint.endpointName} (type: ${desiredEndpoint.endpointType})")
+                try {
+                    requestCallEndpointChange(desiredEndpoint, mainExecutor, object : OutcomeReceiver<Void, CallEndpointException> {
+                        override fun onResult(result: Void?) {
+                            Log.d(TAG, "requestCallEndpointChange succeeded for callId: $callId")
+                            // No need to manually update state, onCallEndpointChanged will be called by Telecom
+                        }
+                        override fun onError(error: CallEndpointException) {
+                            Log.e(TAG, "requestCallEndpointChange failed for callId: $callId: ${error.message}", error)
+                        }
+                    })
+                } catch (e: Exception) {
+                    Log.e(TAG, "Exception during requestCallEndpointChange for callId: $callId: ${e.message}", e)
                 }
+            } else {
+                Log.w(TAG, "Desired endpoint type $routeInt not found in available endpoints for callId: $callId")
+                // Fallback to deprecated for types not found in CallEndpoint list? Or just log and do nothing.
+                // For now, log and do nothing as Telecom should provide valid endpoints.
             }
-        } else {
-            // Fallback to legacy method
-            val route = when (endpoint.endpointType) {
-                CallEndpoint.TYPE_EARPIECE -> CallAudioState.ROUTE_EARPIECE
-                CallEndpoint.TYPE_SPEAKER -> CallAudioState.ROUTE_SPEAKER
-                CallEndpoint.TYPE_BLUETOOTH -> CallAudioState.ROUTE_BLUETOOTH
-                CallEndpoint.TYPE_WIRED_HEADSET -> CallAudioState.ROUTE_WIRED_HEADSET
-                else -> CallAudioState.ROUTE_EARPIECE
-            }
+        } else { // Fallback for API < 34
             @Suppress("DEPRECATION")
-            setAudioRoute(route)
+            setAudioRoute(routeInt)
+            Log.d(TAG, "Using deprecated setAudioRoute(int) for callId: $callId")
         }
     }
 
-    private fun endpointsEqual(endpoint1: CallEndpoint, endpoint2: CallEndpoint): Boolean {
-        return endpoint1.endpointType == endpoint2.endpointType &&
-               endpoint1.identifier == endpoint2.identifier
+    // NEW: Expose current CallEndpoint for CallEngine to query (API 34+)
+    @Suppress("NewApi")
+    fun getCurrentTelecomCallEndpoint(): CallEndpoint? {
+        return currentEndpoint
+    }
+
+    // NEW: Expose available CallEndpoints for CallEngine to query (API 34+)
+    @Suppress("NewApi")
+    fun getAvailableTelecomCallEndpoints(): List<CallEndpoint> {
+        return availableEndpoints
     }
 }

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

@@ -1,10 +1,12 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
 import android.os.Build
+import android.telecom.CallAudioState
 import android.telecom.Connection
 import android.telecom.ConnectionRequest
 import android.telecom.ConnectionService
 import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
 import android.telecom.VideoProfile
 import android.util.Log
 import java.util.UUID
@@ -62,18 +64,16 @@ class MyConnectionService : ConnectionService() {
 
         val videoState = if (isVideoCallBoolean) VideoProfile.STATE_BIDIRECTIONAL else VideoProfile.STATE_AUDIO_ONLY
         connection.setVideoState(videoState)
+        connection.setDialing()
 
-        // Check if this is a startCall scenario (should immediately go to ACTIVE)
-        val existingCallInfo = CallEngine.getActiveCalls().find { it.callId == callId }
-        if (existingCallInfo?.state == CallState.ACTIVE) {
-            Log.d(TAG, "Setting outgoing connection as ACTIVE immediately for callId: $callId")
-            connection.setActive()
-        } else {
-            Log.d(TAG, "Setting outgoing connection as DIALING for callId: $callId")
-            connection.setDialing()
+        Log.d(TAG, "Created outgoing connection for callId: $callId. Status: DIALING, VideoState: $videoState")
+
+        if (request.extras?.getBoolean(TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, false) == true) {
+            Log.d(TAG, "Hinting Telecom to start outgoing call with speakerphone as per request extras.")
+            // Use the new setTelecomAudioRoute on MyConnection to request route change from Telecom
+            connection.setTelecomAudioRoute(CallAudioState.ROUTE_SPEAKER)
         }
 
-        Log.d(TAG, "Created outgoing connection for callId: $callId. VideoState: $videoState")
         return connection
     }
 }

package/package.json

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