@qusaieilouti99/call-manager 0.1.56 → 0.1.57

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

@@ -1,7 +1,6 @@
 package com.margelo.nitro.qusaieilouti99.callmanager
 
-import android.app.Activity
-import android.app.Notification
+import android.app.Application
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.PendingIntent
@@ -15,7 +14,6 @@ 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
@@ -30,6 +28,9 @@ 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
@@ -38,39 +39,40 @@ import org.json.JSONObject
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 
-object CallEngine {
+object CallEngine : DefaultLifecycleObserver {
     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
 
-    // Audio & Media
+    // Core Context Management - Single Source of Truth
+    @Volatile
+    private var appContext: Context? = null
+    private val 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
     private var ringtone: android.media.Ringtone? = null
     private var ringbackPlayer: MediaPlayer? = null
-    private var audioManager: AudioManager? = null
+
+    // Power Management
     private var wakeLock: PowerManager.WakeLock? = null
-    private var appContext: Context? = null
-    private var audioFocusRequest: AudioFocusRequest? = null
 
-    // Call State Management - Only what native needs
+    // Call State Management - Single Source of Truth
     private val activeCalls = ConcurrentHashMap<String, CallInfo>()
     private val telecomConnections = ConcurrentHashMap<String, Connection>()
-
-    // Separate opaque metadata storage - native doesn't interpret
     private val callMetadata = ConcurrentHashMap<String, String>()
-
     private var currentCallId: String? = null
     private var canMakeMultipleCalls: Boolean = false
 
-    // Audio State Tracking
-    private var lastAudioRoutesInfo: AudioRoutesInfo? = null
-    private var lastMuteState: Boolean = false
-    private var hasAudioFocus: Boolean = false
-    private var isSystemCallActive: Boolean = false
-
-    // Lock Screen Bypass
+    // Lock Screen Management
     private var lockScreenBypassActive = false
     private val lockScreenBypassCallbacks = mutableSetOf<LockScreenBypassCallback>()
 
@@ -78,14 +80,51 @@ object CallEngine {
     private var eventHandler: ((CallEventType, String) -> Unit)? = null
     private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
 
-    // Operation State
-    private val operationInProgress = AtomicBoolean(false)
+    // Service Management
+    private val serviceHandler = Handler(Looper.getMainLooper())
+    private var isServiceRunning = false
 
     interface LockScreenBypassCallback {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    // --- Audio Focus Management ---
+    /**
+     * 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
+            audioManager = appContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+
+            // Register lifecycle observer for proper cleanup
+            ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+
+            // Register audio device callback
+            registerAudioDeviceCallback()
+
+            isInitialized.set(true)
+            Log.d(TAG, "CallEngine initialized successfully")
+        }
+    }
+
+    override fun onDestroy(owner: LifecycleOwner) {
+        Log.d(TAG, "Application lifecycle onDestroy - cleaning up all calls")
+        cleanup()
+    }
+
+    private fun ensureInitialized(): Context {
+        return appContext ?: throw IllegalStateException(
+            "CallEngine not initialized. Call CallEngine.initialize(application) from your Application.onCreate()"
+        )
+    }
+
+    // --- Audio Focus Management (Improved) ---
     private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
         Log.d(TAG, "Audio focus changed: $focusChange")
         when (focusChange) {
@@ -118,7 +157,7 @@ object CallEngine {
         hasAudioFocus = true
         isSystemCallActive = false
 
-        Handler(Looper.getMainLooper()).postDelayed({
+        serviceHandler.postDelayed({
             activeCalls.values.filter { it.state == CallState.HELD && it.wasHeldBySystem }.forEach { call ->
                 unholdCallInternal(call.callId, resumedBySystem = true)
             }
@@ -127,7 +166,7 @@ object CallEngine {
     }
 
     private fun requestAudioFocus(): Boolean {
-        val context = appContext ?: return false
+        val context = ensureInitialized()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
 
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -161,7 +200,7 @@ object CallEngine {
 
     private fun abandonAudioFocus() {
         val context = appContext ?: return
-        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+        audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             audioFocusRequest?.let { request ->
@@ -199,66 +238,83 @@ object CallEngine {
         }
     }
 
-    // --- Lock Screen Bypass Management ---
-    fun registerLockScreenBypassCallback(callback: LockScreenBypassCallback) {
-        lockScreenBypassCallbacks.add(callback)
-    }
-
-    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
+        }
 
-    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)
-                }
-            }
+        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
         }
-    }
 
-    fun isLockScreenBypassActive(): Boolean = lockScreenBypassActive
+        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}")
+        }
 
-    // --- Telecom Connection Management ---
-    fun addTelecomConnection(callId: String, connection: Connection) {
-        telecomConnections[callId] = connection
-        Log.d(TAG, "Added Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+            isServiceRunning = true
+            Log.d(TAG, "Foreground service started successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to start foreground service: ${e.message}", e)
+        }
     }
 
-    fun removeTelecomConnection(callId: String) {
-        telecomConnections.remove(callId)?.let {
-            Log.d(TAG, "Removed Telecom Connection for callId: $callId. Total: ${telecomConnections.size}")
+    private fun stopForegroundService(context: Context) {
+        if (!isServiceRunning) {
+            Log.d(TAG, "Foreground service not running")
+            return
         }
+
+        Log.d(TAG, "Stopping CallForegroundService.")
+        val intent = Intent(context, CallForegroundService::class.java)
+        context.stopService(intent)
+        isServiceRunning = false
     }
 
-    fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
+    private fun updateForegroundNotification() {
+        val context = appContext ?: return
+        if (!isServiceRunning) return
 
-    fun getAppContext(): Context? = appContext
+        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
+        val heldCall = activeCalls.values.find { it.state == CallState.HELD }
 
-    // --- Public API ---
-    fun setCanMakeMultipleCalls(allow: Boolean) {
-        canMakeMultipleCalls = allow
-        Log.d(TAG, "canMakeMultipleCalls set to: $allow")
-    }
+        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)
 
-    fun getCurrentCallState(): String {
-        val calls = getActiveCalls()
-        val jsonArray = JSONArray()
-        calls.forEach {
-            jsonArray.put(it.toJsonObject())
+            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)
+            }
         }
-        val result = jsonArray.toString()
-        Log.d(TAG, "Current call state: $result")
-        return result
     }
 
-    // --- Incoming Call Management ---
+    // --- Call Management (Fixed Context Issues) ---
     fun reportIncomingCall(
         context: Context,
         callId: String,
@@ -267,10 +323,9 @@ object CallEngine {
         pictureUrl: String? = null,
         metadata: String? = null
     ) {
-        appContext = context.applicationContext
+        ensureInitialized()
         Log.d(TAG, "reportIncomingCall: callId=$callId, type=$callType, name=$displayName")
 
-        // Store metadata separately if provided
         metadata?.let { callMetadata[callId] = it }
 
         // Check for call collision
@@ -302,6 +357,9 @@ object CallEngine {
         currentCallId = callId
         Log.d(TAG, "Call $callId added to activeCalls. State: INCOMING, callType: $callType")
 
+        // Start foreground service FIRST
+        startForegroundService(context)
+
         showIncomingCallUI(context, callId, displayName, callType)
         registerPhoneAccount(context)
 
@@ -317,7 +375,6 @@ object CallEngine {
 
         try {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
-            startForegroundService(context)
             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)
@@ -330,7 +387,6 @@ object CallEngine {
         updateLockScreenBypass()
     }
 
-    // --- Outgoing Call Management ---
     fun startOutgoingCall(
         context: Context,
         callId: String,
@@ -338,7 +394,7 @@ object CallEngine {
         targetName: String,
         metadata: String? = null
     ) {
-        appContext = context.applicationContext
+        ensureInitialized()
         Log.d(TAG, "startOutgoingCall: callId=$callId, type=$callType, target=$targetName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -366,6 +422,9 @@ object CallEngine {
         currentCallId = callId
         Log.d(TAG, "Call $callId added to activeCalls. State: DIALING, callType: $callType")
 
+        // Start foreground service FIRST
+        startForegroundService(context)
+
         registerPhoneAccount(context)
         val telecomManager = context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager
         val phoneAccountHandle = getPhoneAccountHandle(context)
@@ -382,7 +441,6 @@ object CallEngine {
 
         try {
             telecomManager.placeCall(addressUri, extras)
-            startForegroundService(context)
             Log.d(TAG, "Successfully reported outgoing call to TelecomManager via placeCall for $callId")
 
             requestAudioFocus()
@@ -401,7 +459,7 @@ object CallEngine {
         updateLockScreenBypass()
     }
 
-    // NEW: Start call as active (not dialing)
+    // Fixed: startCall now properly initializes context and starts foreground service
     fun startCall(
         context: Context,
         callId: String,
@@ -409,7 +467,7 @@ object CallEngine {
         targetName: String,
         metadata: String? = null
     ) {
-        appContext = context.applicationContext
+        ensureInitialized()
         Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -432,10 +490,12 @@ object CallEngine {
         currentCallId = callId
         Log.d(TAG, "Call $callId started as ACTIVE, callType: $callType")
 
+        // Start foreground service FIRST
+        startForegroundService(context)
+
         registerPhoneAccount(context)
         requestAudioFocus()
         bringAppToForeground(context)
-        startForegroundService(context)
         keepScreenAwake(context, true)
         setInitialAudioRoute(context, callType)
         updateLockScreenBypass()
@@ -444,13 +504,15 @@ object CallEngine {
         emitCallAnsweredWithMetadata(callId)
     }
 
-    // --- Call Answer Management ---
+    // Fixed: Context management for all operations
     fun callAnsweredFromJS(context: Context, callId: String) {
+        ensureInitialized()
         Log.d(TAG, "callAnsweredFromJS: $callId - remote party answered")
         coreCallAnswered(context, callId, isLocalAnswer = false)
     }
 
     fun answerCall(context: Context, callId: String) {
+        ensureInitialized()
         Log.d(TAG, "answerCall: $callId - local party answering")
         coreCallAnswered(context, callId, isLocalAnswer = true)
     }
@@ -513,13 +575,13 @@ object CallEngine {
         })
     }
 
-    // --- Call Control Methods ---
     fun holdCall(context: Context, callId: String) {
+        ensureInitialized()
         holdCallInternal(callId, heldBySystem = false)
     }
 
-    // NEW: Set hold state from JS
     fun setOnHold(context: Context, callId: String, onHold: Boolean) {
+        ensureInitialized()
         Log.d(TAG, "setOnHold: $callId, onHold: $onHold")
 
         val callInfo = activeCalls[callId]
@@ -561,6 +623,7 @@ object CallEngine {
     }
 
     fun unholdCall(context: Context, callId: String) {
+        ensureInitialized()
         unholdCallInternal(callId, resumedBySystem = false)
     }
 
@@ -572,10 +635,12 @@ object CallEngine {
             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")
@@ -600,15 +665,17 @@ object CallEngine {
     }
 
     fun muteCall(context: Context, callId: String) {
+        ensureInitialized()
         setMutedInternal(context, callId, true)
     }
 
     fun unmuteCall(context: Context, callId: String) {
+        ensureInitialized()
         setMutedInternal(context, callId, false)
     }
 
-    // NEW: Set mute state from JS
     fun setMuted(context: Context, callId: String, muted: Boolean) {
+        ensureInitialized()
         Log.d(TAG, "setMuted: $callId, muted: $muted")
         setMutedInternal(context, callId, muted)
     }
@@ -633,15 +700,14 @@ object CallEngine {
         }
     }
 
-    // --- Call End Management ---
     fun endCall(context: Context, callId: String) {
-        appContext = context.applicationContext
+        ensureInitialized()
         Log.d(TAG, "endCall: $callId")
         endCallInternal(callId)
     }
 
-    // NEW: End all calls
     fun endAllCalls(context: Context) {
+        ensureInitialized()
         Log.d(TAG, "endAllCalls: Ending all active calls.")
         if (activeCalls.isEmpty()) {
             Log.d(TAG, "No active calls, nothing to do.")
@@ -715,13 +781,17 @@ object CallEngine {
         })
     }
 
+    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 = appContext ?: run {
-            Log.e(TAG, "getAudioDevices: appContext is not set. Returning default.")
-            return AudioRoutesInfo(emptyArray(), "Unknown")
-        }
-
+        val context = ensureInitialized()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
             Log.e(TAG, "getAudioDevices: AudioManager is null. Returning default.")
             return AudioRoutesInfo(emptyArray(), "Unknown")
@@ -765,6 +835,7 @@ object CallEngine {
     }
 
     fun setAudioRoute(context: Context, route: String) {
+        ensureInitialized()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         Log.d(TAG, "Attempting to set audio route to: $route. Current mode: ${audioManager?.mode}")
 
@@ -856,14 +927,15 @@ object CallEngine {
         }
     }
 
-    fun registerAudioDeviceCallback(context: Context) {
-        appContext = context.applicationContext
+    private fun registerAudioDeviceCallback() {
+        val context = appContext ?: return
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         audioManager?.registerAudioDeviceCallback(audioDeviceCallback, null)
         Log.d(TAG, "Audio device callback registered.")
     }
 
-    fun unregisterAudioDeviceCallback(context: Context) {
+    private fun unregisterAudioDeviceCallback() {
+        val context = appContext ?: return
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
         Log.d(TAG, "Audio device callback unregistered.")
@@ -942,6 +1014,63 @@ object CallEngine {
         })
     }
 
+    // --- 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) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -957,7 +1086,7 @@ object CallEngine {
 
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
                 channel.setSound(
-                    RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE),
+                    android.media.RingtoneManager.getDefaultUri(android.media.RingtoneManager.TYPE_RINGTONE),
                     AudioAttributes.Builder()
                         .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
                         .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
@@ -1010,20 +1139,20 @@ object CallEngine {
 
         val notification = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             val person = android.app.Person.Builder().setName(callerName).setImportant(true).build()
-            Notification.Builder(context, NOTIF_CHANNEL_ID)
+            android.app.Notification.Builder(context, NOTIF_CHANNEL_ID)
                 .setSmallIcon(android.R.drawable.sym_call_incoming)
-                .setStyle(Notification.CallStyle.forIncomingCall(person, declinePendingIntent, answerPendingIntent))
+                .setStyle(android.app.Notification.CallStyle.forIncomingCall(person, declinePendingIntent, answerPendingIntent))
                 .setFullScreenIntent(fullScreenPendingIntent, true)
                 .setOngoing(true)
                 .setAutoCancel(false)
                 .build()
         } else {
-            Notification.Builder(context, NOTIF_CHANNEL_ID)
+            android.app.Notification.Builder(context, NOTIF_CHANNEL_ID)
                 .setSmallIcon(android.R.drawable.sym_call_incoming)
                 .setContentTitle("Incoming Call")
                 .setContentText(callerName)
-                .setPriority(Notification.PRIORITY_HIGH)
-                .setCategory(Notification.CATEGORY_CALL)
+                .setPriority(android.app.Notification.PRIORITY_HIGH)
+                .setCategory(android.app.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)
@@ -1048,38 +1177,6 @@ object CallEngine {
         stopRingtone()
     }
 
-    // --- Service Management ---
-    fun startForegroundService(context: Context) {
-        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)
-        }
-    }
-
-    fun stopForegroundService(context: Context) {
-        Log.d(TAG, "Stopping CallForegroundService.")
-        val intent = Intent(context, CallForegroundService::class.java)
-        context.stopService(intent)
-    }
-
     fun bringAppToForeground(context: Context) {
         val packageName = context.packageName
         val launchIntent = context.packageManager.getLaunchIntentForPackage(packageName)
@@ -1096,7 +1193,7 @@ object CallEngine {
 
         try {
             context.startActivity(launchIntent)
-            Handler(Looper.getMainLooper()).postDelayed({
+            serviceHandler.postDelayed({
                 updateLockScreenBypass()
             }, 100)
         } catch (e: Exception) {
@@ -1143,8 +1240,8 @@ object CallEngine {
 
         try {
             Log.d(TAG, "Playing ringtone (for Android < S).")
-            val uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
-            ringtone = RingtoneManager.getRingtone(context, uri)
+            val uri = android.media.RingtoneManager.getDefaultUri(android.media.RingtoneManager.TYPE_RINGTONE)
+            ringtone = android.media.RingtoneManager.getRingtone(context, uri)
             ringtone?.audioAttributes = AudioAttributes.Builder()
                 .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
                 .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
@@ -1211,33 +1308,48 @@ object CallEngine {
         }
     }
 
-    private fun updateForegroundNotification() {
-        val context = appContext ?: return
-        val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
-        val heldCall = activeCalls.values.find { it.state == CallState.HELD }
+    // --- Cleanup ---
+    private fun cleanup() {
+        Log.d(TAG, "Cleaning up CallEngine")
 
-        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)
+        // End all calls
+        activeCalls.keys.toList().forEach { callId ->
+            endCallInternal(callId)
+        }
 
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(intent)
-            } else {
-                context.startService(intent)
-            }
+        // Clear all collections
+        activeCalls.clear()
+        telecomConnections.clear()
+        callMetadata.clear()
+        lockScreenBypassCallbacks.clear()
+        cachedEvents.clear()
+
+        // Stop media
+        stopRingtone()
+        stopRingback()
+
+        // Release resources
+        wakeLock?.let {
+            if (it.isHeld) it.release()
         }
-    }
+        wakeLock = null
 
-    private fun finalCleanup(context: Context) {
-        Log.d(TAG, "Performing final cleanup - no active calls remaining")
-        stopForegroundService(context)
-        keepScreenAwake(context, false)
-        resetAudioMode(context)
+        // Audio cleanup
+        abandonAudioFocus()
+        appContext?.let {
+            resetAudioMode(it)
+            unregisterAudioDeviceCallback()
+        }
+
+        // Service cleanup
+        appContext?.let { stopForegroundService(it) }
+
+        currentCallId = null
+        lockScreenBypassActive = false
+        hasAudioFocus = false
         isSystemCallActive = false
+        isServiceRunning = false
+
+        Log.d(TAG, "CallEngine cleanup completed")
     }
 }

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

@@ -29,6 +29,7 @@ class CallForegroundService : Service() {
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
         Log.d(TAG, "Service onStartCommand")
 
+        val isUpdate = intent?.getBooleanExtra("UPDATE_NOTIFICATION", false) ?: false
         val callId = intent?.getStringExtra("callId")
         val callType = intent?.getStringExtra("callType")
         val displayName = intent?.getStringExtra("displayName")
@@ -42,7 +43,13 @@ class CallForegroundService : Service() {
             buildBasicNotification()
         }
 
-        startForeground(NOTIFICATION_ID, notification)
+        if (!isUpdate) {
+            startForeground(NOTIFICATION_ID, notification)
+        } else {
+            val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.notify(NOTIFICATION_ID, notification)
+        }
+
         return START_STICKY
     }
 
@@ -172,7 +179,11 @@ class CallForegroundService : Service() {
 
     override fun onTaskRemoved(rootIntent: Intent?) {
         Log.d(TAG, "onTaskRemoved: User swiped app from recents. Ending all calls.")
-        CallEngine.endAllCalls(this)
+        try {
+            CallEngine.endAllCalls(this)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error ending calls on task removed: ${e.message}", e)
+        }
         super.onTaskRemoved(rootIntent)
         stopSelf()
     }

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

@@ -10,47 +10,57 @@ class CallManager : HybridCallManagerSpec() {
 
     override fun endCall(callId: String) {
         Log.d(TAG, "endCall requested for callId: $callId")
-        CallEngine.getAppContext()?.let {
-            CallEngine.endCall(it, callId)
-        } ?: Log.e(TAG, "App context not set for endCall.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.endCall(context, callId)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun endAllCalls() {
         Log.d(TAG, "endAllCalls requested")
-        CallEngine.getAppContext()?.let {
-            CallEngine.endAllCalls(it)
-        } ?: Log.e(TAG, "App context not set for endAllCalls.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.endAllCalls(context)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun silenceRingtone() {
         Log.d(TAG, "silenceRingtone requested.")
-        CallEngine.getAppContext()?.let {
-            CallEngine.stopRingtone()
-        } ?: Log.e(TAG, "App context not set for silenceRingtone.")
+        CallEngine.stopRingtone()
     }
 
     override fun getAudioDevices(): AudioRoutesInfo {
         Log.d(TAG, "getAudioDevices requested.")
-        return CallEngine.getAppContext()?.let {
+        return try {
             CallEngine.getAudioDevices()
-        } ?: run {
-            Log.e(TAG, "App context not set for getAudioDevices. Returning empty AudioRoutesInfo.")
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
             AudioRoutesInfo(emptyArray(), "Unknown")
         }
     }
 
     override fun setAudioRoute(route: String) {
         Log.d(TAG, "setAudioRoute requested for route: $route")
-        CallEngine.getAppContext()?.let {
-            CallEngine.setAudioRoute(it, route)
-        } ?: Log.e(TAG, "App context not set for setAudioRoute.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.setAudioRoute(context, route)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun keepScreenAwake(keepAwake: Boolean) {
         Log.d(TAG, "keepScreenAwake requested: $keepAwake")
-        CallEngine.getAppContext()?.let {
-            CallEngine.keepScreenAwake(it, keepAwake)
-        } ?: Log.e(TAG, "App context not set for keepAwake.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.keepScreenAwake(context, keepAwake)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun addListener(
@@ -66,36 +76,51 @@ class CallManager : HybridCallManagerSpec() {
 
     override fun startOutgoingCall(callId: String, callType: String, targetName: String, metadata: String?) {
         Log.d(TAG, "startOutgoingCall requested: callId=$callId, callType=$callType, targetName=$targetName")
-        CallEngine.getAppContext()?.let {
-            CallEngine.startOutgoingCall(it, callId, callType, targetName, metadata)
-        } ?: Log.e(TAG, "App context not set for startOutgoingCall.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.startOutgoingCall(context, callId, callType, targetName, metadata)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun startCall(callId: String, callType: String, targetName: String, metadata: String?) {
         Log.d(TAG, "startCall requested: callId=$callId, callType=$callType, targetName=$targetName")
-        CallEngine.getAppContext()?.let {
-            CallEngine.startCall(it, callId, callType, targetName, metadata)
-        } ?: Log.e(TAG, "App context not set for startCall.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.startCall(context, callId, callType, targetName, metadata)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun callAnswered(callId: String) {
         Log.d(TAG, "callAnswered (from JS) requested for callId: $callId")
-        CallEngine.getAppContext()?.let {
-            CallEngine.callAnsweredFromJS(it, callId)
-        } ?: Log.e(TAG, "App context not set for callAnswered.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.callAnsweredFromJS(context, callId)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun setOnHold(callId: String, onHold: Boolean) {
         Log.d(TAG, "setOnHold requested for callId: $callId, onHold: $onHold")
-        CallEngine.getAppContext()?.let {
-            CallEngine.setOnHold(it, callId, onHold)
-        } ?: Log.e(TAG, "App context not set for setOnHold.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.setOnHold(context, callId, onHold)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 
     override fun setMuted(callId: String, muted: Boolean) {
         Log.d(TAG, "setMuted requested for callId: $callId, muted: $muted")
-        CallEngine.getAppContext()?.let {
-            CallEngine.setMuted(it, callId, muted)
-        } ?: Log.e(TAG, "App context not set for setMuted.")
+        try {
+            val context = CallEngine.ensureInitialized()
+            CallEngine.setMuted(context, callId, muted)
+        } catch (e: IllegalStateException) {
+            Log.e(TAG, "CallEngine not initialized: ${e.message}")
+        }
     }
 }

package/package.json

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