@qusaieilouti99/call-manager 0.1.56 → 0.1.58

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

@@ -1,6 +1,7 @@
 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
@@ -46,19 +47,20 @@ object CallEngine {
     private const val FOREGROUND_CHANNEL_ID = "call_foreground_channel"
     private const val FOREGROUND_NOTIF_ID = 1001
 
+    // Core context - initialized once and maintained
+    private var appContext: Context? = null
+    private var isInitialized = AtomicBoolean(false)
+
     // Audio & Media
     private var ringtone: android.media.Ringtone? = null
     private var ringbackPlayer: MediaPlayer? = null
     private var audioManager: AudioManager? = null
     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
     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
@@ -66,7 +68,6 @@ object CallEngine {
 
     // Audio State Tracking
     private var lastAudioRoutesInfo: AudioRoutesInfo? = null
-    private var lastMuteState: Boolean = false
     private var hasAudioFocus: Boolean = false
     private var isSystemCallActive: Boolean = false
 
@@ -78,56 +79,92 @@ object CallEngine {
     private var eventHandler: ((CallEventType, String) -> Unit)? = null
     private val cachedEvents = mutableListOf<Pair<CallEventType, String>>()
 
-    // Operation State
-    private val operationInProgress = AtomicBoolean(false)
-
     interface LockScreenBypassCallback {
         fun onLockScreenBypassChanged(shouldBypass: Boolean)
     }
 
-    // --- Audio Focus Management ---
+    // --- 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")
+
+            // Initialize foreground service if needed
+            if (isCallActive()) {
+                startForegroundService()
+            }
+        }
+    }
+
+    fun isInitialized(): Boolean = isInitialized.get()
+
+    private fun requireContext(): Context {
+        return appContext ?: throw IllegalStateException("CallEngine not initialized. Call initialize() first.")
+    }
+
+    // --- 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 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 (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
-
-        Handler(Looper.getMainLooper()).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 = appContext ?: return false
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
 
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -160,45 +197,20 @@ object CallEngine {
     }
 
     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()
-            }
-        }
-    }
-
-    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))
-        }
-    }
-
     // --- Lock Screen Bypass Management ---
     fun registerLockScreenBypassCallback(callback: LockScreenBypassCallback) {
         lockScreenBypassCallbacks.add(callback)
@@ -239,8 +251,6 @@ object CallEngine {
 
     fun getTelecomConnection(callId: String): Connection? = telecomConnections[callId]
 
-    fun getAppContext(): Context? = appContext
-
     // --- Public API ---
     fun setCanMakeMultipleCalls(allow: Boolean) {
         canMakeMultipleCalls = allow
@@ -267,10 +277,12 @@ object CallEngine {
         pictureUrl: String? = null,
         metadata: String? = null
     ) {
-        appContext = context.applicationContext
+        if (!isInitialized.get()) {
+            initialize(context)
+        }
+
         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,11 +314,11 @@ object CallEngine {
         currentCallId = callId
         Log.d(TAG, "Call $callId added to activeCalls. State: INCOMING, callType: $callType")
 
-        showIncomingCallUI(context, callId, displayName, callType)
-        registerPhoneAccount(context)
+        showIncomingCallUI(callId, displayName, callType)
+        registerPhoneAccount()
 
-        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)
@@ -317,7 +329,7 @@ object CallEngine {
 
         try {
             telecomManager.addNewIncomingCall(phoneAccountHandle, extras)
-            startForegroundService(context)
+            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)
@@ -332,13 +344,12 @@ object CallEngine {
 
     // --- Outgoing Call Management ---
     fun startOutgoingCall(
-        context: Context,
         callId: String,
         callType: String,
         targetName: String,
         metadata: String? = null
     ) {
-        appContext = context.applicationContext
+        val context = requireContext()
         Log.d(TAG, "startOutgoingCall: callId=$callId, type=$callType, target=$targetName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -366,9 +377,9 @@ object CallEngine {
         currentCallId = callId
         Log.d(TAG, "Call $callId added to activeCalls. State: DIALING, callType: $callType")
 
-        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 {
@@ -382,14 +393,13 @@ object CallEngine {
 
         try {
             telecomManager.placeCall(addressUri, extras)
-            startForegroundService(context)
-            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)
@@ -401,15 +411,14 @@ object CallEngine {
         updateLockScreenBypass()
     }
 
-    // NEW: Start call as active (not dialing)
+    // Fixed: Start call as active (not dialing) with foreground service
     fun startCall(
-        context: Context,
         callId: String,
         callType: String,
         targetName: String,
         metadata: String? = null
     ) {
-        appContext = context.applicationContext
+        val context = requireContext()
         Log.d(TAG, "startCall: callId=$callId, type=$callType, target=$targetName")
 
         metadata?.let { callMetadata[callId] = it }
@@ -432,12 +441,12 @@ object CallEngine {
         currentCallId = callId
         Log.d(TAG, "Call $callId started as ACTIVE, callType: $callType")
 
-        registerPhoneAccount(context)
+        registerPhoneAccount()
         requestAudioFocus()
-        bringAppToForeground(context)
-        startForegroundService(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
@@ -445,17 +454,18 @@ object CallEngine {
     }
 
     // --- Call Answer Management ---
-    fun callAnsweredFromJS(context: Context, callId: String) {
+    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) {
+    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]
@@ -466,7 +476,7 @@ object CallEngine {
 
         stopRingtone()
         stopRingback()
-        cancelIncomingCallUI(context)
+        cancelIncomingCallUI()
         requestAudioFocus()
 
         activeCalls[callId] = callInfo.copy(state = CallState.ACTIVE)
@@ -480,10 +490,10 @@ object CallEngine {
             }
         }
 
-        bringAppToForeground(context)
-        startForegroundService(context)
-        keepScreenAwake(context, true)
-        resetAudioMode(context)
+        bringAppToForeground()
+        startForegroundService() // Fixed: Ensure foreground service is running
+        keepScreenAwake(true)
+        resetAudioMode()
         updateLockScreenBypass()
         updateForegroundNotification()
 
@@ -514,12 +524,11 @@ object CallEngine {
     }
 
     // --- Call Control Methods ---
-    fun holdCall(context: Context, callId: String) {
+    fun holdCall(callId: String) {
         holdCallInternal(callId, heldBySystem = false)
     }
 
-    // NEW: Set hold state from JS
-    fun setOnHold(context: Context, callId: String, onHold: Boolean) {
+    fun setOnHold(callId: String, onHold: Boolean) {
         Log.d(TAG, "setOnHold: $callId, onHold: $onHold")
 
         val callInfo = activeCalls[callId]
@@ -560,7 +569,7 @@ object CallEngine {
         updateLockScreenBypass()
     }
 
-    fun unholdCall(context: Context, callId: String) {
+    fun unholdCall(callId: String) {
         unholdCallInternal(callId, resumedBySystem = false)
     }
 
@@ -572,16 +581,10 @@ object CallEngine {
             return
         }
 
-        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")
-                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(
@@ -599,21 +602,21 @@ object CallEngine {
         Log.d(TAG, "Call $callId successfully unheld")
     }
 
-    fun muteCall(context: Context, callId: String) {
-        setMutedInternal(context, callId, true)
+    fun muteCall(callId: String) {
+        setMutedInternal(callId, true)
     }
 
-    fun unmuteCall(context: Context, callId: String) {
-        setMutedInternal(context, callId, false)
+    fun unmuteCall(callId: String) {
+        setMutedInternal(callId, false)
     }
 
-    // NEW: Set mute state from JS
-    fun setMuted(context: Context, callId: String, muted: Boolean) {
+    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")
@@ -626,7 +629,6 @@ object CallEngine {
         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")
@@ -634,14 +636,12 @@ object CallEngine {
     }
 
     // --- Call End Management ---
-    fun endCall(context: Context, callId: String) {
-        appContext = context.applicationContext
+    fun endCall(callId: String) {
         Log.d(TAG, "endCall: $callId")
         endCallInternal(callId)
     }
 
-    // NEW: End all calls
-    fun endAllCalls(context: Context) {
+    fun endAllCalls() {
         Log.d(TAG, "endAllCalls: Ending all active calls.")
         if (activeCalls.isEmpty()) {
             Log.d(TAG, "No active calls, nothing to do.")
@@ -657,7 +657,7 @@ object CallEngine {
         callMetadata.clear()
         currentCallId = null
 
-        finalCleanup(context)
+        finalCleanup()
         updateLockScreenBypass()
     }
 
@@ -678,7 +678,7 @@ object CallEngine {
 
         stopRingback()
         stopRingtone()
-        appContext?.let { cancelIncomingCallUI(it) }
+        cancelIncomingCallUI()
 
         if (currentCallId == callId) {
             currentCallId = activeCalls.filter { it.value.state != CallState.ENDED }.keys.firstOrNull()
@@ -694,7 +694,7 @@ object CallEngine {
         }
 
         if (activeCalls.isEmpty()) {
-            appContext?.let { finalCleanup(it) }
+            finalCleanup()
         } else {
             updateForegroundNotification()
         }
@@ -717,11 +717,7 @@ object CallEngine {
 
     // --- 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 = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
             Log.e(TAG, "getAudioDevices: AudioManager is null. Returning default.")
             return AudioRoutesInfo(emptyArray(), "Unknown")
@@ -764,7 +760,8 @@ object CallEngine {
         return result
     }
 
-    fun setAudioRoute(context: Context, route: String) {
+    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}")
 
@@ -815,7 +812,7 @@ object CallEngine {
         }
     }
 
-    private fun setInitialAudioRoute(context: Context, callType: String) {
+    private fun setInitialAudioRoute(callType: String) {
         val availableDevices = getAudioDevices()
 
         val defaultRoute = when {
@@ -826,10 +823,11 @@ object CallEngine {
         }
 
         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.")
@@ -856,14 +854,15 @@ object CallEngine {
         }
     }
 
-    fun registerAudioDeviceCallback(context: Context) {
-        appContext = context.applicationContext
+    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.")
     }
 
-    fun unregisterAudioDeviceCallback(context: Context) {
+    fun unregisterAudioDeviceCallback() {
+        val context = requireContext()
         audioManager = audioManager ?: context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         audioManager?.unregisterAudioDeviceCallback(audioDeviceCallback)
         Log.d(TAG, "Audio device callback unregistered.")
@@ -886,7 +885,8 @@ object CallEngine {
     }
 
     // --- 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) {
@@ -943,7 +943,8 @@ object CallEngine {
     }
 
     // --- 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,
@@ -974,9 +975,10 @@ object CallEngine {
         }
     }
 
-    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 {
@@ -1035,13 +1037,14 @@ object CallEngine {
         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)
@@ -1049,7 +1052,8 @@ object CallEngine {
     }
 
     // --- Service Management ---
-    fun startForegroundService(context: Context) {
+    private fun startForegroundService() {
+        val context = requireContext()
         Log.d(TAG, "Starting CallForegroundService.")
 
         val currentCall = activeCalls.values.find {
@@ -1074,13 +1078,15 @@ object CallEngine {
         }
     }
 
-    fun stopForegroundService(context: Context) {
+    private fun stopForegroundService() {
+        val context = requireContext()
         Log.d(TAG, "Stopping CallForegroundService.")
         val intent = Intent(context, CallForegroundService::class.java)
         context.stopService(intent)
     }
 
-    fun bringAppToForeground(context: Context) {
+    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)
@@ -1105,9 +1111,10 @@ object CallEngine {
     }
 
     // --- 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")
@@ -1127,7 +1134,8 @@ object CallEngine {
         }
     }
 
-    private fun getPhoneAccountHandle(context: Context): PhoneAccountHandle {
+    private fun getPhoneAccountHandle(): PhoneAccountHandle {
+        val context = requireContext()
         return PhoneAccountHandle(
             ComponentName(context, MyConnectionService::class.java),
             PHONE_ACCOUNT_ID
@@ -1135,7 +1143,8 @@ object CallEngine {
     }
 
     // --- 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
@@ -1155,7 +1164,7 @@ object CallEngine {
         }
     }
 
-    fun stopRingtone() {
+    private fun stopRingtone() {
         try {
             if (ringtone?.isPlaying == true) {
                 ringtone?.stop()
@@ -1168,14 +1177,15 @@ object CallEngine {
     }
 
     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
@@ -1212,7 +1222,7 @@ object CallEngine {
     }
 
     private fun updateForegroundNotification() {
-        val context = appContext ?: return
+        val context = requireContext()
         val activeCall = activeCalls.values.find { it.state == CallState.ACTIVE }
         val heldCall = activeCalls.values.find { it.state == CallState.HELD }
 
@@ -1233,11 +1243,41 @@ object CallEngine {
         }
     }
 
-    private fun finalCleanup(context: Context) {
+    private fun finalCleanup() {
         Log.d(TAG, "Performing final cleanup - no active calls remaining")
-        stopForegroundService(context)
-        keepScreenAwake(context, false)
-        resetAudioMode(context)
+        stopForegroundService()
+        keepScreenAwake(false)
+        resetAudioMode()
         isSystemCallActive = false
     }
+
+    // --- Lifecycle Management ---
+    fun onApplicationTerminate() {
+        Log.d(TAG, "Application terminating - cleaning up all calls")
+
+        // End all calls properly
+        activeCalls.keys.toList().forEach { callId ->
+            val connection = telecomConnections[callId]
+            connection?.setDisconnected(DisconnectCause(DisconnectCause.LOCAL))
+            connection?.destroy()
+        }
+
+        // Clear all state
+        activeCalls.clear()
+        telecomConnections.clear()
+        callMetadata.clear()
+        currentCallId = null
+
+        // Release resources
+        finalCleanup()
+
+        // Clear callbacks
+        lockScreenBypassCallbacks.clear()
+        eventHandler = null
+        cachedEvents.clear()
+
+        // Reset initialization
+        isInitialized.set(false)
+        appContext = null
+    }
 }

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

@@ -172,7 +172,7 @@ class CallForegroundService : Service() {
 
     override fun onTaskRemoved(rootIntent: Intent?) {
         Log.d(TAG, "onTaskRemoved: User swiped app from recents. Ending all calls.")
-        CallEngine.endAllCalls(this)
+        CallEngine.onApplicationTerminate()
         super.onTaskRemoved(rootIntent)
         stopSelf()
     }
@@ -181,5 +181,10 @@ class CallForegroundService : Service() {
         super.onDestroy()
         Log.d(TAG, "Service onDestroy. Stopping foreground.")
         stopForeground(true)
+
+        // Additional cleanup when service is destroyed
+        if (!CallEngine.isCallActive()) {
+            CallEngine.onApplicationTerminate()
+        }
     }
 }

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

@@ -8,55 +8,72 @@ class CallManager : HybridCallManagerSpec() {
 
     private val TAG = "CallManager"
 
+    init {
+        // Initialize CallEngine as soon as CallManager is created
+        try {
+            val context = com.facebook.react.bridge.ReactApplicationContext.getCurrentApplication()
+            if (context != null) {
+                CallEngine.initialize(context.applicationContext)
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not initialize CallEngine in init, will try during first call")
+        }
+    }
+
+    private fun ensureInitialized() {
+        if (!CallEngine.isInitialized()) {
+            try {
+                val context = com.facebook.react.bridge.ReactApplicationContext.getCurrentApplication()
+                    ?: throw IllegalStateException("No application context available")
+                CallEngine.initialize(context.applicationContext)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to initialize CallEngine: ${e.message}", e)
+                throw IllegalStateException("CallEngine not initialized and cannot initialize: ${e.message}")
+            }
+        }
+    }
+
     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.")
+        ensureInitialized()
+        CallEngine.endCall(callId)
     }
 
     override fun endAllCalls() {
         Log.d(TAG, "endAllCalls requested")
-        CallEngine.getAppContext()?.let {
-            CallEngine.endAllCalls(it)
-        } ?: Log.e(TAG, "App context not set for endAllCalls.")
+        ensureInitialized()
+        CallEngine.endAllCalls()
     }
 
     override fun silenceRingtone() {
         Log.d(TAG, "silenceRingtone requested.")
-        CallEngine.getAppContext()?.let {
-            CallEngine.stopRingtone()
-        } ?: Log.e(TAG, "App context not set for silenceRingtone.")
+        ensureInitialized()
+        CallEngine.stopRingtone()
     }
 
     override fun getAudioDevices(): AudioRoutesInfo {
         Log.d(TAG, "getAudioDevices requested.")
-        return CallEngine.getAppContext()?.let {
-            CallEngine.getAudioDevices()
-        } ?: run {
-            Log.e(TAG, "App context not set for getAudioDevices. Returning empty AudioRoutesInfo.")
-            AudioRoutesInfo(emptyArray(), "Unknown")
-        }
+        ensureInitialized()
+        return CallEngine.getAudioDevices()
     }
 
     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.")
+        ensureInitialized()
+        CallEngine.setAudioRoute(route)
     }
 
     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.")
+        ensureInitialized()
+        CallEngine.keepScreenAwake(keepAwake)
     }
 
     override fun addListener(
         listener: (event: CallEventType, payload: String) -> Unit
     ): () -> Unit {
         Log.d(TAG, "addListener called with listener: $listener")
+        ensureInitialized()
         CallEngine.setEventHandler(listener)
         return {
             CallEngine.setEventHandler(null)
@@ -66,36 +83,31 @@ 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.")
+        ensureInitialized()
+        CallEngine.startOutgoingCall(callId, callType, targetName, metadata)
     }
 
     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.")
+        ensureInitialized()
+        CallEngine.startCall(callId, callType, targetName, metadata)
     }
 
     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.")
+        ensureInitialized()
+        CallEngine.callAnsweredFromJS(callId)
     }
 
     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.")
+        ensureInitialized()
+        CallEngine.setOnHold(callId, onHold)
     }
 
     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.")
+        ensureInitialized()
+        CallEngine.setMuted(callId, muted)
     }
 }

package/package.json

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