@qusaieilouti99/call-manager 0.1.43 → 0.1.45

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

@@ -1,4 +1,5 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
+
 import android.app.Activity
 import android.content.Intent
 import android.os.Build
@@ -48,6 +49,7 @@ class CallActivity : Activity() {
         callType = intent.getStringExtra("callType") ?: "Audio"
         Log.d(TAG, "CallActivity received callId: $callId, callType: $callType")
 
+        // FIXED: Immediate cleanup of notifications when CallActivity is shown
         CallEngine.cancelIncomingCallUI(this)
 
         val callerName = intent.getStringExtra("callerName") ?: "Unknown"
@@ -60,7 +62,9 @@ class CallActivity : Activity() {
         answerBtn.setOnClickListener {
             Log.d(TAG, "CallActivity: Answer button clicked for callId: $callId")
             finishReason = FinishReason.ANSWER
-            CallEngine.bringAppToForeground(this)
+
+            // FIXED: Use single source of truth - this will handle all cleanup
+            CallEngine.answerCall(this, callId)
             finishCallActivity()
         }
 
@@ -78,7 +82,10 @@ class CallActivity : Activity() {
         super.onDestroy()
         Log.d(TAG, "CallActivity onDestroy for callId: $callId. Reason: $finishReason")
         timeoutHandler.removeCallbacks(timeoutRunnable)
+
+        // FIXED: Ensure cleanup happens regardless of how activity ends
         CallEngine.stopRingtone()
+        CallEngine.cancelIncomingCallUI(this)
     }
 
     override fun onBackPressed() {

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

@@ -105,7 +105,6 @@ object CallEngine {
     }
 
     // --- Public API ---
-
     fun setCanMakeMultipleCalls(allow: Boolean) {
         canMakeMultipleCalls = allow
         Log.d(TAG, "canMakeMultipleCalls set to: $allow")
@@ -164,6 +163,7 @@ object CallEngine {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
             startForegroundService(context)
             Log.d(TAG, "Successfully reported incoming call to TelecomManager for $callId")
+            // REMOVED: Don't bring app to foreground for incoming calls - only when answered
         } catch (e: SecurityException) {
             Log.e(TAG, "SecurityException: Failed to report incoming call. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
             endCall(context, callId)
@@ -174,7 +174,6 @@ object CallEngine {
         notifyCallStateChanged(context)
     }
 
-    // CORRECTED: Uses TelecomManager.placeCall for outgoing calls.
     fun startOutgoingCall(context: Context, callId: String, callData: String) {
         appContext = context.applicationContext
         Log.d(TAG, "startOutgoingCall: $callId, $callData")
@@ -218,6 +217,7 @@ object CallEngine {
             startForegroundService(context)
             Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
             startRingback()
+            // CHANGED: Bring app to foreground for outgoing calls
             bringAppToForeground(context)
             keepScreenAwake(context, true)
             if (parsedCallType == "Video") {
@@ -235,33 +235,46 @@ object CallEngine {
         notifyCallStateChanged(context)
     }
 
+    // SINGLE SOURCE OF TRUTH: Core function for handling when remote party answers
     fun callAnsweredFromJS(context: Context, callId: String) {
         Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
-        stopRingback()
-        activeCalls[callId]?.state = CallState.ACTIVE
-        currentCallId = callId
-        if (!canMakeMultipleCalls) {
-            activeCalls.filter { it.key != callId }.values.forEach { it.state = CallState.HELD }
-        }
-        notifyCallStateChanged(context)
-        emitEvent(CallEventType.CALL_ANSWERED, JSONObject().put("callId", callId))
-        keepScreenAwake(context, true)
-        resetAudioMode(context)
+        coreCallAnswered(context, callId, isLocalAnswer = false)
     }
 
+    // SINGLE SOURCE OF TRUTH: Core function for handling local answer (user answering)
     fun answerCall(context: Context, callId: String) {
         Log.d(TAG, "answerCall: $callId - local party answering")
+        coreCallAnswered(context, callId, isLocalAnswer = true)
+    }
+
+    // SINGLE SOURCE OF TRUTH: Core function that handles ALL call answering logic
+    private fun coreCallAnswered(context: Context, callId: String, isLocalAnswer: Boolean) {
+        Log.d(TAG, "coreCallAnswered: $callId, isLocalAnswer: $isLocalAnswer")
+
+        // Stop all ringtones and notifications immediately
         stopRingtone()
+        stopRingback()
+        cancelIncomingCallUI(context)
+
+        // Update call state
         activeCalls[callId]?.state = CallState.ACTIVE
         currentCallId = callId
+
         if (!canMakeMultipleCalls) {
             activeCalls.filter { it.key != callId }.values.forEach { it.state = CallState.HELD }
         }
-        emitEvent(CallEventType.CALL_ANSWERED, JSONObject().put("callId", callId))
-        notifyCallStateChanged(context)
+
+        // Bring app to foreground only when call is answered
+        bringAppToForeground(context)
         startForegroundService(context)
         keepScreenAwake(context, true)
         resetAudioMode(context)
+
+        // Emit event
+        emitEvent(CallEventType.CALL_ANSWERED, JSONObject().put("callId", callId))
+        notifyCallStateChanged(context)
+
+        Log.d(TAG, "Call $callId successfully answered and UI cleaned up")
     }
 
     fun holdCall(context: Context, callId: String) {
@@ -295,73 +308,113 @@ object CallEngine {
         emitEvent(CallEventType.CALL_UNMUTED, JSONObject().put("callId", callId))
     }
 
+    // SINGLE SOURCE OF TRUTH: Core function that handles ALL call ending logic
     fun endCall(context: Context, callId: String) {
         appContext = context.applicationContext
         Log.d(TAG, "endCall: $callId")
+
+        // Core cleanup logic
+        coreEndCall(context, callId)
+    }
+
+    fun endAllCalls(context: Context) {
+        Log.d(TAG, "endAllCalls: Ending all active calls.")
+        if (activeCalls.isEmpty()) {
+            Log.d(TAG, "No active calls, nothing to do.")
+            return
+        }
+        activeCalls.keys.toList().forEach { callId ->
+            coreEndCall(context, callId)
+        }
+        activeCalls.clear()
+        telecomConnections.clear()
+        currentCallId = null
+
+        // Final cleanup
+        finalCleanup(context)
+        notifyCallStateChanged(context)
+    }
+
+    // SINGLE SOURCE OF TRUTH: Core function that handles ending a single call
+    private fun coreEndCall(context: Context, callId: String) {
+        Log.d(TAG, "coreEndCall: $callId")
+
+        // Update call state
         activeCalls[callId]?.state = CallState.ENDED
         activeCalls.remove(callId)
         Log.d(TAG, "Call $callId removed from activeCalls. Remaining: ${activeCalls.size}")
 
+        // Stop ringtones and notifications
         stopRingback()
         stopRingtone()
+        cancelIncomingCallUI(context)
 
+        // Update current call
         if (currentCallId == callId) {
             currentCallId = activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
             Log.d(TAG, "Current call was $callId. New currentCallId: $currentCallId")
         }
 
-        cancelIncomingCallUI(context)
-
+        // Handle telecom connection
         val connection = telecomConnections[callId]
         if (connection != null) {
             connection.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
             connection.destroy()
             removeTelecomConnection(callId)
             Log.d(TAG, "Telecom Connection for $callId disconnected and destroyed.")
-        } else {
-            Log.d(TAG, "No Telecom Connection found for callId=$callId. Likely an outgoing call not initially handled by Telecom.")
         }
 
+        // If no more calls, do final cleanup
         if (activeCalls.isEmpty()) {
-            Log.d(TAG, "No active calls remaining. Stopping foreground service and releasing resources.")
-            stopForegroundService(context)
-            keepScreenAwake(context, false)
-            resetAudioMode(context)
-        } else {
-            Log.d(TAG, "Other calls still active. Foreground service remains.")
+            finalCleanup(context)
         }
 
         emitEvent(CallEventType.CALL_ENDED, JSONObject().put("callId", callId))
         notifyCallStateChanged(context)
     }
 
-    fun endAllCalls(context: Context) {
-        Log.d(TAG, "endAllCalls: Ending all active calls.")
-        if (activeCalls.isEmpty()) {
-            Log.d(TAG, "No active calls, nothing to do.")
-            return
-        }
-        activeCalls.keys.toList().forEach { callId ->
-            endCall(context, callId)
-        }
-        activeCalls.clear()
-        telecomConnections.clear()
-        currentCallId = null
-        cancelIncomingCallUI(context)
+    // SINGLE SOURCE OF TRUTH: Final cleanup when all calls are ended
+    private fun finalCleanup(context: Context) {
+        Log.d(TAG, "Performing final cleanup - no active calls remaining")
+
         stopForegroundService(context)
-        stopRingtone()
-        stopRingback()
         keepScreenAwake(context, false)
         resetAudioMode(context)
-        notifyCallStateChanged(context)
+
+        // FIXED: Clear lock screen bypass when calls end
+        clearLockScreenBypass(context)
+    }
+
+    // NEW: Function to clear lock screen bypass
+    private fun clearLockScreenBypass(context: Context) {
+        try {
+            if (context is Activity) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+                    context.setShowWhenLocked(false)
+                    context.setTurnScreenOn(false)
+                } else {
+                    context.window.clearFlags(
+                        android.view.WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+                        android.view.WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+                        android.view.WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
+                    )
+                }
+                Log.d(TAG, "Lock screen bypass flags cleared for Activity")
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not clear lock screen bypass flags: ${e.message}")
+        }
     }
 
     fun getActiveCalls(): List<CallInfo> = activeCalls.values.toList()
     fun getCurrentCallId(): String? = currentCallId
-    fun isCallActive(): Boolean = activeCalls.any { it.value.state == CallState.ACTIVE || it.value.state == CallState.INCOMING || it.value.state == CallState.DIALING }
-
-    // --- Notification/UI/Foreground ---
+    fun isCallActive(): Boolean = activeCalls.any {
+        it.value.state == CallState.ACTIVE ||
+        it.value.state == CallState.INCOMING ||
+        it.value.state == CallState.DIALING
+    }
 
+    // Enhanced incoming call UI with better cleanup
     fun showIncomingCallUI(context: Context, callId: String, callerName: String, callType: String) {
         Log.d(TAG, "Showing incoming call UI for $callId, caller: $callerName, callType: $callType")
         createNotificationChannel(context)
@@ -443,19 +496,22 @@ object CallEngine {
         val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
         launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
 
-        // The deprecated lock screen flags have been removed
-        // Lock screen bypass is now handled in the target activity (CallActivity, MainActivity)
+        // Handle lock screen bypass for active calls
         if (isCallActive()) {
-            Log.d(TAG, "App brought to foreground due to active call - lock screen handling in target activity")
+            // Only set lock screen bypass when bringing to foreground during active calls
+            launchIntent?.putExtra("BYPASS_LOCK_SCREEN", true)
+            Log.d(TAG, "App brought to foreground with lock screen bypass for active call")
         } else {
-            Log.d(TAG, "App brought to foreground via normal launchIntent")
+            Log.d(TAG, "App brought to foreground without lock screen bypass")
         }
 
         context.startActivity(launchIntent)
     }
 
-    // --- Audio Device Management ---
+    // Rest of the methods remain the same...
+    // (getAudioDevices, setAudioRoute, keepScreenAwake, etc. - keeping them unchanged for brevity)
 
+    // --- Audio Device Management ---
     fun getAudioDevices(): AudioRoutesInfo {
         audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
             Log.e(TAG, "getAudioDevices: AudioManager is null or appContext is not set. Returning default.")

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

@@ -15,24 +15,21 @@ class CallNotificationActionReceiver : BroadcastReceiver() {
 
         when (intent.action) {
             "com.qusaieilouti99.callmanager.ANSWER_CALL" -> {
-                Log.d(TAG, "Answer action received for callId: $callId. Answering call via Telecom.")
+                Log.d(TAG, "Answer action received for callId: $callId")
 
-                // Get the telecom connection and answer it
+                // FIXED: Use single source of truth for answering
                 val connection = CallEngine.getTelecomConnection(callId)
                 if (connection != null) {
-                    // This will trigger MyConnection.onAnswer() which handles the rest
-                    connection.onAnswer()
+                    connection.onAnswer() // This will trigger MyConnection.onAnswer()
                     Log.d(TAG, "Call answered via Telecom connection for callId: $callId")
                 } else {
-                    Log.e(TAG, "No Telecom connection found for callId: $callId. Falling back to direct answer.")
-                    // Fallback: answer directly via CallEngine
+                    Log.e(TAG, "No Telecom connection found for callId: $callId. Using direct answer.")
                     CallEngine.answerCall(context, callId)
                 }
-
-                CallEngine.bringAppToForeground(context)
+                // NOTE: Don't call bringAppToForeground here - it's handled in coreCallAnswered
             }
             "com.qusaieilouti99.callmanager.DECLINE_CALL" -> {
-                Log.d(TAG, "Decline action received for callId: $callId. Ending call.")
+                Log.d(TAG, "Decline action received for callId: $callId")
                 CallEngine.endCall(context, callId)
             }
             else -> {

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

@@ -32,9 +32,8 @@ class MyConnection(
             JSONObject(callDataJson).optString("callType", "Audio")
         } catch (e: Exception) { "Audio" }
 
-        // Set connection properties and capabilities
         connectionProperties = Connection.PROPERTY_SELF_MANAGED
-        connectionCapabilities = Connection.CAPABILITY_SUPPORT_HOLD or Connection.CAPABILITY_MUTE // Added hold and mute capabilities
+        connectionCapabilities = Connection.CAPABILITY_SUPPORT_HOLD or Connection.CAPABILITY_MUTE
 
         if (currentCallType == "Video") {
             Log.d(TAG, "MyConnection for callId $callId initialized as VIDEO call.")
@@ -51,8 +50,9 @@ class MyConnection(
     override fun onAnswer() {
         Log.d(TAG, "Call answered via Telecom for callId: $callId")
         setActive()
+
+        // FIXED: Use single source of truth for answering
         CallEngine.answerCall(context, callId)
-        CallEngine.bringAppToForeground(context)
     }
 
     override fun onReject() {
@@ -83,7 +83,7 @@ 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}, supportedRoutes=${state.supportedRouteMask}")
+        Log.d(TAG, "Audio state changed for callId: $callId. muted=${state.isMuted}, route=${state.route}")
 
         if (state.isMuted) {
             CallEngine.muteCall(context, callId)
@@ -98,7 +98,6 @@ class MyConnection(
             CallAudioState.ROUTE_WIRED_HEADSET -> "Headset"
             else -> "Unknown"
         }
-        Log.d(TAG, "CallAudioState changed, new route detected: $routeName")
         CallEngine.emitEvent(
             CallEventType.AUDIO_ROUTE_CHANGED,
             JSONObject().put("callId", callId).put("route", routeName)
@@ -108,9 +107,6 @@ class MyConnection(
     override fun onPlayDtmfTone(digit: Char) {
         super.onPlayDtmfTone(digit)
         Log.d(TAG, "Playing DTMF tone: $digit for callId: $callId")
-        // NOTE: DTMF_TONE is not in your current CallEventType enum.
-        // If you need to emit this event, you MUST add 'DTMF_TONE' to your CallEventType.ts
-        // and re-run nitro-codegen. For now, it's commented out to prevent compilation error.
         CallEngine.emitEvent(
             CallEventType.DTMF_TONE,
             JSONObject().put("callId", callId).put("digit", digit.toString())
@@ -122,12 +118,10 @@ class MyConnection(
         Log.d(TAG, "Stopping DTMF tone for callId: $callId")
     }
 
-    // REMOVED: onConnectionEvent override since it doesn't exist in the base Connection class
-    // If you need connection events, you can send them via sendConnectionEvent() method
-
     override fun onShowIncomingCallUi() {
         super.onShowIncomingCallUi()
-        Log.d(TAG, "onShowIncomingCallUi for callId: $callId. Attempting to bring app to foreground.")
-        CallEngine.bringAppToForeground(context)
+        Log.d(TAG, "onShowIncomingCallUi for callId: $callId")
+        // REMOVED: Don't bring app to foreground for incoming calls
+        // CallEngine.bringAppToForeground(context)
     }
 }

package/package.json

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