@qusaieilouti99/call-manager 0.1.113 → 0.1.115

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

@@ -42,8 +42,7 @@ import android.os.Vibrator
 import android.os.VibrationEffect
 import android.content.BroadcastReceiver
 import android.content.IntentFilter
-import android.database.ContentObserver
-import android.provider.Settings
+import android.view.KeyEvent
 
 /**
  * Core call‐management engine.  Manages self-managed telecom calls,
@@ -55,16 +54,7 @@ object CallEngine {
   private const val NOTIF_CHANNEL_ID = "incoming_call_channel"
   private const val NOTIF_ID = 2001
 
-  // Audio routing timing constants
-  private const val AUDIO_ROUTE_DELAY_AFTER_ANSWER = 500L
-  private const val AUDIO_ROUTE_RETRY_DELAY = 200L
-  private const val MAX_AUDIO_ROUTE_RETRIES = 3
-
   // --- NEW: Call-end listener API ---
-  /**
-   * Implement this in your UI (CallActivity).  Will be called
-   * on the main thread whenever a call is ended.
-   */
   interface CallEndListener {
     fun onCallEnded(callId: String)
   }
@@ -82,30 +72,28 @@ object CallEngine {
   fun unregisterCallEndListener(l: CallEndListener) {
     callEndListeners.remove(l)
   }
-  // --- end listener API ---
 
   // Core context - initialized once and maintained
   @Volatile private var appContext: Context? = null
   private val isInitialized = AtomicBoolean(false)
   private val initializationLock = Any()
 
-  // Audio & Media Management
+  // Simplified Audio & Media Management
   private var ringtone: android.media.Ringtone? = null
   private var ringbackPlayer: MediaPlayer? = null
 
-  // Volume monitoring
+  // FIXED: New volume key handling approach
   private var vibrator: Vibrator? = null
-  private var volumeContentObserver: ContentObserver? = null
-  private var lastRingVolumeLevel = -1
-  private var isMonitoringVolume = false
+  private var volumeKeyReceiver: BroadcastReceiver? = null
+  private var isRingtonePlaying = false
 
   private var audioManager: AudioManager? = null
   private var wakeLock: PowerManager.WakeLock? = null
 
-  // Audio routing state
-  private var pendingAudioRoute: String? = null
-  private var audioRouteRetryCount = 0
-  private val audioRouteHandler = Handler(Looper.getMainLooper())
+  // FIXED: New audio routing approach
+  private var desiredAudioRoute: String? = null
+  private var isWaitingForTelecomAudioState = false
+  private val audioRoutingHandler = Handler(Looper.getMainLooper())
 
   // Call State Management
   private val activeCalls = ConcurrentHashMap<String, CallInfo>()
@@ -136,7 +124,7 @@ object CallEngine {
       if (isInitialized.compareAndSet(false, true)) {
         appContext = context.applicationContext
         audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
-        setupVolumeMonitoring()
+        setupVolumeKeyDetection()
         Log.d(TAG, "CallEngine initialized successfully")
 
         if (isCallActive()) {
@@ -154,61 +142,69 @@ object CallEngine {
     )
   }
 
-  // --- VOLUME MONITORING FOR RINGTONE SILENCING ---
-  private fun setupVolumeMonitoring() {
-    val context = requireContext()
-    audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-
-    // Get initial ring volume
-    lastRingVolumeLevel = audioManager?.getStreamVolume(AudioManager.STREAM_RING) ?: 0
-
-    // Create content observer for ring volume changes
-    volumeContentObserver = object : ContentObserver(mainHandler) {
-      override fun onChange(selfChange: Boolean) {
-        handleVolumeChange()
+  // --- FIXED: Volume Key Detection for Ringtone Silencing ---
+  private fun setupVolumeKeyDetection() {
+    volumeKeyReceiver = object : BroadcastReceiver() {
+      override fun onReceive(context: Context, intent: Intent) {
+        when (intent.action) {
+          Intent.ACTION_MEDIA_BUTTON -> {
+            val keyEvent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+              intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT, KeyEvent::class.java)
+            } else {
+              @Suppress("DEPRECATION")
+              intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT) as? KeyEvent
+            }
+
+            if (keyEvent?.action == KeyEvent.ACTION_DOWN) {
+              when (keyEvent.keyCode) {
+                KeyEvent.KEYCODE_VOLUME_UP,
+                KeyEvent.KEYCODE_VOLUME_DOWN -> {
+                  if (isRingtonePlaying) {
+                    Log.d(TAG, "Volume key pressed - silencing ringtone")
+                    stopRingtone()
+                  }
+                }
+              }
+            }
+          }
+          "android.media.VOLUME_CHANGED_ACTION" -> {
+            // Secondary fallback for some devices
+            if (isRingtonePlaying) {
+              Log.d(TAG, "Volume changed while ringing - silencing ringtone")
+              stopRingtone()
+            }
+          }
+        }
       }
     }
   }
 
-  private fun startVolumeMonitoring() {
-    if (!isMonitoringVolume) {
-      isMonitoringVolume = true
-      val context = requireContext()
-
-      // Monitor ring volume changes
-      context.contentResolver.registerContentObserver(
-        Settings.System.getUriFor(Settings.System.VOLUME_RING),
-        false,
-        volumeContentObserver!!
-      )
-
-      Log.d(TAG, "Started volume monitoring for ringtone silencing")
-    }
-  }
-
-  private fun stopVolumeMonitoring() {
-    if (isMonitoringVolume) {
-      isMonitoringVolume = false
-      val context = requireContext()
-      volumeContentObserver?.let {
-        context.contentResolver.unregisterContentObserver(it)
+  private fun startVolumeKeyMonitoring() {
+    val context = requireContext()
+    if (volumeKeyReceiver != null) {
+      val filter = IntentFilter().apply {
+        addAction(Intent.ACTION_MEDIA_BUTTON)
+        addAction("android.media.VOLUME_CHANGED_ACTION")
+        priority = IntentFilter.SYSTEM_HIGH_PRIORITY
+      }
+      try {
+        context.registerReceiver(volumeKeyReceiver, filter)
+        Log.d(TAG, "Volume key monitoring started")
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to register volume key receiver: ${e.message}")
       }
-      Log.d(TAG, "Stopped volume monitoring")
     }
   }
 
-  private fun handleVolumeChange() {
-    if (!isMonitoringVolume) return
-
-    val currentRingVolume = audioManager?.getStreamVolume(AudioManager.STREAM_RING) ?: 0
-
-    // Check if ring volume changed
-    if (currentRingVolume != lastRingVolumeLevel) {
-      Log.d(TAG, "Ring volume changed from $lastRingVolumeLevel to $currentRingVolume - silencing ringtone")
-      lastRingVolumeLevel = currentRingVolume
-
-      // Stop ringtone when volume is changed
-      stopRingtone()
+  private fun stopVolumeKeyMonitoring() {
+    val context = requireContext()
+    volumeKeyReceiver?.let {
+      try {
+        context.unregisterReceiver(it)
+        Log.d(TAG, "Volume key monitoring stopped")
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to unregister volume key receiver: ${e.message}")
+      }
     }
   }
 
@@ -276,6 +272,61 @@ object CallEngine {
 
   fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
 
+  // --- FIXED: Audio Route Management via Telecom Callback ---
+  /**
+   * Called by MyConnection when telecom audio state changes.
+   * This is the key to solving the audio routing issue.
+   */
+  fun onTelecomAudioStateChanged(callId: String, audioState: CallAudioState) {
+    Log.d(TAG, "Telecom audio state changed for $callId: route=${audioState.route}, muted=${audioState.isMuted}")
+
+    // If we have a desired route that differs from current, apply it now
+    desiredAudioRoute?.let { desired ->
+      val currentTelecomRoute = telecomRouteToString(audioState.route)
+      if (currentTelecomRoute != desired) {
+        Log.d(TAG, "Applying desired route $desired (current: $currentTelecomRoute)")
+        applyAudioRouteThroughTelecom(callId, desired)
+      } else {
+        Log.d(TAG, "Desired route $desired matches current route")
+        desiredAudioRoute = null // Clear since we're in sync
+      }
+    }
+
+    // Always emit the current state
+    emitAudioRouteChanged()
+  }
+
+  private fun telecomRouteToString(route: Int): String {
+    return when (route) {
+      CallAudioState.ROUTE_BLUETOOTH -> "Bluetooth"
+      CallAudioState.ROUTE_SPEAKER -> "Speaker"
+      CallAudioState.ROUTE_WIRED_HEADSET -> "Headset"
+      CallAudioState.ROUTE_EARPIECE -> "Earpiece"
+      else -> "Unknown"
+    }
+  }
+
+  private fun stringToTelecomRoute(route: String): Int {
+    return when (route) {
+      "Bluetooth" -> CallAudioState.ROUTE_BLUETOOTH
+      "Speaker" -> CallAudioState.ROUTE_SPEAKER
+      "Headset" -> CallAudioState.ROUTE_WIRED_HEADSET
+      "Earpiece" -> CallAudioState.ROUTE_EARPIECE
+      else -> CallAudioState.ROUTE_EARPIECE
+    }
+  }
+
+  private fun applyAudioRouteThroughTelecom(callId: String, route: String) {
+    val connection = telecomConnections[callId]
+    if (connection != null) {
+      val telecomRoute = stringToTelecomRoute(route)
+      connection.setAudioRoute(telecomRoute)
+      Log.d(TAG, "Set audio route via telecom connection: $route")
+    } else {
+      Log.w(TAG, "No telecom connection found for $callId, cannot set audio route")
+    }
+  }
+
   // --- Public API ---
   fun setCanMakeMultipleCalls(allow: Boolean) {
     canMakeMultipleCalls = allow
@@ -467,10 +518,8 @@ object CallEngine {
     startForegroundService()
     keepScreenAwake(true)
 
-    // Delay initial audio route to avoid conflicts
-    mainHandler.postDelayed({
-      setInitialAudioRoute(callType)
-    }, AUDIO_ROUTE_DELAY_AFTER_ANSWER)
+    // Set desired initial route, will be applied when telecom state changes
+    setInitialAudioRoute(callType)
 
     updateLockScreenBypass()
 
@@ -517,10 +566,8 @@ object CallEngine {
     keepScreenAwake(true)
     updateLockScreenBypass()
 
-    // FIXED: Delay audio routing to avoid conflicts with system
-    mainHandler.postDelayed({
-      setInitialAudioRoute(callInfo.callType)
-    }, AUDIO_ROUTE_DELAY_AFTER_ANSWER)
+    // FIXED: Set initial route via telecom system
+    setInitialAudioRoute(callInfo.callType)
 
     if (isLocalAnswer) {
       emitCallAnsweredWithMetadata(callId)
@@ -807,110 +854,20 @@ object CallEngine {
     return AudioRoutesInfo(devices.toTypedArray(), current)
   }
 
-  // FIXED: Improved audio route handling with retries and proper timing
+  // FIXED: New audio route approach - work with telecom system instead of against it
   fun setAudioRoute(route: String) {
-    Log.d(TAG, "setAudioRoute called: $route")
-
-    // Clear any pending route changes
-    audioRouteHandler.removeCallbacksAndMessages(null)
-    audioRouteRetryCount = 0
-
-    // Store the pending route for retry logic
-    pendingAudioRoute = route
-
-    // Execute immediately, then set up retry mechanism
-    performAudioRouteChange(route)
-  }
-
-  private fun performAudioRouteChange(route: String) {
-    val ctx = requireContext()
-    if (audioManager == null) {
-      audioManager = ctx.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    }
-    val am = audioManager!!
-
-    // Ensure proper audio mode first
-    if (am.mode != AudioManager.MODE_IN_COMMUNICATION) {
-      setAudioMode()
-    }
-
-    Log.d(TAG, "Performing audio route change to: $route")
-
-    when (route) {
-      "Speaker" -> {
-        // Disable Bluetooth SCO first if active
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && am.isBluetoothScoOn) {
-          am.stopBluetoothSco()
-          am.isBluetoothScoOn = false
-        }
-        am.isSpeakerphoneOn = true
-        Log.d(TAG, "Audio routed to SPEAKER")
-      }
-
-      "Earpiece" -> {
-        // Disable Bluetooth SCO if active
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && am.isBluetoothScoOn) {
-          am.stopBluetoothSco()
-          am.isBluetoothScoOn = false
-        }
-        am.isSpeakerphoneOn = false
-        Log.d(TAG, "Audio routed to EARPIECE")
-      }
-
-      "Bluetooth" -> {
-        am.isSpeakerphoneOn = false
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-          am.startBluetoothSco()
-          am.isBluetoothScoOn = true
-          Log.d(TAG, "Audio routed to BLUETOOTH (SCO started)")
-        } else {
-          Log.w(TAG, "Bluetooth SCO not supported on this OS")
-        }
-      }
-
-      "Headset" -> {
-        am.isSpeakerphoneOn = false
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && am.isBluetoothScoOn) {
-          am.stopBluetoothSco()
-          am.isBluetoothScoOn = false
-        }
-        Log.d(TAG, "Audio routed to HEADSET (wired)")
-      }
-
-      else -> {
-        Log.w(TAG, "Unknown audio route: $route")
-        return
-      }
-    }
+    Log.d(TAG, "setAudioRoute requested: $route")
+    desiredAudioRoute = route
 
-    // Verify the route was applied and retry if necessary
-    audioRouteHandler.postDelayed({
-      verifyAudioRoute(route)
-    }, AUDIO_ROUTE_RETRY_DELAY)
+    // Try to apply immediately if we have an active call
+    val activeCallId = activeCalls.values.find {
+      it.state == CallState.ACTIVE
+    }?.callId
 
-    emitAudioRouteChanged()
-  }
-
-  private fun verifyAudioRoute(expectedRoute: String) {
-    val currentRoute = getCurrentAudioRoute()
-
-    if (currentRoute != expectedRoute && audioRouteRetryCount < MAX_AUDIO_ROUTE_RETRIES) {
-      audioRouteRetryCount++
-      Log.d(TAG, "Audio route verification failed. Expected: $expectedRoute, Current: $currentRoute. Retry: $audioRouteRetryCount")
-
-      // Retry the audio route change
-      audioRouteHandler.postDelayed({
-        performAudioRouteChange(expectedRoute)
-      }, AUDIO_ROUTE_RETRY_DELAY)
+    if (activeCallId != null) {
+      applyAudioRouteThroughTelecom(activeCallId, route)
     } else {
-      if (currentRoute == expectedRoute) {
-        Log.d(TAG, "Audio route successfully verified: $currentRoute")
-      } else {
-        Log.w(TAG, "Audio route change failed after $MAX_AUDIO_ROUTE_RETRIES retries. Expected: $expectedRoute, Current: $currentRoute")
-      }
-      // Clear pending route
-      pendingAudioRoute = null
-      audioRouteRetryCount = 0
+      Log.d(TAG, "No active call found, route will be applied when call becomes active")
     }
   }
 
@@ -1343,21 +1300,23 @@ object CallEngine {
   }
 
   // --- Media Management ---
-  // FIXED: Improved ringtone management with proper volume monitoring
+  // FIXED: Improved ringtone with volume key detection
   private fun playRingtone() {
     val context = requireContext()
 
     audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
+    // Set ringtone playing flag
+    isRingtonePlaying = true
+
     // Set up proper audio mode for ringtone
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
       audioManager?.mode = AudioManager.MODE_RINGTONE
     }
     audioManager?.isSpeakerphoneOn = true
 
-    // Start volume monitoring for silencing
-    startVolumeMonitoring()
-    lastRingVolumeLevel = audioManager?.getStreamVolume(AudioManager.STREAM_RING) ?: 0
+    // Start volume key monitoring
+    startVolumeKeyMonitoring()
 
     // Start repeating vibration
     vibrator = context.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
@@ -1383,6 +1342,8 @@ object CallEngine {
   }
 
   fun stopRingtone() {
+    isRingtonePlaying = false
+
     try {
       ringtone?.stop()
       Log.d(TAG, "Ringtone stopped")
@@ -1395,8 +1356,8 @@ object CallEngine {
     vibrator?.cancel()
     vibrator = null
 
-    // Stop volume monitoring
-    stopVolumeMonitoring()
+    // Stop volume key monitoring
+    stopVolumeKeyMonitoring()
   }
 
   private fun startRingback() {
@@ -1433,10 +1394,9 @@ object CallEngine {
     stopForegroundService()
     keepScreenAwake(false)
     resetAudioMode()
-    stopVolumeMonitoring()
-    audioRouteHandler.removeCallbacksAndMessages(null)
-    pendingAudioRoute = null
-    audioRouteRetryCount = 0
+    stopVolumeKeyMonitoring()
+    desiredAudioRoute = null
+    isWaitingForTelecomAudioState = false
   }
 
   // --- Lifecycle Management ---

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

@@ -130,4 +130,22 @@ class MyConnection(
             }
         }
     }
+
+    override fun onCallAudioStateChanged(state: CallAudioState) {
+        super.onCallAudioStateChanged(state)
+        Log.d(TAG, "Audio state changed 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)
+            }
+        }
+
+        // FIXED: Notify CallEngine of telecom audio state changes
+        CallEngine.onTelecomAudioStateChanged(callId, state)
+
+        lastAudioState = state
+    }
 }

package/package.json

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