@qusaieilouti99/call-manager 0.1.63 → 0.1.64

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

@@ -48,13 +48,11 @@ object CallEngine {
     private const val FOREGROUND_NOTIF_ID = 1001
 
     // Core context - initialized once and maintained
-    // Improved context management with thread safety
     @Volatile
     private var appContext: Context? = null
     private val isInitialized = AtomicBoolean(false)
     private val initializationLock = Any()
 
-
     // Audio & Media
     private var ringtone: android.media.Ringtone? = null
     private var ringbackPlayer: MediaPlayer? = null
@@ -87,7 +85,7 @@ object CallEngine {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    // --- INITIALIZATION with better error handling ---
+    // --- INITIALIZATION - Fixed for better context management ---
     fun initialize(context: Context) {
         synchronized(initializationLock) {
             if (isInitialized.compareAndSet(false, true)) {
@@ -143,38 +141,79 @@ object CallEngine {
         }
     }
 
-    // --- Audio Focus Management (Simplified) ---
+    // --- FIXED Audio Focus Management ---
     private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
         Log.d(TAG, "Audio focus changed: $focusChange")
         when (focusChange) {
-            AudioManager.AUDIOFOCUS_LOSS,
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                Log.d(TAG, "Permanent audio focus loss - another app took focus")
+                hasAudioFocus = false
+                isSystemCallActive = true
+                holdSystemCalls()
+            }
             AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                Log.d(TAG, "Transient audio focus loss - temporary interruption")
                 hasAudioFocus = false
                 isSystemCallActive = true
                 holdSystemCalls()
             }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                Log.d(TAG, "Audio focus loss with ducking - lowering volume but keeping active")
+                // Don't hold the call for ducking, just lower volume
+                hasAudioFocus = false
+            }
             AudioManager.AUDIOFOCUS_GAIN -> {
+                Log.d(TAG, "Audio focus gained")
                 hasAudioFocus = true
                 isSystemCallActive = false
+                // Delay resuming to avoid rapid hold/unhold cycles
                 Handler(Looper.getMainLooper()).postDelayed({
                     resumeSystemHeldCalls()
-                }, 1000)
+                }, 500)  // Reduced from 1000ms
+            }
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT -> {
+                Log.d(TAG, "Transient audio focus gained")
+                hasAudioFocus = true
             }
         }
         updateForegroundNotification()
     }
 
     private fun holdSystemCalls() {
-        activeCalls.values.filter { it.state == CallState.ACTIVE }.forEach { call ->
-            if (!call.wasHeldBySystem) {
+        val callsToHold = activeCalls.values.filter {
+            it.state == CallState.ACTIVE && !it.wasHeldBySystem
+        }
+
+        if (callsToHold.isEmpty()) {
+            Log.d(TAG, "No active calls to hold due to audio focus loss")
+            return
+        }
+
+        Log.d(TAG, "Holding ${callsToHold.size} calls due to audio focus loss")
+        callsToHold.forEach { call ->
+            // Add a small delay to prevent holding immediately after answering
+            val timeSinceAnswer = System.currentTimeMillis() - call.timestamp
+            if (timeSinceAnswer > 2000) {  // Only hold if call has been active for 2+ seconds
                 holdCallInternal(call.callId, heldBySystem = true)
+            } else {
+                Log.d(TAG, "Skipping hold for recently answered call: ${call.callId}")
             }
         }
         stopRingback()
     }
 
     private fun resumeSystemHeldCalls() {
-        activeCalls.values.filter { it.state == CallState.HELD && it.wasHeldBySystem }.forEach { call ->
+        val callsToResume = activeCalls.values.filter {
+            it.state == CallState.HELD && it.wasHeldBySystem
+        }
+
+        if (callsToResume.isEmpty()) {
+            Log.d(TAG, "No system-held calls to resume")
+            return
+        }
+
+        Log.d(TAG, "Resuming ${callsToResume.size} system-held calls")
+        callsToResume.forEach { call ->
             unholdCallInternal(call.callId, resumedBySystem = true)
         }
     }
@@ -192,12 +231,13 @@ object CallEngine {
                             .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                             .build()
                     )
-                    .setOnAudioFocusChangeListener(audioFocusChangeListener)
+                    .setOnAudioFocusChangeListener(audioFocusChangeListener, Handler(Looper.getMainLooper()))
+                    .setAcceptsDelayedFocusGain(true)  // Added this
                     .build()
             }
             val result = audioManager?.requestAudioFocus(audioFocusRequest!!)
             hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
-            Log.d(TAG, "Audio focus request result: $result")
+            Log.d(TAG, "Audio focus request result: $result (granted: $hasAudioFocus)")
             hasAudioFocus
         } else {
             @Suppress("DEPRECATION")
@@ -207,7 +247,7 @@ object CallEngine {
                 AudioManager.AUDIOFOCUS_GAIN
             )
             hasAudioFocus = result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
-            Log.d(TAG, "Audio focus request result (legacy): $result")
+            Log.d(TAG, "Audio focus request result (legacy): $result (granted: $hasAudioFocus)")
             hasAudioFocus
         }
     }
