@qusaieilouti99/call-manager 0.1.57 → 0.1.58

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

@@ -1,6 +1,8 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
+import android.app.Activity
 import android.app.Application
+import android.app.Notification
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
@@ -14,6 +16,7 @@ import android.media.AudioDeviceInfo
 import android.media.AudioFocusRequest
 import android.media.AudioManager
 import android.media.MediaPlayer
+import android.media.RingtoneManager
 import android.net.Uri
 import android.os.Build
 import android.os.Bundle
@@ -28,9 +31,6 @@ import android.telecom.PhoneAccountHandle
 import android.telecom.TelecomManager
 import android.telecom.VideoProfile
 import android.util.Log
-import androidx.lifecycle.DefaultLifecycleObserver
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.ProcessLifecycleOwner
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -39,40 +39,39 @@ import org.json.JSONObject
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 
-object CallEngine : DefaultLifecycleObserver {
+object CallEngine {
     private const val TAG = "CallEngine"
     private const val PHONE_ACCOUNT_ID = "com.qusaieilouti99.callmanager.SELF_MANAGED"
     private const val NOTIF_CHANNEL_ID = "incoming_call_channel"
     private const val NOTIF_ID = 2001
+    private const val FOREGROUND_CHANNEL_ID = "call_foreground_channel"
+    private const val FOREGROUND_NOTIF_ID = 1001
 
-    // Core Context Management - Single Source of Truth
-    @Volatile
+    // Core context - initialized once and maintained
     private var appContext: Context? = null
-    private val isInitialized = AtomicBoolean(false)
+    private var isInitialized = AtomicBoolean(false)
 
-    // Audio Management
-    private var audioManager: AudioManager? = null
-    private var audioFocusRequest: AudioFocusRequest? = null
-    private var hasAudioFocus: Boolean = false
-    private var isSystemCallActive: Boolean = false
-    private var lastAudioRoutesInfo: AudioRoutesInfo? = null
-    private var lastMuteState: Boolean = false
-
-    // Media Management
+    // Audio & Media
     private var ringtone: android.media.Ringtone? = null
     private var ringbackPlayer: MediaPlayer? = null
-
-    // Power Management
+    private var audioManager: AudioManager? = null
     private var wakeLock: PowerManager.WakeLock? = null
+    private var audioFocusRequest: AudioFocusRequest? = null
 
-    // Call State Management - Single Source of Truth
+    // Call State Management
     private val activeCalls = ConcurrentHashMap<String, CallInfo>()
     private val telecomConnections = ConcurrentHashMap<String, Connection>()
     private val callMetadata = ConcurrentHashMap<String, String>()
+
     private var currentCallId: String? = null
     private var canMakeMultipleCalls: Boolean = false
 
-    // Lock Screen Management
+    // Audio State Tracking
+    private var lastAudioRoutesInfo: AudioRoutesInfo? = null
+    private var hasAudioFocus: Boolean = false
+    private var isSystemCallActive: Boolean = false
+
+    // Lock Screen Bypass
     private var lockScreenBypassActive = false
     private val lockScreenBypassCallbacks = mutableSetOf<LockScreenBypassCallback>()
 
@@ -80,93 +79,92 @@ object CallEngine : DefaultLifecycleObserver {
     private var eventHandler: ((CallEventType, String) -> Unit)? = null
     private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
 
-    // Service Management
-    private val serviceHandler = Handler(Looper.getMainLooper())
-    private var isServiceRunning = false
-
     interface LockScreenBypassCallback {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    /**
-     * MANDATORY: Initialize CallEngine with Application context
-     * This should be called from Application.onCreate() or MainApplication
-     */
-    fun initialize(application: Application) {
-        synchronized(this) {
-            if (isInitialized.get()) {
-                Log.d(TAG, "CallEngine already initialized")
-                return
-            }
-
-            appContext = application.applicationContext
+    // --- INITIALIZATION - Fix for context management ---
+    fun initialize(context: Context) {
+        if (isInitialized.compareAndSet(false, true)) {
+            appContext = context.applicationContext
             audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+            Log.d(TAG, "CallEngine initialized with context")
 
-            // Register lifecycle observer for proper cleanup
-            ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+            // Initialize foreground service if needed
+            if (isCallActive()) {
+                startForegroundService()
+            }
+        }
+    }
 
-            // Register audio device callback
-            registerAudioDeviceCallback()
+    fun isInitialized(): Boolean = isInitialized.get()
 
-            isInitialized.set(true)
-            Log.d(TAG, "CallEngine initialized successfully")
-        }
+    private fun requireContext(): Context {
+        return appContext ?: throw IllegalStateException("CallEngine not initialized. Call initialize() first.")
     }
 
-    override fun onDestroy(owner: LifecycleOwner) {
-        Log.d(TAG, "Application lifecycle onDestroy - cleaning up all calls")
-        cleanup()
+    // --- Event System ---
+    fun setEventHandler(handler: ((CallEventType, String) -> Unit)?) {
+        Log.d(TAG, "setEventHandler called. Handler present: ${handler != null}")
+        eventHandler = handler
+        handler?.let { h ->
+            if (cachedEvents.isNotEmpty()) {
+                Log.d(TAG, "Emitting ${cachedEvents.size} cached events.")
+                cachedEvents.forEach { (type, data) -> h.invoke(type, data) }
+                cachedEvents.clear()
+            }
+        }
     }
 
-    private fun ensureInitialized(): Context {
-        return appContext ?: throw IllegalStateException(
-            "CallEngine not initialized. Call CallEngine.initialize(application) from your Application.onCreate()"
-        )
+    private fun emitEvent(type: CallEventType, data: JSONObject) {
+        Log.d(TAG, "Emitting event: $type, data: $data")
+        val dataString = data.toString()
+        if (eventHandler != null) {
+            eventHandler?.invoke(type, dataString)
+        } else {
+            Log.d(TAG, "No event handler registered, caching event: $type")
+            cachedEvents.add(Pair(type, dataString))
+        }
     }
 
-    // --- Audio Focus Management (Improved) ---
+    // --- Audio Focus Management (Simplified) ---
     private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
         Log.d(TAG, "Audio focus changed: $focusChange")
         when (focusChange) {
-            AudioManager.AUDIOFOCUS_LOSS -> handleAudioFocusLoss()
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> handleAudioFocusLoss()
-            AudioManager.AUDIOFOCUS_GAIN -> handleAudioFocusGain()
-            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
-                Log.d(TAG, "Audio focus loss - can duck, not holding call")
+            AudioManager.AUDIOFOCUS_LOSS,
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                hasAudioFocus = false
+                isSystemCallActive = true
+                holdSystemCalls()
+            }
+            AudioManager.AUDIOFOCUS_GAIN -> {
+                hasAudioFocus = true
+                isSystemCallActive = false
+                Handler(Looper.getMainLooper()).postDelayed({
+                    resumeSystemHeldCalls()
+                }, 1000)
             }
         }
+        updateForegroundNotification()
     }
 
-    private fun handleAudioFocusLoss() {
-        Log.d(TAG, "Audio focus lost - likely system call active")
-        hasAudioFocus = false
-        isSystemCallActive = true
-
+    private fun holdSystemCalls() {
         activeCalls.values.filter { it.state == CallState.ACTIVE }.forEach { call ->
             if (!call.wasHeldBySystem) {
                 holdCallInternal(call.callId, heldBySystem = true)
             }
         }
-
         stopRingback()
-        updateForegroundNotification()
     }
 
-    private fun handleAudioFocusGain() {
-        Log.d(TAG, "Audio focus regained - system call likely ended")
-        hasAudioFocus = true
-        isSystemCallActive = false
-
-        serviceHandler.postDelayed({
-            activeCalls.values.filter { it.state == CallState.HELD && it.wasHeldBySystem }.forEach { call ->
-                unholdCallInternal(call.callId, resumedBySystem = true)
-            }
-            updateForegroundNotification()
-        }, 1000)
+    private fun resumeSystemHeldCalls() {
+        activeCalls.values.filter { it.state == CallState.HELD && it.wasHeldBySystem }.forEach { call ->
+            unholdCallInternal(call.callId, resumedBySystem = true)
+        }
     }
 
     private fun requestAudioFocus(): Boolean {
-        val context = ensureInitialized()
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
 
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -199,122 +197,78 @@ object CallEngine : DefaultLifecycleObserver {
     }
 
     private fun abandonAudioFocus() {
-        val context = appContext ?: return
-        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            audioFocusRequest?.let { request ->
-                audioManager?.abandonAudioFocusRequest(request)
+        audioManager?.let { am ->
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                audioFocusRequest?.let { request ->
+                    am.abandonAudioFocusRequest(request)
+                }
+            } else {
+                @Suppress("DEPRECATION")
+                am.abandonAudioFocus(audioFocusChangeListener)
             }
-        } else {
-            @Suppress("DEPRECATION")
-            audioManager?.abandonAudioFocus(audioFocusChangeListener)
         }
         hasAudioFocus = false
         Log.d(TAG, "Audio focus abandoned")
     }
 
-    // --- Event System ---
-    fun setEventHandler(handler: ((CallEventType, String) -> Unit)?) {
-        Log.d(TAG, "setEventHandler called. Handler present: ${handler != null}")
-        eventHandler = handler
-        handler?.let { h ->
-            if (cachedEvents.isNotEmpty()) {
-                Log.d(TAG, "Emitting ${cachedEvents.size} cached events.")
-                cachedEvents.forEach { (type, data) -> h.invoke(type, data) }
-                cachedEvents.clear()
-            }
-        }
+    // --- Lock Screen Bypass Management ---
+    fun registerLockScreenBypassCallback(callback: LockScreenBypassCallback) {
+        lockScreenBypassCallbacks.add(callback)
     }
 
-    fun emitEvent(type: CallEventType, data: JSONObject) {
-        Log.d(TAG, "Emitting event: $type, data: $data")
-        val dataString = data.toString()
-        if (eventHandler != null) {
-            eventHandler?.invoke(type, dataString)
-        } else {
-            Log.d(TAG, "No event handler registered, caching event: $type")
-            cachedEvents.add(Pair(type, dataString))
-        }
+    fun unregisterLockScreenBypassCallback(callback: LockScreenBypassCallback) {
+        lockScreenBypassCallbacks.remove(callback)
     }
 
-    // --- Service Management (Fixed) ---
-    private fun startForegroundService(context: Context) {
-        if (isServiceRunning) {
-            Log.d(TAG, "Foreground service already running, updating notification")
-            updateForegroundNotification()
-            return
-        }
-
-        Log.d(TAG, "Starting CallForegroundService.")
-        val currentCall = activeCalls.values.find {
-            it.state == CallState.ACTIVE || it.state == CallState.INCOMING ||
-            it.state == CallState.DIALING || it.state == CallState.HELD
-        }
-
-        val intent = Intent(context, CallForegroundService::class.java)
-        if (currentCall != null) {
-            intent.putExtra("callId", currentCall.callId)
-            intent.putExtra("callType", currentCall.callType)
-            intent.putExtra("displayName", currentCall.displayName)
-            intent.putExtra("state", currentCall.state.name)
-            Log.d(TAG, "Starting foreground service with call info: ${currentCall.callId}")
-        }
-
-        try {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(intent)
-            } else {
-                context.startService(intent)
+    private fun updateLockScreenBypass() {
+        val shouldBypass = isCallActive()
+        if (lockScreenBypassActive != shouldBypass) {
+            lockScreenBypassActive = shouldBypass
+            Log.d(TAG, "Lock screen bypass state changed: $lockScreenBypassActive")
+            lockScreenBypassCallbacks.forEach { callback ->
+                try {
+                    callback.onLockScreenBypassChanged(shouldBypass)
+                } catch (e: Exception) {
+                    Log.w(TAG, "Error notifying lock screen bypass callback", e)
+                }
             }
-            isServiceRunning = true
-            Log.d(TAG, "Foreground service started successfully")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to start foreground service: ${e.message}", e)
         }
     }
 
-    private fun stopForegroundService(context: Context) {
-        if (!isServiceRunning) {
-            Log.d(TAG, "Foreground service not running")
-            return
-        }
+    fun isLockScreenBypassActive(): Boolean = lockScreenBypassActive
 
-        Log.d(TAG, "Stopping CallForegroundService.")
-        val intent = Intent(context, CallForegroundService::class.java)
-        context.stopService(intent)
-        isServiceRunning = false
+    // --- Telecom Connection Management ---
+    fun addTelecomConnection(callId: String, connection: Connection) {
+        telecomConnections[callId] = connection
+        Log.d(TAG, "Added Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
     }
 
-    private fun updateForegroundNotification() {
-        val context = appContext ?: return
-        if (!isServiceRunning) return
+    fun removeTelecomConnection(callId: String) {
+        telecomConnections.remove(callId)?.let {
+            Log.d(TAG, "Removed Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
+        }
+    }
 
-        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
-        val heldCall = activeCalls.values.find { it.state == CallState.HELD }
+    fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
 
-        val callToShow = activeCall ?: heldCall
-        callToShow?.let {
-            val intent = Intent(context, CallForegroundService::class.java)
-            intent.putExtra("UPDATE_NOTIFICATION", true)
-            intent.putExtra("callId", it.callId)
-            intent.putExtra("callType", it.callType)
-            intent.putExtra("displayName", it.displayName)
-            intent.putExtra("state", it.state.name)
+    // --- Public API ---
+    fun setCanMakeMultipleCalls(allow: Boolean) {
+        canMakeMultipleCalls = allow
+        Log.d(TAG, "canMakeMultipleCalls set to: $allow")
+    }
 
-            try {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    context.startForegroundService(intent)
-                } else {
-                    context.startService(intent)
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to update foreground notification: ${e.message}", e)
-            }
+    fun getCurrentCallState(): String {
+        val calls = getActiveCalls()
+        val jsonArray = JSONArray()
+        calls.forEach {
+            jsonArray.put(it.toJsonObject())
         }
+        val result = jsonArray.toString()
+        Log.d(TAG, "Current call state: $result")
+        return result
     }
 
-    // --- Call Management (Fixed Context Issues) ---
+    // --- Incoming Call Management ---
     fun reportIncomingCall(
         context: Context,
         callId: String,
@@ -323,7 +277,10 @@ object CallEngine : DefaultLifecycleObserver {
         pictureUrl: String? = null,
         metadata: String? = null
     ) {
-        ensureInitialized()
+        if (!isInitialized.get()) {
+            initialize(context)
+        }
+
         Log.d(TAG, "reportIncomingCall: callId=$callId, type=$callType, name=$displayName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -357,14 +314,11 @@ object CallEngine : DefaultLifecycleObserver {
         currentCallId = callId
         Log.d(TAG, "Call $callId added to activeCalls. State: INCOMING, callType: $callType")
 
-        // Start foreground service FIRST
-        startForegroundService(context)
+        showIncomingCallUI(callId, displayName, callType)
+        registerPhoneAccount()
 
-        showIncomingCallUI(context, callId, displayName, callType)
-        registerPhoneAccount(context)
-
-        val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle(context)
+        val telecomManager = requireContext().getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+        val phoneAccountHandle = getPhoneAccountHandle()
         val extras = Bundle().apply {
             putString(MyConnectionService.EXTRA_CALL_ID, callId)
             putString(MyConnectionService.EXTRA_CALL_TYPE, callType)
@@ -375,6 +329,7 @@ object CallEngine : DefaultLifecycleObserver {
 
         try {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
+            startForegroundService() // Fixed: Always start foreground service
             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)
@@ -387,14 +342,14 @@ object CallEngine : DefaultLifecycleObserver {
         updateLockScreenBypass()
     }
 
+    // --- Outgoing Call Management ---
     fun startOutgoingCall(
-        context: Context,
         callId: String,
         callType: String,
         targetName: String,
         metadata: String? = null
     ) {
-        ensureInitialized()
+        val context = requireContext()
         Log.d(TAG, "startOutgoingCall: callId=$callId, type=$callType, target=$targetName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -422,12 +377,9 @@ object CallEngine : DefaultLifecycleObserver {
         currentCallId = callId
         Log.d(TAG, "Call $callId added to activeCalls. State: DIALING, callType: $callType")
 
-        // Start foreground service FIRST
-        startForegroundService(context)
-
-        registerPhoneAccount(context)
+        registerPhoneAccount()
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle(context)
+        val phoneAccountHandle = getPhoneAccountHandle()
         val addressUri = Uri.fromParts(PhoneAccount.SCHEME_TEL, targetName, null)
 
         val extras = Bundle().apply {
@@ -441,13 +393,13 @@ object CallEngine : DefaultLifecycleObserver {
 
         try {
             telecomManager.placeCall(addressUri, extras)
-            Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
-
+            startForegroundService() // Fixed: Always start foreground service
             requestAudioFocus()
             startRingback()
-            bringAppToForeground(context)
-            keepScreenAwake(context, true)
-            setInitialAudioRoute(context, callType)
+            bringAppToForeground()
+            keepScreenAwake(true)
+            setInitialAudioRoute(callType)
+            Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
         } catch (e: SecurityException) {
             Log.e(TAG, "SecurityException: Failed to start outgoing call via placeCall. Check MANAGE_OWN_CALLS permission: ${e.message}", e)
             endCallInternal(callId)
@@ -459,15 +411,14 @@ object CallEngine : DefaultLifecycleObserver {
         updateLockScreenBypass()
     }
 
-    // Fixed: startCall now properly initializes context and starts foreground service
+    // Fixed: Start call as active (not dialing) with foreground service
     fun startCall(
-        context: Context,
         callId: String,
         callType: String,
         targetName: String,
         metadata: String? = null
     ) {
-        ensureInitialized()
+        val context = requireContext()
         Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -490,34 +441,31 @@ object CallEngine : DefaultLifecycleObserver {
         currentCallId = callId
         Log.d(TAG, "Call $callId started as ACTIVE, callType: $callType")
 
-        // Start foreground service FIRST
-        startForegroundService(context)
-
-        registerPhoneAccount(context)
+        registerPhoneAccount()
         requestAudioFocus()
-        bringAppToForeground(context)
-        keepScreenAwake(context, true)
-        setInitialAudioRoute(context, callType)
+        bringAppToForeground()
+        startForegroundService() // Fixed: Start foreground service for JS-initiated calls
+        keepScreenAwake(true)
+        setInitialAudioRoute(callType)
         updateLockScreenBypass()
 
         // Emit call answered event with metadata
         emitCallAnsweredWithMetadata(callId)
     }
 
-    // Fixed: Context management for all operations
-    fun callAnsweredFromJS(context: Context, callId: String) {
-        ensureInitialized()
+    // --- Call Answer Management ---
+    fun callAnsweredFromJS(callId: String) {
         Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
-        coreCallAnswered(context, callId, isLocalAnswer = false)
+        coreCallAnswered(callId, isLocalAnswer = false)
     }
 
-    fun answerCall(context: Context, callId: String) {
-        ensureInitialized()
+    fun answerCall(callId: String) {
         Log.d(TAG, "answerCall: $callId - local party answering")
-        coreCallAnswered(context, callId, isLocalAnswer = true)
+        coreCallAnswered(callId, isLocalAnswer = true)
     }
 
-    private fun coreCallAnswered(context: Context, callId: String, isLocalAnswer: Boolean) {
+    private fun coreCallAnswered(callId: String, isLocalAnswer: Boolean) {
+        val context = requireContext()
         Log.d(TAG, "coreCallAnswered: $callId, isLocalAnswer: $isLocalAnswer")
 
         val callInfo = activeCalls[callId]
@@ -528,7 +476,7 @@ object CallEngine : DefaultLifecycleObserver {
 
         stopRingtone()
         stopRingback()
-        cancelIncomingCallUI(context)
+        cancelIncomingCallUI()
         requestAudioFocus()
 
         activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
@@ -542,10 +490,10 @@ object CallEngine : DefaultLifecycleObserver {
             }
         }
 
-        bringAppToForeground(context)
-        startForegroundService(context)
-        keepScreenAwake(context, true)
-        resetAudioMode(context)
+        bringAppToForeground()
+        startForegroundService() // Fixed: Ensure foreground service is running
+        keepScreenAwake(true)
+        resetAudioMode()
         updateLockScreenBypass()
         updateForegroundNotification()
 
@@ -575,13 +523,12 @@ object CallEngine : DefaultLifecycleObserver {
         })
     }
 
-    fun holdCall(context: Context, callId: String) {
-        ensureInitialized()
+    // --- Call Control Methods ---
+    fun holdCall(callId: String) {
         holdCallInternal(callId, heldBySystem = false)
     }
 
-    fun setOnHold(context: Context, callId: String, onHold: Boolean) {
-        ensureInitialized()
+    fun setOnHold(callId: String, onHold: Boolean) {
         Log.d(TAG, "setOnHold: $callId, onHold: $onHold")
 
         val callInfo = activeCalls[callId]
@@ -622,8 +569,7 @@ object CallEngine : DefaultLifecycleObserver {
         updateLockScreenBypass()
     }
 
-    fun unholdCall(context: Context, callId: String) {
-        ensureInitialized()
+    fun unholdCall(callId: String) {
         unholdCallInternal(callId, resumedBySystem = false)
     }
 
@@ -635,18 +581,10 @@ object CallEngine : DefaultLifecycleObserver {
             return
         }
 
-        // Fixed: Don't emit UNHOLD_FAILED for system-held calls or when we have focus
-        if (!hasAudioFocus && !resumedBySystem) {
-            Log.d(TAG, "Attempting to request audio focus for unhold")
-            if (!requestAudioFocus()) {
-                Log.w(TAG, "Failed to get audio focus for unhold")
-                // Only emit UNHOLD_FAILED for user-initiated unhold attempts
-                emitEvent(CallEventType.CALL_UNHOLD_FAILED, JSONObject().apply {
-                    put("callId", callId)
-                    put("reason", "Could not obtain audio focus")
-                })
-                return
-            }
+        // 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
         }
 
         activeCalls[callId] = callInfo.copy(
@@ -664,23 +602,21 @@ object CallEngine : DefaultLifecycleObserver {
         Log.d(TAG, "Call $callId successfully unheld")
     }
 
-    fun muteCall(context: Context, callId: String) {
-        ensureInitialized()
-        setMutedInternal(context, callId, true)
+    fun muteCall(callId: String) {
+        setMutedInternal(callId, true)
     }
 
-    fun unmuteCall(context: Context, callId: String) {
-        ensureInitialized()
-        setMutedInternal(context, callId, false)
+    fun unmuteCall(callId: String) {
+        setMutedInternal(callId, false)
     }
 
-    fun setMuted(context: Context, callId: String, muted: Boolean) {
-        ensureInitialized()
+    fun setMuted(callId: String, muted: Boolean) {
         Log.d(TAG, "setMuted: $callId, muted: $muted")
-        setMutedInternal(context, callId, muted)
+        setMutedInternal(callId, muted)
     }
 
-    private fun setMutedInternal(context: Context, callId: String, muted: Boolean) {
+    private fun setMutedInternal(callId: String, muted: Boolean) {
+        val context = requireContext()
         val callInfo = activeCalls[callId]
         if (callInfo == null) {
             Log.w(TAG, "Cannot set mute state for call $callId - not found in active calls")
@@ -693,21 +629,19 @@ object CallEngine : DefaultLifecycleObserver {
         audioManager?.isMicrophoneMute = muted
 
         if (wasMuted != muted) {
-            lastMuteState = muted
             val eventType = if (muted) CallEventType.CALL_MUTED else CallEventType.CALL_UNMUTED
             emitEvent(eventType, JSONObject().put("callId", callId))
             Log.d(TAG, "Call $callId mute state changed to: $muted")
         }
     }
 
-    fun endCall(context: Context, callId: String) {
-        ensureInitialized()
+    // --- Call End Management ---
+    fun endCall(callId: String) {
         Log.d(TAG, "endCall: $callId")
         endCallInternal(callId)
     }
 
-    fun endAllCalls(context: Context) {
-        ensureInitialized()
+    fun endAllCalls() {
         Log.d(TAG, "endAllCalls: Ending all active calls.")
         if (activeCalls.isEmpty()) {
             Log.d(TAG, "No active calls, nothing to do.")
@@ -723,7 +657,7 @@ object CallEngine : DefaultLifecycleObserver {
         callMetadata.clear()
         currentCallId = null
 
-        finalCleanup(context)
+        finalCleanup()
         updateLockScreenBypass()
     }
 
@@ -744,7 +678,7 @@ object CallEngine : DefaultLifecycleObserver {
 
         stopRingback()
         stopRingtone()
-        appContext?.let { cancelIncomingCallUI(it) }
+        cancelIncomingCallUI()
 
         if (currentCallId == callId) {
             currentCallId = activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
@@ -760,7 +694,7 @@ object CallEngine : DefaultLifecycleObserver {
         }
 
         if (activeCalls.isEmpty()) {
-            appContext?.let { finalCleanup(it) }
+            finalCleanup()
         } else {
             updateForegroundNotification()
         }
@@ -781,17 +715,9 @@ object CallEngine : DefaultLifecycleObserver {
         })
     }
 
-    private fun finalCleanup(context: Context) {
-        Log.d(TAG, "Performing final cleanup - no active calls remaining")
-        stopForegroundService(context)
-        keepScreenAwake(context, false)
-        resetAudioMode(context)
-        isSystemCallActive = false
-    }
-
     // --- Audio Management ---
     fun getAudioDevices(): AudioRoutesInfo {
-        val context = ensureInitialized()
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
             Log.e(TAG, "getAudioDevices: AudioManager is null. Returning default.")
             return AudioRoutesInfo(emptyArray(), "Unknown")
@@ -834,8 +760,8 @@ object CallEngine : DefaultLifecycleObserver {
         return result
     }
 
-    fun setAudioRoute(context: Context, route: String) {
-        ensureInitialized()
+    fun setAudioRoute(route: String) {
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         Log.d(TAG, "Attempting to set audio route to: $route. Current mode: ${audioManager?.mode}")
 
@@ -886,7 +812,7 @@ object CallEngine : DefaultLifecycleObserver {
         }
     }
 
-    private fun setInitialAudioRoute(context: Context, callType: String) {
+    private fun setInitialAudioRoute(callType: String) {
         val availableDevices = getAudioDevices()
 
         val defaultRoute = when {
@@ -897,10 +823,11 @@ object CallEngine : DefaultLifecycleObserver {
         }
 
         Log.d(TAG, "Setting initial audio route for $callType call: $defaultRoute")
-        setAudioRoute(context, defaultRoute)
+        setAudioRoute(defaultRoute)
     }
 
-    fun resetAudioMode(context: Context) {
+    private fun resetAudioMode() {
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         if (activeCalls.isEmpty()) {
             Log.d(TAG, "Resetting audio mode to NORMAL as no active calls remain.")
@@ -927,15 +854,15 @@ object CallEngine : DefaultLifecycleObserver {
         }
     }
 
-    private fun registerAudioDeviceCallback() {
-        val context = appContext ?: return
+    fun registerAudioDeviceCallback() {
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         audioManager?.registerAudioDeviceCallback(audioDeviceCallback, null)
         Log.d(TAG, "Audio device callback registered.")
     }
 
-    private fun unregisterAudioDeviceCallback() {
-        val context = appContext ?: return
+    fun unregisterAudioDeviceCallback() {
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
         Log.d(TAG, "Audio device callback unregistered.")
@@ -958,7 +885,8 @@ object CallEngine : DefaultLifecycleObserver {
     }
 
     // --- Screen Management ---
-    fun keepScreenAwake(context: Context, keepAwake: Boolean) {
+    fun keepScreenAwake(keepAwake: Boolean) {
+        val context = requireContext()
         val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
         if (keepAwake) {
             if (wakeLock == null || !wakeLock!!.isHeld) {
@@ -1014,65 +942,9 @@ object CallEngine : DefaultLifecycleObserver {
         })
     }
 
-    // --- Lock Screen Bypass Management ---
-    fun registerLockScreenBypassCallback(callback: LockScreenBypassCallback) {
-        lockScreenBypassCallbacks.add(callback)
-    }
-
-    fun unregisterLockScreenBypassCallback(callback: LockScreenBypassCallback) {
-        lockScreenBypassCallbacks.remove(callback)
-    }
-
-    private fun updateLockScreenBypass() {
-        val shouldBypass = isCallActive()
-        if (lockScreenBypassActive != shouldBypass) {
-            lockScreenBypassActive = shouldBypass
-            Log.d(TAG, "Lock screen bypass state changed: $lockScreenBypassActive")
-            lockScreenBypassCallbacks.forEach { callback ->
-                try {
-                    callback.onLockScreenBypassChanged(shouldBypass)
-                } catch (e: Exception) {
-                    Log.w(TAG, "Error notifying lock screen bypass callback", e)
-                }
-            }
-        }
-    }
-
-    fun isLockScreenBypassActive(): Boolean = lockScreenBypassActive
-
-    // --- Telecom Connection Management ---
-    fun addTelecomConnection(callId: String, connection: Connection) {
-        telecomConnections[callId] = connection
-        Log.d(TAG, "Added Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
-    }
-
-    fun removeTelecomConnection(callId: String) {
-        telecomConnections.remove(callId)?.let {
-            Log.d(TAG, "Removed Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
-        }
-    }
-
-    fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
-
-    // --- Public API ---
-    fun setCanMakeMultipleCalls(allow: Boolean) {
-        canMakeMultipleCalls = allow
-        Log.d(TAG, "canMakeMultipleCalls set to: $allow")
-    }
-
-    fun getCurrentCallState(): String {
-        val calls = getActiveCalls()
-        val jsonArray = JSONArray()
-        calls.forEach {
-            jsonArray.put(it.toJsonObject())
-        }
-        val result = jsonArray.toString()
-        Log.d(TAG, "Current call state: $result")
-        return result
-    }
-
     // --- Notification Management ---
-    private fun createNotificationChannel(context: Context) {
+    private fun createNotificationChannel() {
+        val context = requireContext()
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val channel = NotificationChannel(
                 NOTIF_CHANNEL_ID,
@@ -1086,7 +958,7 @@ object CallEngine : DefaultLifecycleObserver {
 
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
                 channel.setSound(
-                    android.media.RingtoneManager.getDefaultUri(android.media.RingtoneManager.TYPE_RINGTONE),
+                    RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE),
                     AudioAttributes.Builder()
                         .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
                         .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
@@ -1103,9 +975,10 @@ object CallEngine : DefaultLifecycleObserver {
         }
     }
 
-    fun showIncomingCallUI(context: Context, callId: String, callerName: String, callType: String) {
+    private fun showIncomingCallUI(callId: String, callerName: String, callType: String) {
+        val context = requireContext()
         Log.d(TAG, "Showing incoming call UI for $callId, caller: $callerName, callType: $callType")
-        createNotificationChannel(context)
+        createNotificationChannel()
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
         val answerIntent = Intent(context, CallNotificationActionReceiver::class.java).apply {
@@ -1139,20 +1012,20 @@ object CallEngine : DefaultLifecycleObserver {
 
         val notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             val person = android.app.Person.Builder().setName(callerName).setImportant(true).build()
-            android.app.Notification.Builder(context, NOTIF_CHANNEL_ID)
+            Notification.Builder(context, NOTIF_CHANNEL_ID)
                 .setSmallIcon(android.R.drawable.sym_call_incoming)
-                .setStyle(android.app.Notification.CallStyle.forIncomingCall(person, declinePendingIntent, answerPendingIntent))
+                .setStyle(Notification.CallStyle.forIncomingCall(person, declinePendingIntent, answerPendingIntent))
                 .setFullScreenIntent(fullScreenPendingIntent, true)
                 .setOngoing(true)
                 .setAutoCancel(false)
                 .build()
         } else {
-            android.app.Notification.Builder(context, NOTIF_CHANNEL_ID)
+            Notification.Builder(context, NOTIF_CHANNEL_ID)
                 .setSmallIcon(android.R.drawable.sym_call_incoming)
                 .setContentTitle("Incoming Call")
                 .setContentText(callerName)
-                .setPriority(android.app.Notification.PRIORITY_HIGH)
-                .setCategory(android.app.Notification.CATEGORY_CALL)
+                .setPriority(Notification.PRIORITY_HIGH)
+                .setCategory(Notification.CATEGORY_CALL)
                 .setFullScreenIntent(fullScreenPendingIntent, true)
                 .addAction(android.R.drawable.sym_action_call, "Answer", answerPendingIntent)
                 .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Decline", declinePendingIntent)
@@ -1164,20 +1037,56 @@ object CallEngine : DefaultLifecycleObserver {
         notificationManager.notify(NOTIF_ID, notification)
 
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
-            playRingtone(context)
+            playRingtone()
         }
 
-        setInitialAudioRoute(context, callType)
+        setInitialAudioRoute(callType)
     }
 
-    fun cancelIncomingCallUI(context: Context) {
+    private fun cancelIncomingCallUI() {
+        val context = requireContext()
         Log.d(TAG, "Cancelling incoming call UI.")
         val notificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         notificationManager.cancel(NOTIF_ID)
         stopRingtone()
     }
 
-    fun bringAppToForeground(context: Context) {
+    // --- Service Management ---
+    private fun startForegroundService() {
+        val context = requireContext()
+        Log.d(TAG, "Starting CallForegroundService.")
+
+        val currentCall = activeCalls.values.find {
+            it.state == CallState.ACTIVE || it.state == CallState.INCOMING ||
+            it.state == CallState.DIALING || it.state == CallState.HELD
+        }
+
+        val intent = Intent(context, CallForegroundService::class.java)
+
+        if (currentCall != null) {
+            intent.putExtra("callId", currentCall.callId)
+            intent.putExtra("callType", currentCall.callType)
+            intent.putExtra("displayName", currentCall.displayName)
+            intent.putExtra("state", currentCall.state.name)
+            Log.d(TAG, "Starting foreground service with call info: ${currentCall.callId}")
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent)
+        } else {
+            context.startService(intent)
+        }
+    }
+
+    private fun stopForegroundService() {
+        val context = requireContext()
+        Log.d(TAG, "Stopping CallForegroundService.")
+        val intent = Intent(context, CallForegroundService::class.java)
+        context.stopService(intent)
+    }
+
+    private fun bringAppToForeground() {
+        val context = requireContext()
         val packageName = context.packageName
         val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
         launchIntent?.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
@@ -1193,7 +1102,7 @@ object CallEngine : DefaultLifecycleObserver {
 
         try {
             context.startActivity(launchIntent)
-            serviceHandler.postDelayed({
+            Handler(Looper.getMainLooper()).postDelayed({
                 updateLockScreenBypass()
             }, 100)
         } catch (e: Exception) {
@@ -1202,9 +1111,10 @@ object CallEngine : DefaultLifecycleObserver {
     }
 
     // --- Phone Account Management ---
-    private fun registerPhoneAccount(context: Context) {
+    private fun registerPhoneAccount() {
+        val context = requireContext()
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-        val phoneAccountHandle = getPhoneAccountHandle(context)
+        val phoneAccountHandle = getPhoneAccountHandle()
 
         if (telecomManager.getPhoneAccount(phoneAccountHandle) == null) {
             val phoneAccount = PhoneAccount.builder(phoneAccountHandle, "PingMe Call")
@@ -1224,7 +1134,8 @@ object CallEngine : DefaultLifecycleObserver {
         }
     }
 
-    private fun getPhoneAccountHandle(context: Context): PhoneAccountHandle {
+    private fun getPhoneAccountHandle(): PhoneAccountHandle {
+        val context = requireContext()
         return PhoneAccountHandle(
             ComponentName(context, MyConnectionService::class.java),
             PHONE_ACCOUNT_ID
@@ -1232,7 +1143,8 @@ object CallEngine : DefaultLifecycleObserver {
     }
 
     // --- Media Management ---
-    fun playRingtone(context: Context) {
+    private fun playRingtone() {
+        val context = requireContext()
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             Log.d(TAG, "playRingtone: Android S+ detected, system will handle ringtone via Telecom.")
             return
@@ -1240,8 +1152,8 @@ object CallEngine : DefaultLifecycleObserver {
 
         try {
             Log.d(TAG, "Playing ringtone (for Android < S).")
-            val uri = android.media.RingtoneManager.getDefaultUri(android.media.RingtoneManager.TYPE_RINGTONE)
-            ringtone = android.media.RingtoneManager.getRingtone(context, uri)
+            val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+            ringtone = RingtoneManager.getRingtone(context, uri)
             ringtone?.audioAttributes = AudioAttributes.Builder()
                 .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
                 .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
@@ -1252,7 +1164,7 @@ object CallEngine : DefaultLifecycleObserver {
         }
     }
 
-    fun stopRingtone() {
+    private fun stopRingtone() {
         try {
             if (ringtone?.isPlaying == true) {
                 ringtone?.stop()
@@ -1265,14 +1177,15 @@ object CallEngine : DefaultLifecycleObserver {
     }
 
     private fun startRingback() {
+        val context = requireContext()
         if (ringbackPlayer?.isPlaying == true) {
             Log.d(TAG, "Ringback tone already playing.")
             return
         }
 
         try {
-            val ringbackUri = Uri.parse("android.resource://${appContext?.packageName}/raw/ringback_tone")
-            ringbackPlayer = MediaPlayer.create(appContext, ringbackUri)
+            val ringbackUri = Uri.parse("android.resource://${context.packageName}/raw/ringback_tone")
+            ringbackPlayer = MediaPlayer.create(context, ringbackUri)
             if (ringbackPlayer == null) {
                 Log.e(TAG, "Failed to create MediaPlayer for ringback. Check raw/ringback_tone.mp3 exists.")
                 return
@@ -1308,48 +1221,63 @@ object CallEngine : DefaultLifecycleObserver {
         }
     }
 
-    // --- Cleanup ---
-    private fun cleanup() {
-        Log.d(TAG, "Cleaning up CallEngine")
+    private fun updateForegroundNotification() {
+        val context = requireContext()
+        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
+        val heldCall = activeCalls.values.find { it.state == CallState.HELD }
+
+        val callToShow = activeCall ?: heldCall
+        callToShow?.let {
+            val intent = Intent(context, CallForegroundService::class.java)
+            intent.putExtra("UPDATE_NOTIFICATION", true)
+            intent.putExtra("callId", it.callId)
+            intent.putExtra("callType", it.callType)
+            intent.putExtra("displayName", it.displayName)
+            intent.putExtra("state", it.state.name)
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+    }
+
+    private fun finalCleanup() {
+        Log.d(TAG, "Performing final cleanup - no active calls remaining")
+        stopForegroundService()
+        keepScreenAwake(false)
+        resetAudioMode()
+        isSystemCallActive = false
+    }
+
+    // --- Lifecycle Management ---
+    fun onApplicationTerminate() {
+        Log.d(TAG, "Application terminating - cleaning up all calls")
 
-        // End all calls
+        // End all calls properly
         activeCalls.keys.toList().forEach { callId ->
-            endCallInternal(callId)
+            val connection = telecomConnections[callId]
+            connection?.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+            connection?.destroy()
         }
 
-        // Clear all collections
+        // Clear all state
         activeCalls.clear()
         telecomConnections.clear()
         callMetadata.clear()
-        lockScreenBypassCallbacks.clear()
-        cachedEvents.clear()
-
-        // Stop media
-        stopRingtone()
-        stopRingback()
+        currentCallId = null
 
         // Release resources
-        wakeLock?.let {
-            if (it.isHeld) it.release()
-        }
-        wakeLock = null
-
-        // Audio cleanup
-        abandonAudioFocus()
-        appContext?.let {
-            resetAudioMode(it)
-            unregisterAudioDeviceCallback()
-        }
+        finalCleanup()
 
-        // Service cleanup
-        appContext?.let { stopForegroundService(it) }
-
-        currentCallId = null
-        lockScreenBypassActive = false
-        hasAudioFocus = false
-        isSystemCallActive = false
-        isServiceRunning = false
+        // Clear callbacks
+        lockScreenBypassCallbacks.clear()
+        eventHandler = null
+        cachedEvents.clear()
 
-        Log.d(TAG, "CallEngine cleanup completed")
+        // Reset initialization
+        isInitialized.set(false)
+        appContext = null
     }
 }