@qusaieilouti99/call-manager 0.1.52 → 0.1.53

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

@@ -69,7 +69,6 @@ object CallEngine {
 
     // System Call State Tracking
     private var isSystemCallActive: Boolean = false
-    private var wasHeldBySystem: Boolean = false
 
     // Lock Screen Bypass
     private var lockScreenBypassActive = false
@@ -92,7 +91,7 @@ object CallEngine {
     )
 
     enum class CallState {
-        INCOMING, DIALING, ACTIVE, HELD, HELD_BY_SYSTEM, ENDED
+        INCOMING, DIALING, ACTIVE, HELD, ENDED
     }
 
     interface LockScreenBypassCallback {
@@ -104,26 +103,23 @@ object CallEngine {
         Log.d(TAG, "Audio focus changed: $focusChange")
         when (focusChange) {
             AudioManager.AUDIOFOCUS_LOSS -> {
-                // Lost focus permanently - likely due to phone call
                 handleAudioFocusLoss()
             }
             AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-                // Lost focus temporarily
-                handleAudioFocusLossTransient()
+                handleAudioFocusLoss()
             }
             AudioManager.AUDIOFOCUS_GAIN -> {
-                // Regained focus
                 handleAudioFocusGain()
             }
             AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
-                // Can duck audio
-                handleAudioFocusLossCanDuck()
+                // Can duck audio - don't hold call
+                Log.d(TAG, "Audio focus loss - can duck, not holding call")
             }
         }
     }
 
     private fun handleAudioFocusLoss() {
-        Log.d(TAG, "Audio focus lost permanently - likely system call active")
+        Log.d(TAG, "Audio focus lost - likely system call active")
         hasAudioFocus = false
         isSystemCallActive = true
 
@@ -131,17 +127,16 @@ object CallEngine {
         activeCalls.values.filter { it.state == CallState.ACTIVE }.forEach { call ->
             if (!call.wasHeldBySystem) {
                 call.wasHeldBySystem = true
-                call.state = CallState.HELD_BY_SYSTEM
+                call.state = CallState.HELD
 
                 val connection = telecomConnections[call.callId]
                 connection?.setOnHold()
 
                 emitEvent(CallEventType.CALL_HELD, JSONObject().apply {
                     put("callId", call.callId)
-                    put("reason", "system_call_active")
                 })
 
-                notifySpecificCallStateChanged(appContext!!, call.callId, CallState.HELD_BY_SYSTEM)
+                notifySpecificCallStateChanged(appContext!!, call.callId, CallState.HELD)
                 Log.d(TAG, "Call ${call.callId} held by system due to audio focus loss")
             }
         }
@@ -150,39 +145,29 @@ object CallEngine {
         updateForegroundNotification(appContext!!)
     }
 
-    private fun handleAudioFocusLossTransient() {
-        // Similar to permanent loss but may be temporary
-        handleAudioFocusLoss()
-    }
-
     private fun handleAudioFocusGain() {
         Log.d(TAG, "Audio focus regained - system call likely ended")
         hasAudioFocus = true
         isSystemCallActive = false
 
-        // Resume calls that were held by system
-        activeCalls.values.filter { it.state == CallState.HELD_BY_SYSTEM && it.wasHeldBySystem }.forEach { call ->
-            call.wasHeldBySystem = false
-            call.state = CallState.ACTIVE
-
-            val connection = telecomConnections[call.callId]
-            connection?.setActive()
+        // Automatically resume calls that were held by system after a short delay
+        Handler(Looper.getMainLooper()).postDelayed({
+            activeCalls.values.filter { it.state == CallState.HELD && it.wasHeldBySystem }.forEach { call ->
+                Log.d(TAG, "Auto-resuming call ${call.callId} after system call ended")
+                call.wasHeldBySystem = false
+                call.state = CallState.ACTIVE
 
-            emitEvent(CallEventType.CALL_UNHELD, JSONObject().apply {
-                put("callId", call.callId)
-                put("reason", "system_call_ended")
-            })
-
-            notifySpecificCallStateChanged(appContext!!, call.callId, CallState.ACTIVE)
-            Log.d(TAG, "Call ${call.callId} resumed after system call ended")
-        }
+                val connection = telecomConnections[call.callId]
+                connection?.setActive()
 
-        updateForegroundNotification(appContext!!)
-    }
+                emitEvent(CallEventType.CALL_UNHELD, JSONObject().apply {
+                    put("callId", call.callId)
+                })
 
-    private fun handleAudioFocusLossCanDuck() {
-        // Lower volume but continue
-        Log.d(TAG, "Audio focus loss - can duck")
+                notifySpecificCallStateChanged(appContext!!, call.callId, CallState.ACTIVE)
+            }
+            updateForegroundNotification(appContext!!)
+        }, 1000) // 1 second delay to ensure system is ready
     }
 
     private fun requestAudioFocus(): Boolean {
@@ -311,7 +296,6 @@ object CallEngine {
             obj.put("callData", it.callData)
             obj.put("state", it.state.name)
             obj.put("callType", it.callType)
-            obj.put("wasHeldBySystem", it.wasHeldBySystem)
             jsonArray.put(obj)
         }
         val result = jsonArray.toString()
@@ -333,7 +317,7 @@ object CallEngine {
         }
 
         // Check if there's an active call when receiving incoming
-        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE || it.state == CallState.HELD_BY_SYSTEM }
+        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE || it.state == CallState.HELD }
         if (activeCall != null && !canMakeMultipleCalls) {
             Log.d(TAG, "Active call exists when receiving incoming call. Auto-rejecting: $callId")
             rejectIncomingCallCollision(callId, "Another call is already active")
@@ -432,14 +416,13 @@ object CallEngine {
             startForegroundService(context)
             Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
 
-            // Request audio focus for outgoing call
-            if (requestAudioFocus()) {
-                startRingback()
-                setInitialAudioRoute(context, parsedCallType)
-            }
+            // Request audio focus and start ringback
+            requestAudioFocus()
+            startRingback()
 
             bringAppToForeground(context)
             keepScreenAwake(context, true)
+            setInitialAudioRoute(context, parsedCallType)
         } catch (e: SecurityException) {
             Log.e(TAG, "SecurityException: Failed to start outgoing call via placeCall. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
             endCall(context, callId)
@@ -478,9 +461,7 @@ object CallEngine {
         cancelIncomingCallUI(context)
 
         // Request audio focus when answering
-        if (!hasAudioFocus) {
-            requestAudioFocus()
-        }
+        requestAudioFocus()
 
         // Update call state
         activeCalls[callId]?.state = CallState.ACTIVE
@@ -538,31 +519,16 @@ object CallEngine {
     fun unholdCall(context: Context, callId: String) {
         Log.d(TAG, "unholdCall: $callId")
         val callInfo = activeCalls[callId]
-        if (callInfo?.state != CallState.HELD && callInfo?.state != CallState.HELD_BY_SYSTEM) {
+        if (callInfo?.state != CallState.HELD) {
             Log.w(TAG, "Cannot unhold call $callId - not in held state (current: ${callInfo?.state})")
             return
         }
 
-        // If call was held by system, don't allow manual unhold until system allows it
-        if (callInfo.state == CallState.HELD_BY_SYSTEM && isSystemCallActive) {
-            Log.w(TAG, "Cannot unhold call $callId - held by system and system call still active")
-            emitEvent(CallEventType.CALL_UNHOLD_FAILED, JSONObject().apply {
-                put("callId", callId)
-                put("reason", "system_call_active")
-            })
-            return
-        }
-
-        // Request audio focus before unholding
+        // Try to request audio focus, but don't fail if we can't get it immediately
+        // The system will handle audio routing properly
         if (!hasAudioFocus) {
-            if (!requestAudioFocus()) {
-                Log.w(TAG, "Cannot unhold call $callId - failed to gain audio focus")
-                emitEvent(CallEventType.CALL_UNHOLD_FAILED, JSONObject().apply {
-                    put("callId", callId)
-                    put("reason", "audio_focus_failed")
-                })
-                return
-            }
+            Log.d(TAG, "Attempting to request audio focus for unhold")
+            requestAudioFocus()
         }
 
         activeCalls[callId]?.state = CallState.ACTIVE
@@ -574,6 +540,8 @@ object CallEngine {
         emitEvent(CallEventType.CALL_UNHELD, JSONObject().put("callId", callId))
         updateLockScreenBypass()
         notifySpecificCallStateChanged(context, callId, CallState.ACTIVE)
+
+        Log.d(TAG, "Call $callId successfully unheld")
     }
 
     fun muteCall(context: Context, callId: String) {
@@ -880,8 +848,7 @@ object CallEngine {
         it.value.state == CallState.ACTIVE ||
         it.value.state == CallState.INCOMING ||
         it.value.state == CallState.DIALING ||
-        it.value.state == CallState.HELD ||
-        it.value.state == CallState.HELD_BY_SYSTEM
+        it.value.state == CallState.HELD
     }
 
     private fun validateOutgoingCallRequest(): Boolean {
@@ -1037,8 +1004,7 @@ object CallEngine {
         // Find the current active call to pass its info
         val currentCall = activeCalls.values.find {
             it.state == CallState.ACTIVE || it.state == CallState.INCOMING ||
-            it.state == CallState.DIALING || it.state == CallState.HELD ||
-            it.state == CallState.HELD_BY_SYSTEM
+            it.state == CallState.DIALING || it.state == CallState.HELD
         }
 
         val intent = Intent(context, CallForegroundService::class.java)
@@ -1203,7 +1169,6 @@ object CallEngine {
             put("callData", callInfo.callData)
             put("state", newState.name)
             put("callType", callInfo.callType)
-            put("wasHeldBySystem", callInfo.wasHeldBySystem)
         }
 
         Log.d(TAG, "Specific call state changed. Emitting CALL_STATE_CHANGED for $callId: $newState")
@@ -1213,9 +1178,8 @@ object CallEngine {
     private fun updateForegroundNotification(context: Context) {
         val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
         val heldCall = activeCalls.values.find { it.state == CallState.HELD }
-        val heldBySystemCall = activeCalls.values.find { it.state == CallState.HELD_BY_SYSTEM }
 
-        val callToShow = activeCall ?: heldCall ?: heldBySystemCall
+        val callToShow = activeCall ?: heldCall
         callToShow?.let {
             val intent = Intent(context, CallForegroundService::class.java)
             intent.putExtra("UPDATE_NOTIFICATION", true)
@@ -1236,8 +1200,6 @@ object CallEngine {
         stopForegroundService(context)
         keepScreenAwake(context, false)
         resetAudioMode(context)
-        abandonAudioFocus()
         isSystemCallActive = false
-        wasHeldBySystem = false
     }
 }

package/package.json

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