@@ -345,7 +385,7 @@ object CallEngine {
 
         try {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
-            startForegroundService() // Fixed: Always start foreground service
+            startForegroundService()
             Log.d(TAG, "Successfully reported incoming call to TelecomManager for $callId")
         } catch (e: SecurityException) {
             Log.e(TAG, "SecurityException: Failed to report incoming call. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
@@ -395,7 +435,7 @@ object CallEngine {
         val phoneAccountHandle = getPhoneAccountHandle()
         val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, targetName, null)
 
-        // 1) build a bundle of ONLY your own keys
+        // Build a bundle of ONLY your own keys
         val outgoingExtras = Bundle().apply {
             putString(MyConnectionService.EXTRA_CALL_ID, callId)
             putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
@@ -404,7 +444,7 @@ object CallEngine {
             metadata?.let { putString("metadata", it) }
         }
 
-        // 2) wrap under the single Telecom‐honored key
+        // Wrap under the single Telecom-honored key
         val extras = Bundle().apply {
             putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandle)
             putBundle(TelecomManager.EXTRA_OUTGOING_CALL_EXTRAS, outgoingExtras)
@@ -414,8 +454,15 @@ object CallEngine {
         try {
             telecomManager.placeCall(addressUri, extras)
             startForegroundService()
-            requestAudioFocus()
-            startRingback()
+
+            // FIXED: Request audio focus BEFORE starting ringback
+            val audioFocusGranted = requestAudioFocus()
+            if (audioFocusGranted) {
+                startRingback()
+            } else {
+                Log.w(TAG, "Audio focus not granted for outgoing call, skipping ringback")
+            }
+
             bringAppToForeground()
             keepScreenAwake(true)
             setInitialAudioRoute(callType)
@@ -464,13 +511,13 @@ object CallEngine {
         registerPhoneAccount()
         requestAudioFocus()
         bringAppToForeground()
-        startForegroundService() // Fixed: Start foreground service for JS-initiated calls
+        startForegroundService()
         keepScreenAwake(true)
         setInitialAudioRoute(callType)
         updateLockScreenBypass()
 
-        // Emit call answered event with metadata
-        emitCallAnsweredWithMetadata(callId)
+        // Emit outgoing call answered event with metadata for JS-initiated calls
+        emitOutgoingCallAnsweredWithMetadata(callId)
     }
 
     // --- Call Answer Management ---
@@ -484,6 +531,7 @@ object CallEngine {
         coreCallAnswered(callId, isLocalAnswer = true)
     }
 
+    // FIXED: Core Call Answered Method with proper audio focus handling
     private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
         val context = requireContext()
         Log.d(TAG, "coreCallAnswered: $callId, isLocalAnswer: $isLocalAnswer")
@@ -494,13 +542,27 @@ object CallEngine {
             return
         }
 
+        // FIXED: Request audio focus FIRST, before stopping media
+        val audioFocusGranted = requestAudioFocus()
+        if (!audioFocusGranted) {
+            Log.w(TAG, "Failed to get audio focus for call $callId, but continuing...")
+            // Don't fail the call, but warn about audio issues
+        }
+
+        // Stop media AFTER getting audio focus
         stopRingtone()
         stopRingback()
         cancelIncomingCallUI()
-        requestAudioFocus()
 
-        activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
-        currentCallId = callId
+        // FIXED: Only set call to ACTIVE if we have audio focus OR if it's a remote answer
+        if (audioFocusGranted || !isLocalAnswer) {
+            activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
+            currentCallId = callId
+            Log.d(TAG, "Call $callId set to ACTIVE state")
+        } else {
+            Log.w(TAG, "Call $callId not set to ACTIVE due to audio focus failure")
+            return
+        }
 
         if (!canMakeMultipleCalls) {
             activeCalls.filter { it.key != callId }.values.forEach { otherCall ->
@@ -511,18 +573,25 @@ object CallEngine {
         }
 
         bringAppToForeground()
-        startForegroundService() // Fixed: Ensure foreground service is running
+        startForegroundService()
         keepScreenAwake(true)
         resetAudioMode()
         updateLockScreenBypass()
         updateForegroundNotification()
 
-        // Emit with metadata
-        emitCallAnsweredWithMetadata(callId)
+        // FIXED: Emit different events based on call direction
+        if (isLocalAnswer) {
+            // This is for incoming calls - user answered locally
+            emitCallAnsweredWithMetadata(callId)
+        } else {
+            // This is for outgoing calls - remote party answered
+            emitOutgoingCallAnsweredWithMetadata(callId)
+        }
 
         Log.d(TAG, "Call $callId successfully answered and UI cleaned up")
     }
 
+    // For incoming calls (local answer)
     private fun emitCallAnsweredWithMetadata(callId: String) {
         val callInfo = activeCalls[callId] ?: return
         val metadata = callMetadata[callId]
@@ -543,6 +612,27 @@ object CallEngine {
         })
     }
 
+    // For outgoing calls (remote answer)
+    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) {
+                    Log.w(TAG, "Invalid metadata JSON for callId: $callId", e)
+                    put("metadata", it) // fallback to string
+                }
+            }
+        })
+    }
+
     // --- Call Control Methods ---
     fun holdCall(callId: String) {
         holdCallInternal(callId, heldBySystem = false)
@@ -601,7 +691,7 @@ object CallEngine {
             return
         }
 
-        // Fixed: Simplified audio focus check to prevent UNHELD FAILED
+        // FIXED: Simplified audio focus check to prevent UNHELD FAILED
         if (!hasAudioFocus && !resumedBySystem && !requestAudioFocus()) {
             Log.w(TAG, "Failed to get audio focus for unhold - but continuing anyway")
             // Don't emit UNHELD FAILED - just continue

package/package.json

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