@qusaieilouti99/call-manager 0.1.166 → 0.1.167

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

@@ -34,14 +34,6 @@ import java.util.concurrent.atomic.AtomicBoolean
 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"
@@ -329,7 +321,6 @@ object CallEngine {
     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)
     }
 
@@ -348,11 +339,6 @@ object CallEngine {
     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,
@@ -382,8 +368,7 @@ object CallEngine {
       }
     }
 
-    // This call will be set to ACTIVE immediately by MyConnectionService
-    activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.ACTIVE)
+    activeCalls[callId] = CallInfo(callId, callType, targetName, null, CallState.DIALING)
     currentCallId = callId
     Log.d(TAG, "Call $callId will be started as ACTIVE.")
 
@@ -399,7 +384,7 @@ object CallEngine {
       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
+      putBoolean(MyConnectionService.EXTRA_START_IMMEDIATELY_ACTIVE, true)
       metadata?.let { putString("metadata", it) }
     }
 
@@ -414,7 +399,6 @@ object CallEngine {
       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)
@@ -429,7 +413,12 @@ object CallEngine {
 
   fun answerCall(callId: String) {
     Log.d(TAG, "answerCall: $callId - local party answering")
-    coreCallAnswered(callId, isLocalAnswer = true)
+    val connection = telecomConnections[callId]
+    if (connection != null) {
+        connection.setActive()
+    } else {
+        Log.e(TAG, "Cannot answer call, no connection found for $callId")
+    }
   }
 
   fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
@@ -440,8 +429,6 @@ object CallEngine {
       return
     }
 
-    // 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")
@@ -463,9 +450,6 @@ object CallEngine {
     keepScreenAwake(true)
     updateLockScreenBypass()
 
-    // 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 {
@@ -587,13 +571,12 @@ object CallEngine {
   }
 
   private fun setMutedInternal(callId: String, muted: Boolean) {
-    val callInfo = activeCalls[callId]
-    if (callInfo == null) {
+    val connection = telecomConnections[callId] as? MyConnection ?: run {
       Log.w(TAG, "Cannot set mute state for call $callId - not found")
       return
     }
-    // The Connection's onCallAudioStateChanged will handle the event emission
-    (telecomConnections[callId] as? MyConnection)?.setMuted(muted)
+    // Delegate the action to the connection, which will inform Telecom
+    connection.setMuted(muted)
   }
 
   fun endCall(callId: String) {
@@ -675,7 +658,7 @@ object CallEngine {
     })
   }
 
-  // ====== NEW TELECOM-DRIVEN AUDIO ROUTING SYSTEM ======
+  // ====== TELECOM-DRIVEN AUDIO ROUTING SYSTEM ======
 
   fun getAudioDevices(): AudioRoutesInfo {
     val context = requireContext()
@@ -726,35 +709,11 @@ object CallEngine {
     connection.requestAudioRouteChange(telecomRoute)
   }
 
-  /**
-   * 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) {
-    val am = audioManager ?: return
-    val connection = telecomConnections[callId] as? MyConnection ?: return
-
-    // Determine default route based on Android standards
-    val defaultRoute = when {
-      connection.isBluetoothAvailable() -> "Bluetooth"
-      am.isWiredHeadsetOn -> "Headset"
-      callType.equals("Video", ignoreCase = true) -> "Speaker"
-      else -> "Earpiece"
-    }
-
-    Log.d(TAG, "Requesting initial audio route for call $callId: $defaultRoute")
-    setAudioRoute(defaultRoute)
-  }
-
   private fun emitAudioRouteChanged() {
     val info = getAudioDevices()
     val deviceStrings = info.devices.map { it.value }
@@ -813,12 +772,11 @@ object CallEngine {
     })
 
     // 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)")
+    if (!activeCalls.containsKey(callId)) {
+        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})")
+        Log.d(TAG, "Kept metadata for callId: $callId (an existing call is using it)")
     }
   }
 
@@ -836,7 +794,6 @@ object CallEngine {
         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)
@@ -1141,7 +1098,6 @@ object CallEngine {
     Log.d(TAG, "Performing cleanup")
     stopForegroundService()
     keepScreenAwake(false)
-    // Reset audio mode via AudioManager when all calls are truly gone
     audioManager?.mode = AudioManager.MODE_NORMAL
   }
 

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

@@ -4,6 +4,7 @@ import android.os.Build
 import android.os.OutcomeReceiver
 import android.telecom.CallAudioState
 import android.telecom.CallEndpoint
+import android.telecom.CallEndpointException
 import android.telecom.Connection
 import android.telecom.DisconnectCause
 import android.telecom.VideoProfile
@@ -22,13 +23,11 @@ class MyConnection(
         const val TAG = "MyConnection"
     }
 
-    private var lastAudioState: CallAudioState? = null
     private val telecomExecutor = Executors.newSingleThreadExecutor()
 
     init {
         connectionProperties = PROPERTY_SELF_MANAGED
         connectionCapabilities = CAPABILITY_SUPPORT_HOLD or CAPABILITY_MUTE or CAPABILITY_HOLD
-
         audioModeIsVoip = true
 
         if (callType == "Video") {
@@ -43,6 +42,8 @@ class MyConnection(
         Log.d(TAG, "MyConnection for callId $callId created and added to CallEngine.")
     }
 
+    // --- Lifecycle Callbacks ---
+
     override fun onSilence() {
         super.onSilence()
         Log.d(TAG, "onSilence called by system for callId: $callId. Silencing ringtone.")
@@ -51,7 +52,7 @@ class MyConnection(
 
     override fun onAnswer() {
         Log.d(TAG, "Call answered via Telecom for callId: $callId")
-        setActive()
+        // State will be set to ACTIVE, which triggers onStateChanged
         CallEngine.answerCall(callId)
     }
 
@@ -81,25 +82,7 @@ class MyConnection(
         CallEngine.unholdCall(callId)
     }
 
-    override fun onCallAudioStateChanged(state: CallAudioState) {
-        super.onCallAudioStateChanged(state)
-        Log.d(TAG, "onCallAudioStateChanged for callId: $callId. muted=${state.isMuted}, route=${state.routeToString()}")
-
-        // Mute state change
-        if (lastAudioState?.isMuted != state.isMuted) {
-            val eventType = if (state.isMuted) CallEventType.CALL_MUTED else CallEventType.CALL_UNMUTED
-            CallEngine.emitEvent(eventType, JSONObject().put("callId", callId))
-            Log.d(TAG, "Call $callId mute state changed to: ${state.isMuted}")
-        }
-
-        // Route change
-        if (lastAudioState?.route != state.route) {
-            Log.d(TAG, "System audio route changed for callId: $callId. New route: ${state.routeToString()}")
-            CallEngine.onTelecomAudioRouteChanged(callId, state.routeToString())
-        }
-
-        lastAudioState = state
-    }
+    // --- State Change Callbacks ---
 
     override fun onStateChanged(state: Int) {
         super.onStateChanged(state)
@@ -107,12 +90,13 @@ class MyConnection(
 
         when (state) {
             STATE_ACTIVE -> {
-                // When the call becomes active, set the initial audio route.
-                // This is the correct place to do it.
-                Log.d(TAG, "Connection is now active for callId: $callId. Setting initial audio route.")
-                CallEngine.setInitialAudioRouteForCall(callId, callType)
+                Log.d(TAG, "Connection is now active for callId: $callId.")
                 // If this was an immediate-start call, trigger the answered event.
-                CallEngine.coreCallAnswered(callId, isLocalAnswer = false)
+                // Otherwise, this is handled by onAnswer -> answerCall.
+                val callInfo = CallEngine.getActiveCalls().find { it.callId == callId }
+                if (callInfo?.state != CallState.ACTIVE) {
+                     CallEngine.coreCallAnswered(callId, isLocalAnswer = true)
+                }
             }
             STATE_DISCONNECTED -> {
                 Log.d(TAG, "Connection is now disconnected for callId: $callId")
@@ -121,17 +105,37 @@ class MyConnection(
         }
     }
 
+    override fun onCallAudioStateChanged(state: CallAudioState) {
+        super.onCallAudioStateChanged(state)
+        Log.d(TAG, "onCallAudioStateChanged for callId: $callId. muted=${state.isMuted}, route=${routeToString(state.route)}")
+
+        // This callback is the source of truth from the system.
+        // We just need to forward these state changes to our engine/UI.
+        CallEngine.onTelecomAudioRouteChanged(callId, routeToString(state.route))
+
+        // Emit mute/unmute events based on state changes from the system
+        val eventType = if (state.isMuted) CallEventType.CALL_MUTED else CallEventType.CALL_UNMUTED
+        CallEngine.emitEvent(eventType, JSONObject().put("callId", callId))
+    }
+
+    // --- Audio Control Methods (Called from CallEngine) ---
+
+    /**
+     * Requests a change in the audio route (Speaker, Earpiece, etc.).
+     * This is the ONLY method that should be used to change the audio route.
+     */
     fun requestAudioRouteChange(route: Int) {
         Log.d(TAG, "Requesting audio route change to: ${routeToString(route)} for callId: $callId")
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            val endpoint = availableCallEndpoints.find { it.endpointType == route }
+            // For API 34+, use the modern CallEndpoint API
+            val endpoint = this.callAudioState?.availableCallEndpoints?.find { it.type == route }
             if (endpoint != null) {
                 Log.d(TAG, "Using requestCallEndpointChange for API 34+")
-                requestCallEndpointChange(endpoint, telecomExecutor, object : OutcomeReceiver<Void, Exception> {
+                requestCallEndpointChange(endpoint, telecomExecutor, object : OutcomeReceiver<Void, CallEndpointException> {
                     override fun onResult(result: Void?) {
-                        Log.d(TAG, "Successfully changed audio endpoint to ${endpoint.endpointName}")
+                        Log.d(TAG, "Successfully requested audio endpoint change to ${endpoint.name}")
                     }
-                    override fun onError(error: Exception) {
+                    override fun onError(error: CallEndpointException) {
                         Log.e(TAG, "Failed to change audio endpoint", error)
                     }
                 })
@@ -139,23 +143,37 @@ class MyConnection(
                 Log.w(TAG, "Could not find a matching CallEndpoint for route: ${routeToString(route)}")
             }
         } else {
+            // For older APIs, use the deprecated setAudioRoute
             Log.d(TAG, "Using setAudioRoute (deprecated) for older API")
             @Suppress("DEPRECATION")
             setAudioRoute(route)
         }
     }
 
-    fun isBluetoothAvailable(): Boolean {
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            this.callAudioState?.supportedRouteMask?.and(CallAudioState.ROUTE_BLUETOETOOTH) != 0
-        } else {
-            // Fallback for older versions
-            this.callAudioState?.supportedRouteMask?.and(CallAudioState.ROUTE_BLUETOOTH) != 0
-        }
+    /**
+     * Informs the Telecom framework about a mute state change initiated by our app.
+     */
+    fun setMuted(muted: Boolean) {
+        val currentState = this.callAudioState ?: return
+        if (currentState.isMuted == muted) return // No change needed
+
+        val newState = CallAudioState(muted, currentState.route, currentState.supportedRouteMask)
+        // This call informs the system of the change. The system will then call
+        // onCallAudioStateChanged back on this connection instance with the new state.
+        onCallAudioStateChanged(newState)
+        Log.d(TAG, "Informed Telecom of mute state change to: $muted")
     }
 
+
+    // --- Helper Functions ---
+
     fun getCurrentRouteString(): String {
-        return lastAudioState?.route.let { routeToString(it) }
+        return this.callAudioState?.route.let { routeToString(it) }
+    }
+
+    fun isBluetoothAvailable(): Boolean {
+        val mask = this.callAudioState?.supportedRouteMask ?: 0
+        return mask and CallAudioState.ROUTE_BLUETOOTH != 0
     }
 
     private fun routeToString(route: Int?): String {
@@ -167,4 +185,18 @@ class MyConnection(
             else -> "Unknown"
         }
     }
+
+    private fun stateToString(state: Int): String {
+        return when (state) {
+            STATE_INITIALIZING -> "INITIALIZING"
+            STATE_NEW -> "NEW"
+            STATE_RINGING -> "RINGING"
+            STATE_DIALING -> "DIALING"
+            STATE_ACTIVE -> "ACTIVE"
+            STATE_HOLDING -> "HOLDING"
+            STATE_DISCONNECTED -> "DISCONNECTED"
+            STATE_PULLING_CALL -> "PULLING_CALL"
+            else -> "UNKNOWN"
+        }
+    }
 }

package/package.json

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